**The task:** I'm attempting to write a function with type signature `minimum_recursive :: (a -> a -> Bool) -> [a] -> a`

. For its first parameter, it accepts a function I will call `less`

that takes two parameters, and returns True if the first param is less than the second, False otherwise. `minimum_recursive`

also accepts a list as its second parameter. Using explicit recursion, `minimum_recursive`

should determine the smallest value in its input list [a].

**My thinking:** I was thinking to put the actual recursion in a helper function that also accepts an accumulator. I would call the helper function with the first item as the accumulator.

**What I have so far:** So far I have the following:

```
-- function as first parameter to min'
-- accepts two params, returns True if
-- first must come before second in sorted
-- order
less :: Ord a => a -> a -> Bool
less a b = a < b
-- Subpart B
minimum_recursive :: (a -> a -> Bool) -> [a] -> a
minimum_recursive func list = minimum_recursive_h func list []
```

**I am having trouble** figuring out how to even begin to write `minimum_recursive_h`

.

**Note:** I know there probably is an easier way to accomplish this task, but I'm required to go about it as specified above.

`n - 1`

, how would you combine it with the current element to get an answer for a list of length`n`

?`n - 1`

, then compare this to the original list's element n? I don't know the Haskell syntax for this. I'll do some research.