On 4 May 2007, at 08:43, Adrian Neumann wrote:

However I

don't understand the type signatures for bind and fmap. I'd say (and

ghci's type inference agrees) that bind and fmap have the type

bind:: (a->W b) -> W a -> W b

fmap:: (a->b) -> W a -> W b

They take a function f and something and return what f does to that. I

don't see why they should return a function.

I suggest you look up currying. In the mean time, I shall attempt an explanation.

In Haskell (as in many other functional languages), function types appear as if the function were curried. This means that a function accepts one single argument, and returns one single result. The important thing to realise though is that the result (or less importantly the argument) may be a function.

Let's study a (slightly over constrained) variant on the (+) function, with type (+) :: Int -> Int -> Int. This type signature should be read to mean:

(+) takes an Int, and returns a new function of type (Int -> Int). We can see an example of this (+ 5) -- (+) is given an argument (5), and returns a function (that adds 5 to integers).

Another way to think about it is that the (->) type constructor is right associative, so any type written as a -> b -> c -> d -> e, can also be written as a -> (b -> (c -> (d -> e))).

I hope that helped a bit, and if it didn't I suggest going and looking up currying in as many places as you can.

Bob