Question

I should write function that takes list, element and return positions in with such element occurs. Like,

pos 2 [1, 2, 3, 2] -> [2, 4]
pos 1 [1, 2, 3, 2] -> [1]
pos 8 [1, 2, 3, 2] -> []

This what I’ve done.

--findFirstPosition :: Eq a => a -> [a] -> Maybe a
findFirstPosition val xs = case f of 
    Nothing -> Nothing 
    Just (v, i) -> Just(i)
  where f = (find (\ (v, i) -> val == v) (zip xs [1..]))

--pos :: Eq a => a -> [a] -> [Int]
pos _ [] = []
pos val xs = if (finded) 
    then concat[
           [fromJust res],
            map (\a -> a + (fromJust res)) 
            (pos val (drop  (fromJust res) xs))]
    else []  
  where 
    res = findFirstPosition val xs
    finded = (isJust res)

It’s works quite good. But when I’m trying to use functions type (like shown in comments) error occurs

Could not deduce (a ~ Int)
from the context (Eq a)
  bound by the type signature for pos :: Eq a => a -> [a] -> [Int]
  at \test.hs:(63,1)-(72,29)
  `a' is a rigid type variable bound by
      the type signature for pos :: Eq a => a -> [a] -> [Int]
      at \test.hs:63:1
Expected type: Maybe Int
  Actual type: Maybe a
In the first argument of `fromJust', namely `res'
In the first argument of `drop', namely `(fromJust res)'

How should I deal with it? Also any additional code review comments are highly appreciated.

Upd
I should implement it using find function.

Answer 1

The type of findFirstPosition should be

findFirstPosition :: Eq a => a -> [a] -> Maybe Int

The purpose of this function is to find a position, or index. So the return type should wrap something appropriate for indexing, but independent of the argument type(s).

Unrelated: are you sure that indexing should start with 1? Usual is 0-based indexing.