为什么即使在以下示例中，n约简也不适用于滤波器？

Question

I am following 'Learn Haskell Fast and Hard' and I was able to follow most of it, but I have two questions for the following code sample.

1. In the first function, why don't I need l but in the second version I do need l ?
2. In evenSum1 , when the function is called recursively will filter be called on the list again and again or will filter be called only once on the first call?

.

evenSum = accumSum 0 
    where 
        accumSum n [] = n
        accumSum n (x:xs) =
                        if even x
                                then accumSum (n+x) xs
                                else accumSum n xs

evenSum1 l = mysum 0 (filter even l)
    where
        mysum n [] = n
        mysum n (x:xs) = mysum (n+x) xs

Answer 1

You can actually drop of the l in the second example too, but you need to switch to what is called point free notation and use the function composition operator (.) :

evenSum1 = mysum 0 . filter even
    where
        mysum n [] = n
        mysum n (x:xs) = mysum (n + x) xs

And in evenSum1 , the filter even function will only be called once. What happens is that filter even runs out the list passed in, then the output of that is passed to mysum 0 .

---

A quick primer on point free notation

Say you have a function add :

add :: Int -> Int -> Int
add x y = x + y

And then you want to make a function add5 that always adds 5 to an Int . You could do it as

add5 :: Int -> Int
add5 y = add 5 y

But since functions are first class objects in Haskell and we can partially apply a function, this is equivalent to saying

add5 :: Int -> Int
add5 = add 5

Another way to look at it is to add some optional parentheses to the type signature of add :

add :: Int -> (Int -> Int)
add x y = x + y

Written like this, we can say that add is a function that accepts a single Int argument and returns a new function of Int -> Int . So if we give add a single Int , we get a new function back. This is also what lets us write expressions like

filter even list

Instead of

filter (\x -> even x) list

A good rule of thumb for point-free notation is that variables can be dropped off the end turning the last $ into a . :

f x y = h x $ g y
f x   = h x . g

f x y z = h x $ g y $ j z
f x y   = h x $ g y . j

This doesn't always work with multi-argument functions:

f x y = h $ g x y

Is not the same as

f = h . g

Because h . g h . g won't type check. This is because of implicit parentheses:

f x y = h $ (g x) y
f x   = h . (g x)

And now there's parentheses in the way from being able to drop the x argument.

Also, keep in mind that fxy = h (gxy) is equivalent to fxy = h $ gxy , so you can usually turn the outermost parentheses into a $ instead, potentially letting you eta-reduce and change the $ to a . . If all this seems confusing, you can also grab the pointfree package off hackage, which contains a command line tool for automatically performing eta-reductions for you.