[Haskell-cafe] The Trivial Monad

[Thomas Davie]

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
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/haskell-cafe/attachments/20070504/00492c47/attachment.htm