[throwaway183839]

I'm kind of surprised that `enumerate` isn't defined in any standard libraries (as far as I know) since I need it pretty often.

After a while spent programming in Haskell you would probably develop your own mini-library of functions that make your life easier. Another one I often find useful is

  (.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
  (.:) f g = \x y -> f (g x y)

which e.g. allows you to define the absolute distance function

  dist :: (Num a) => a -> a -> a
  dist = abs .: (-)

A fun challenge is figuring out why the definition of (.:) is equivalent to

  (.:) = fmap . fmap

!

[JadeNB]

> A fun challenge is figuring out why the definition of (.:) is equivalent to

> (.:) = fmap . fmap

> !

Of course it's not really equivalent, since the most general type of the LHS is as you have said, whereas that of the RHS involves functor constraints; but inlining the definition of `fmap` for arrows gives the amusing definition:

    (.:) = (.) . (.)

I tend to figure this sort of thing out by successive eta conversion:

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

Is there a better way?

[HanyouHottie]

Seems like a better name for it would be

  (...) :: (c -> d) -> (a -> b -> c) -> a -> b -> d

since

  (...) = (.) . (.)

.

[wz1000]

    (.:) f g = (f .) . g

This can interestingly be generalized(in a way) to get

    (.::) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> d
    (.::) f g = ((f .) .) . g

and so on.

Since fmap = (.), substitution would get your point free form.

[cschneid]

The downside of using (.:) is that it is used heavily in other libraries (Aeson for instance) in a very different context (field accessors, similar in look to json's `:`).