Comments on: The Magic Dot

By: Nick Zivkovic

Nick Zivkovic — Thu, 03 Sep 2009 21:45:26 +0000

Ah. Ok. It sounded like you were wrongly convinced that the two were identical (which they are not. `fmap` merely has a ‘function’ instance, as you said earlier), and I was just trying clear up the misconception I perceived, wrongly. Also, a nice thing about `fmap` in applicative is that it has instances for monads where

f `fmap` xs == xs >>= return.f

If you haven’t already, check out the Control.Applicative library. It is truly a thing of beauty.

By: Will Donnelly

Will Donnelly — Wed, 02 Sep 2009 17:28:46 +0000

I think I understand what you are saying. I worded the post badly. What I meant to convey was that “in the case of functions, fmap is equivalent to the composition operation”. I suppose I should fix the wording in the original post.

My point was that since it is perfectly valid to have

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

in the Control.Monad.Instances module, regular function composition can be viewed as simply being

fmap

as it applies to functions. And once that conceptual jump was made, I thought it would be interesting to see what happens if

(.)

is redefined to always mean

fmap

By: nick

nick — Wed, 02 Sep 2009 14:53:04 +0000

because I suck at html, here is the link to the operator that gets eaten:
http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Applicative.html#v:%3C$%3E

By: nick

nick — Wed, 02 Sep 2009 14:52:20 +0000

html hates my code …

() :: Functor f => (a -> b) -> f a -> f b

instead of () :: Functor f => (a -> b) -> f a -> f b

By: nick

nick — Wed, 02 Sep 2009 14:50:56 +0000

sorry, for the second signature should be:
() :: Functor f => (a -> b) -> f a -> f b

instead of () :: Functor f => (a -> b) -> f a -> f b

By: nick

nick — Wed, 02 Sep 2009 14:50:16 +0000

Actually, not quite. The dot operator acts over two functions, and the second function’s argument.
It’s definition is
(.) :: (b->c) -> (a->b) -> a -> c
a . b x = a (b x)
Notice, how ‘.’ takes two /functions/ and the second function’s argument as arguments. It can’t take a function and a value. So something like a.b.x is not equal to the above. It is invalid, unless x is a function in point-free form.
fmap is often abbreviated as infix operator.
It doesn’t take two functions. It takes one function and one functor (i.e. a list). It then lifts the function into the functor class and applies it over the functor. Here is the signature:
() :: Functor f => (a -> b) -> f a -> f b

As you can see is a little more general than ‘.’ and acts only on instances of the functor typeclass. I would show you the fill definition, but I think you should head over to hoogle or hayoo, and look up the operator, and the Control.Applicative module for a better understanding of this. If anything, is more closely related to the $ operator than the . operator.

Hope this is helpful, on your haskell journey.