Using an element against an entire list in Haskell

Question

I have an assignment and am currently caught in one section of what I'm trying to do. Without going in to specific detail here is the basic layout: I'm given a data element, f, that holds four different types inside (each with their own purpose):

data F = F Float Int, Int

a function:

func :: F -> F-> Q  

Which takes two data elements and (by simple calculations) returns a type that is now an updated version of one of the types in the first f.

I now have an entire list of these elements and need to run the given function using one data element and return the type's value (not the data element). My first analysis was to use a foldl function:

myfunc :: F -> [F] -> Q
myfunc y [] = func y y -- func deals with the same data element calls
myfunc y (x:xs) = foldl func y (x:xs)

however I keep getting the same error:

"Couldn't match expected type 'F' against inferred type 'Q'. 
In the first argument of 'foldl', namely 'myfunc'
In the expression: foldl func y (x:xs)

I apologise for such an abstract analysis on my problem but could anyone give me an idea as to what I should do? Should I even use a fold function or is there recursion I'm not thinking about?

Answer 1

The type of foldl is

foldl :: (a -> b -> a) -> a -> [b] -> a

but the type of func is

-- #      a -> b -> a
func  ::  F -> F -> Q

The type variable a cannot be simultaneously F and Q, thus the error.

---

If the Q can be converted to and from F, you could use

myfunc y xs = foldl (func . fromQ) (toQ y) xs

where

 func . fromQ :: Q -> F -> Q
        toQ y :: Q
           xs :: [F]

so this satisfies all the type requirements, and will return the final Q.

Answer 2

maybe you need map?

map :: (f -> q) -> [f] -> [q]

it evaluates a function on each element in a list and gives a list of the results. I'm not sure why your function takes two Fs though, possibly to work with foldl?