[Haskell-cafe] lawless instances of Functor

[Brent Yorgey]

On Mon, Jan 04, 2010 at 11:49:33PM +0100, Steffen Schuldenzucker wrote:
> 
> data Foo a = Foo a
> 
> instance Functor Foo where
>     fmap f (Foo x) = Foo . f . f $ x
> 
> Then:
> 
> fmap id (Foo x) == Foo . id . id $ x == Foo x
> 
> fmap (f . g) (Foo x)      == Foo . f . g . f . g $ x
> fmap f . fmap g $ (Foo x) == Foo . f . f . g . g $ x
> 
> Now consider Foo Int and
> 
> fmap ((+1) . (*3)) (Foo x)      == Foo $ (x * 3 + 1) * 3 + 1
>     == Foo $ x * 9 + 4
> fmap (+1) . fmap (*3) $ (Foo x) == Foo $ x * 3 * 3 + 1 + 1
>     == Foo $ x * 9 + 2

As others have pointed out, this doesn't typecheck; but what it DOES
show is that if we had a type class

  class Endofunctor a where
    efmap :: (a -> a) -> f a -> f a

then it would be possible to write an instance for which efmap id = id
but efmap (f . g) /= efmap f . efmap g.  The difference is that with
the normal Functor class, once you have applied your function f :: a
-> b to get a b, you can't do anything else with it, since you don't
know what b is.  With the Endofunctor class, once you have applied f
:: a -> a, you CAN do something with the result: namely, apply f
again.  

-Brent