Brent Yorgey byorgey at seas.upenn.edu
Fri Mar 4 21:07:07 CET 2011

```On Wed, Mar 02, 2011 at 04:38:07PM -0500, Patrick Lynch wrote:
>
> ----- Original Message ----- From: "Brent Yorgey"
> <byorgey at seas.upenn.edu>
> Sent: Wednesday, March 02, 2011 10:37 AM
>
>
> >On Wed, Mar 02, 2011 at 10:04:38AM -0500, Patrick Lynch wrote:
> >>Daniel,
> >>Thank you...I understand now...
> >>Good day
> >>
> >>    instance Functor Maybe where
> >>      fmap f (Just x) = Just (f x)
> >>      fmap f Nothing = Nothing
> >
> >you are confused about?  Try thinking carefully about all the types
> >involved.  What is the type of f? (You already answered this: a -> b.)
> >What is the type of (Just x)? The type of x?  What type is required on
> >the right hand side of the = ?  And so on.
>
>
> -Hi Brent
> I know that Maybe type is: data Maybe a = Nothing | Just a
> ...so, I assume that the type to the right of the '=' should be
> Maybe a..

Not quite.  Let's look again at the type of fmap here:

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

So fmap will be taking *two* parameters, the first of type (a -> b),
the second of type Maybe a.  Then it needs to return something of type
Maybe b (so this is what will be on the right hand side of the =).

>     instance Functor Maybe where
>       fmap Nothing = Nothing
>       fmap Just x = Just x

You're missing the first argument to fmap (the one of type a -> b).
Let's call it f.  Since the second argument is of type (Maybe a)
you're right that we should handle all cases (Nothing and Just).

fmap f Nothing = Nothing

so here we need to return something of type 'Maybe b'.  Well, we don't
have any values of type b, so the only thing we can do is return
Nothing.

fmap f (Just x) = ?

The reason we need the parentheses around (Just x) is simply that
otherwise the compiler thinks we are writing a definition of fmap that
takes three arguments: f, Just, and x, but that doesn't make sense.

Now, here f has type (a -> b), and (Just x) has type (Maybe a), hence
x has type a.  If we apply f to x we get something of type b, so we
can define

fmap f (Just x) = Just (f x)

Does that make sense?

-Brent

```