Parse error in pattern: f . g in fmap (f . g) = fmap f . fmap g

Parse error in pattern: f . g

i am a beginner, where is wrong?

   (f . g) x = f (g x)


class Functor f  where
    fmap :: (a -> b) -> f a -> f b

class Functor g  where
    fmap :: (a -&g开发者_如何学运维t; b) -> f a -> f b 

instance Functor F where
    fmap id = id 
    fmap (f . g)  = fmap f . fmap g

---

When you make an instance of Functor, you should prove the side condition that

fmap id = id 

and

fmap (f . g)  = fmap f . fmap g

(Technically the latter comes for free given the types involved and the former law, but it is still a good exercise.)

You can't do this just by saying

fmap id = id

but instead you use this as a reasoning tool -- once you have proven it.

That said, the code that you have written doesn't make sense for a number of reasons.

  (f . g) x = f (g x)

Since this is indented, I'm somewhat unclear if this is intended to be a definition for (.), but that is already included in the Prelude, so you need not define it again.

class Functor f  where
    fmap :: (a -> b) -> f a -> f b

This definition is also provided for you in the Prelude.

class Functor g  where
    fmap :: (a -> b) -> f a -> f b 

But then you define the class again, but here it has mangled the signature of fmap, which would have to be

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

But as you have another definition of Functor right above (and the Prelude has still another, you couldn't get that to compile)

Finally, your

instance Functor F where
    fmap id = id 
    fmap (f . g)  = fmap f . fmap g

makes up a name F for a type that you want to make into an instance of Functor, and then tries to give the laws as an implementation, which isn't how it works.

Let us take an example of how it should work.

Consider a very simple functor:

data Pair a = Pair a a

instance Functor Pair where
   fmap f (Pair a b) = Pair (f a) (f b)

now, to prove fmap id = id, let us consider what fmap id and id do pointwise:

fmap id (Pair a b) = -- by definition
Pair (id a) (id b) = -- by beta reduction
Pair a (id b) = -- by beta reduction
Pair a b

id (Pair a b) = -- by definition
Pair a b

So, fmap id = id in this particular case.

Then you can check (though technically given the above, you don't have to) that fmap f . fmap g = fmap (f . g)

(fmap f . fmap g) (Pair a b) = -- definition of (.)
fmap f (fmap g (Pair a b)) = -- definition of fmap 
fmap f (Pair (g a) (g b)) = -- definition of fmap
Pair (f (g a)) (f (g b))

fmap (f . g) (Pair a b) = -- definition of fmap
Pair ((f . g) a) ((f . g) b) = -- definition of (.)
Pair (f (g a)) ((f . g) b) = -- definition of (.)
Pair (f (g a)) (f (g b))

so fmap f . fmap g = fmap (f . g)

Now, you can make function composition into a functor.

class Functor f where
    fmap :: (a -> b) -> f a -> f b

by partially applying the function arrow constructor.

Note that a -> b and (->) a b mean the same thing, so when we say

instance Functor ((->) e) where

the signature of fmap specializes to

    fmap {- for (->) e -} :: (a -> b) -> (->) e a -> (->) e b

which once you have flipped the arrows around looks like

    fmap {- for (->) e -} :: (a -> b) -> (e -> a) -> e -> b

but this is just the signature for function composition!

So

instance Functor ((->)e) where
    fmap f g x = f (g x)

is a perfectly reasonable definition, or even

instance Functor ((->)e) where
    fmap = (.)

and it actually shows up in Control.Monad.Instances.

So all you need to use it is

import Control.Monad.Instances

and you don't need to write any code to support this at all and you can use fmap as function composition as a special case, so for instance

fmap (+1) (*2) 3 = 
((+1) . (*2)) 3 =
((+1) ((*2) 3)) =
((+1) (3 * 2)) = 
3 * 2 + 1 =
7

---

Since . is not a data constructor you cannot use it for pattern matching I believe. As far as I can tell there isn't an easy way to do what you're trying, although I'm pretty new to Haskell as well.

---

let is not used for top-level bindings, just do:

f . g = \x -> f (g x)

But the complaint, as cobbal said, is about fmap (f . g), which isn't valid. Actually, that whole class Functor F where is screwy. The class is already declared, now I think you want to make and instance:

instance Functor F where
    fmap SomeConstructorForF = ...
    fmap OtherConstructorForF = ...

etc.