4

After reading through a page on Higher Order Functions from an awesome site I am still having trouble understanding the negate function paired with function composition.

to be more specific, take this piece of code:

ghci> map (negate . sum . tail) [[1..5],[3..6],[1..7]]

which yields:

[-14,-15,-27]

I re-read the page again, but to be honest, I still have no idea how that line of code produced this answer, if someone could walk me through the process of this I would really appreciate it!

Syntactic Fructose
  • 18,936
  • 23
  • 91
  • 177

2 Answers2

15
map f [a,b,c] = [f a,  f b,  f c]

because map f (x:xs) = f x:map f xs - apply f to each element of the list.

So

map (negate.sum.tail) [[1..5],[3..6],[1..7]]
= [(negate.sum.tail) [1..5],   (negate.sum.tail) [3..6],   (negate.sum.tail) [1..7]]

now 

(negate . sum . tail) [1..5]
= negate (sum (tail [1,2,3,4,5]))
= negate (sum  [2,3,4,5])
= negate 14
= -14

because (f.g) x = f (g x) and . is right associative, so (negate.sum.tail) xs = (negate.(sum.tail)) xs which in turn is negate ((sum.tail) xs) = negate (sum (tail xs)).

tail gives you everything except the first element of a list: tail (x:xs) = xs, for example tail "Hello" = "ello" sum adds them up as you expect, and
negate x = -x.

The others work similarly, giving minus the sum of the tail of each list.

AndrewC
  • 32,300
  • 7
  • 79
  • 115
  • 2
    I'm not sure calling `tail` the end of the list is fortunate. In other settings (Java, ...) "tail" is often used to denote the last node of a linked list, it might be better to use a wording that sets it clearer apart. Unfortunately, "all but the first element" is way too clumsy. – Daniel Fischer Jun 26 '13 at 18:36
  • @DanielFischer Cheers. Edited to make `tail` functionality more explicit. – AndrewC Jun 26 '13 at 18:39
  • Great. I won't bother to un- and re-upvote to show my appreciation, though. – Daniel Fischer Jun 26 '13 at 18:40
  • @Daniel Fischer this also confused me, as in C++ i always name the ending node of a linked list `tail`. – Syntactic Fructose Jun 27 '13 at 01:19
5

To add a different perspective to AndrewC's excellent answer I usually think about these types of problems in terms of the functor laws and fmap. Since map can be thought of as a specialization of fmap to lists we can replace map with the more general fmap and keep the same functionality:

ghci> fmap (negate . sum . tail) [[1..5],[3..6],[1..7]]

Now we can apply the composition functor law using algebraic substitution to shift where the composition is happening and then map each function individually over the list:

fmap (f . g)  ==  fmap f . fmap g -- Composition functor law

fmap (negate . sum . tail)             $ [[1..5],[3..6],[1..7]]
== fmap negate . fmap (sum . tail)     $ [[1..5],[3..6],[1..7]]
== fmap negate . fmap sum . fmap tail  $ [[1..5],[3..6],[1..7]]
== fmap negate . fmap sum $    fmap tail [[1..5],[3..6],[1..7]]
== fmap negate . fmap sum              $ [tail [1..5],tail [3..6],tail [1..7]] -- As per AndrewC's explanation
== fmap negate . fmap sum              $ [[2..5],[4..6],[2..7]]
== fmap negate                         $ [14, 15, 27]
==                                       [-14, -15, -27]
Davorak
  • 7,362
  • 1
  • 38
  • 48