Hi,
So the way I have to reason on the output I get from ghci is:
Prelude> :t liftM2
liftM2 :: (Monad m) => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
The m stands for ((->) e), that is like writing (e -> a1): a function
which will take an argument of type e and will return an argument of
type a1.
And so the above line has a signature that reads something like:
liftM2 will takes 3 arguments:
- a function (-) that takes two arguments and returns one result of
type r.
- a function (fst) that takes one argument and returns one result.
- a function (snd) that takes one argument and returns one result.
- the result will be a certain function that will return the same type
r of the (-) function.
- Overall to this liftM2 I will actually pass two values of type a1
and a2 and will get a result of type r.
From the type signature - correct me if I am wrong - I cannot
actually
tell that liftM2 will apply (-) to the rest of the expression, I can
only make a guess. I mean I know it now that you showed me:
liftM2 f x y = do
u <- x
v <- y
return (f u v)
If this is correct and it all makes sense, my next question is:
- How do I know - or how does the interpreter know - that the "m" of
this example is an instance of type ((->) e) ?
- Is it always like that for liftM2 ? Or is it like that only because
I used the function (-) ?
I am trying to understand this bit by bit I am sorry if this is either
very basic and easy stuff, or if all I wrote is completely wrong and I
did not understand anything. :D Feedback welcome.
You can derive this yourself by assigning types to all parts of the
expression and working things out, i.e., doing the type inference
yourself. For example,
liftM2 :: T1 = T2 -> T3 -> T4 -> T5 because liftM2 consumes three
arguments. Furthermore, ghci gives you the type of liftM2, you know
the type of (-) and the types of snd and fst. Therefore,
T2 = (a -> a -> a) (type of (-))
T3 = (b,c) -> c (type of snd)
T4 = (d,e) -> d (type of fst)
and, by the type of liftM2 :: (f -> g -> h) -> m f -> m g -> m h, we
also have
T2 = (f -> g -> h)
T3 = m f
T4 = m g
T5 = m h
The two type expressions for T2 imply that f = g = h = a (type-wise,
that is). And
m f = (b,c) -> c = ((->) (b,c)) c
m g = (d,e) -> d = ((-> (d,e)) d, because f = g this reduces to ((->)
(c,c)) c
and thus : m h = (c,c) -> c, because f = g = h
This implies that the monad m = ((->) (c,c)) and h = c = a = f = g
Thus:
liftM2 (-) snd fst :: ((->) (a,a)) a = (a,a) -> a
If I made any errors, please tell me.
-- Andy
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
