
Hi all, I saw this 1. instance Monad Maybe where 2. return x = Just x 3. Nothing >>= f = Nothing 4. Just x >>= f = f x 5. fail _ = Nothing I am wondering about the implementation of function (>>=). Why don't it be *Just x >>= f = Just (f x)*? Any body knows about this? --Trung

Excerpts from Trung Quang Nguyen's message of Thu Dec 20 22:07:02 +0800 2012:
Hi all,
I saw this
1. instance Monad Maybe where 2. return x = Just x 3. Nothing >>= f = Nothing 4. Just x >>= f = f x 5. fail _ = Nothing
I am wondering about the implementation of function (>>=). Why don't it be *Just x >>= f = Just (f x)*?
Try it; it won't typecheck. Cheers, Edward

On 20 Dec 2012, at 14:07, Trung Quang Nguyen
Hi all,
I saw this
instance Monad Maybe where return x = Just x Nothing >>= f = Nothing Just x >>= f = f x fail _ = Nothing
I am wondering about the implementation of function (>>=). Why don't it be Just x >>= f = Just (f x)?
Any body knows about this?
The reason is in the type of bind: (>>=) :: Monad m => m a -> (a -> m b) -> m b The function f takes a non-in-a-monad value, and gives you an in-a-monad value. Bob

Oh yes, I understand now.
Just x >>= f = f x
the output of f is actually (Monad value) like in this example
(Just 3) >>= (\x -> Just $ x^2)
At the first sight, I thought about (Monad (f x)), but it's wrong because
it will be (Monad (Monad value)) when f return.
Thanks a lot!
--Trung
2012/12/20 Tom Davie
On 20 Dec 2012, at 14:07, Trung Quang Nguyen
wrote: Hi all,
I saw this
1. instance Monad Maybe where 2. return x = Just x 3. Nothing >>= f = Nothing 4. Just x >>= f = f x 5. fail _ = Nothing
I am wondering about the implementation of function (>>=). Why don't it be *Just x >>= f = Just (f x)*?
Any body knows about this?
The reason is in the type of bind:
(>>=) :: Monad m => m a -> (a -> m b) -> m b
The function f takes a non-in-a-monad value, and gives you an in-a-monad value.
Bob
-- *Trung Nguyen* Mobile: +45 50 11 10 63 LinkedIn: http://www.linkedin.com/pub/trung-nguyen/36/a44/187 View my blog at http://www.onextrabit.com/

A 20/12/2012, às 14:07, Trung Quang Nguyen escreveu:
Hi all,
I saw this
• instance Monad Maybe where • return x = Just x • Nothing >>= f = Nothing • Just x >>= f = f x • fail _ = Nothing
I am wondering about the implementation of function (>>=). Why don't it be Just x >>= f = Just (f x)?
Any body knows about this?
That would be the implementation of fmap for Maybe: instance Functor Maybe where fmap _ Nothing = Nothing fmap f (Just a) = Just (f a) so, different behavior. best, Miguel

*fmap*http://hackage.haskell.org/packages/archive/base/latest/doc/html/Prelude.htm...
::
Functor f => (a -> b) -> f a -> f
bhttp://hackage.haskell.org/packages/archive/base/latest/doc/html/Prelude.htm...
fmap f (Just a) = Just (f a)
We wrap Just around (f a) because f return a value with type b instead
(Just b).
But in
(*>>=*)http://hackage.haskell.org/packages/archive/base/latest/doc/html/Prelude.htm...
::
Monad m => m a -> (a -> m b) -> m
bhttp://hackage.haskell.org/packages/archive/base/latest/doc/html/Prelude.htm...
Just x >>= f = f x
We don't need to wrap Just around (f a) because f return (Just b).
--Trung
2012/12/20 Miguel Negrao
A 20/12/2012, às 14:07, Trung Quang Nguyen escreveu:
Hi all,
I saw this
• instance Monad Maybe where • return x = Just x • Nothing >>= f = Nothing • Just x >>= f = f x • fail _ = Nothing
I am wondering about the implementation of function (>>=). Why don't it be Just x >>= f = Just (f x)?
Any body knows about this?
That would be the implementation of fmap for Maybe:
instance Functor Maybe where fmap _ Nothing = Nothing fmap f (Just a) = Just (f a)
so, different behavior.
best, Miguel _______________________________________________ Beginners mailing list Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners
-- *Trung Nguyen* Mobile: +45 50 11 10 63 LinkedIn: http://www.linkedin.com/pub/trung-nguyen/36/a44/187 View my blog at http://www.onextrabit.com/
participants (4)
-
Edward Z. Yang
-
Miguel Negrao
-
Tom Davie
-
Trung Quang Nguyen