9

I found this implementation of the average function:

avg :: [Int] -> Int
avg = div . sum <*> length

How does this work? I looked at the function that was produced as a result of div . sum:

(div . sum) :: (Integral a, Foldable t) => t a -> a -> a

I understand that, but I'm unable to tell how <*> length does the work.

xilpex
  • 3,097
  • 2
  • 14
  • 45

2 Answers2

12

<*> :: Applicative f => f (a -> b) -> f a -> f b is the sequential application function that works on an Applicative structure. For a function, this is implemented as [src]:

instance Applicative ((->) r) where
    pure = const
    (<*>) f g x = f x (g x)
    liftA2 q f g x = q (f x) (g x)

so f <*> g is short for \x -> f x (g x). This thus means that in the case of avg:

avg = div . sum <*> length

is equivalent to:

avg x = (div . sum) x (length x)

which is thus equivalent to:

avg x = div (sum x) (length x)

so it divides the sum x with length x.

Willem Van Onsem
  • 443,496
  • 30
  • 428
  • 555
  • 4
    Piggybacking off this answer, one thing that has helped me with ab(uses) of `<*>` for functions is reading it like `div <$> sum <*> length`. If you're familiar with the `f <$> x <*> y <*> z ...` idiom, you can think of the function case as meaning "apply `x` to the first argument of `f`, `y` to the second, etc. – cole Aug 24 '20 at 04:21
9

I'm not a fan of this particular pointfree-trick. It uses the Applicative (a->) instance as a “fanout”, to pass the argument to two separate functions. Essentially those two functions are sum and length, and the results are then combined back by div, which can be expressed nicely with arrow combinators (albeit a bit more verbose, because arrows don't really play in Haskell's default curried style):

import Control.Arrow

avg = uncurry div . (sum &&& length)

In the applicative trick, you merge the combining function into the first argument-sharing one. So div . sum in this case, and the result of the other function length is then passed into the second argument of the first function.

You can also use

avg = liftA2 div sum length

which uses the Applicative instance too.

leftaroundabout
  • 117,950
  • 5
  • 174
  • 319
  • Right! Actually I had it this way at first, but then on reading over the answer at the end somehow made a thought mistake that the whole thing still had two arguments. – leftaroundabout Aug 24 '20 at 05:59