Определить рекурсивные функции для решения задачи

task :: Ord a => [a] -> Int
task l = let m = minimum l in length $ filter (==m) l

task :: Ord a => [a] -> Int
task l@(h:t) =  let minim i (x:xs) | x<i = minim x xs
                                   | otherwise = minim i xs
                    minim i _ = i
                    m = minim h t
                    go n (x:xs) | x==m = go (n+1) xs
                                | otherwise = go n xs
                    go n _ = n
                in go 0 l
task [] = error "empty list"

f []                 = error "Empty list"
f [x]                = (x, 1)
f (x:xs) | x< m      = (x, 1)
         | x==m      = (x, i+1)
         | otherwise = (m, i) where
         (m, i) = f xs
         
task = snd . f

task :: Ord a => [a] -> Int
task [] = error "empty list"
task (h:t) = go 1 h t
    where go n _ [] = n
          go n m (x:xs) | x<m = go 1 x xs
                        | x==m = go (n+1) x xs
                        | otherwise = go n m xs

task' [] _ c = c
task' (x:xs) m c | x == m    = task' xs m (c+1)
                 | x <  m    = task' xs x 1
                 | otherwise = task' xs m c
 
task [x] = 1
task (x:xs) = task' xs x 1   
 
*Main> task [1,2,3,1,1,2]
3
*Main> task [1,2,3,1,1,2,1,1]
5
*Main> task [1,2,3,1,1,-2,1,1]
1
*Main>