高阶函数(higher-order function)就是指可以操作函数的函数，即函数可以作为参数，也可以作为返回结果。有了这两个特性，haskell可以实现许多神奇的效果。

柯里化（Currying）

在haskell中所有的算术运算符都是函数(包括大小于等于关系符等)，而它们的快捷方式都可以省略操作数（参数）。

(+) 1 2 -- (+) 是需要两个操作数的函数
> 3

(+1) 2 -- (+1) 是需要左操作数的函数
> 3

(3*) 3 -- (3*) 是需要右操作数的函数
> 6

map (*2) [1,2,3] -- map所有元素 *2 的操作
> [2,4,6]

filter (>3) [2,3,4,5] -- 过滤 >3的元素
> [4,5]

haskell中的函数默认都是前缀模式的，也就是：函数名 参数1 参数2 … 。但几乎所有拥有两个参数的函数都有中缀模式，只需要将函数名反引号包起来就可以了：参数1 `函数名` 参数2。因为在某些情况下中缀函数可读性更好，更符合人们的理解习惯。

5 `div` 3 -- 求余数
> 1

9 `mod` 7 -- 求模
> 2

'f' `elem` ['a' .. 'z'] -- 是否包含'f'
> True

本质上，Haskell 的所有函数都只有一个参数，那么我们多个参数的函数又是怎么回事? 那是因为所有多个参数的函数都是 Curried functions。其实从上面的算术运算函数例子，我们大概就能猜出来了。接着用实例来进验证一下：

moreThen4 = max 4 -- 最小为4的函数

:t max -- 需要两个可比较的参数的函数
max :: Ord a => a -> a -> a

:t moreThen4 -- 需要一个可比较的数字的函数
> moreThen4 :: (Ord a, Num a) => a -> a

通过查看函数的类型可发现，两个参数的 max 函数其实可以写成 (max x) y 。moreThen4 其实就是 max 函数以不全的参数调用后，再创建了一个新的返回函数，该函数是单个参数形式的。

这和 JavaScript 里用 闭包 的特性返回函数来实现 柯里化 是一样一样的。但在函数式语言当中，函数本来就是一等公民，这事情简直就是和吃饭睡觉一样地自然而然。

我们看起来很怪的函数类型描述 Num a => a -> a -> a ，这下也能理解通了。它表示的是函数取一个数字参数a后，会返回一个需要a类型参数的函数 (Num a) => a -> a ，最后的这个函数再取一个参数a后 ，最终就会回传a类型的结果。
利用柯里化去掉多余参数后的函数更加简洁：

sum' xs = foldl (+) 0 xs
sum' = foldl (+) 0  -- 去掉xs后

maxNum x = foldr max 0 x
maxNum = foldr max 0  -- 去掉x后

Lambda表达式

lambda 已经不是什么新鲜事物了， 早在 .NET 4.0时代 C# 就已经引入了 lambda，JavaScript 也在 ES6 中引入。

编写匿名的函数，这样就不需要费力的创建命名函数。因为匿名函数从 lambda 演算而来，所以匿名函数通常也被称为 lambda 函数。

在 Haskell 中，匿名函数以反斜杠符号 \ 开始，后跟函数的参数（可以包含模式），而函数体定义在 -> 符号之后。lambda 函数的定义只能有一条语句，同时无法为一个参数设置多个模式，如 [] 和 (x:xs)。

plusOne = \x -> x+1

checkZero = \x -> if x > 0 then "大于0" 
    else if x<0 then "小于0" 
    else "等于0"

折叠函数

遍历列表是一个非常普遍的需求，用折叠函数代替显式递归进行遍历明显更加易于理解和实现。其中 foldl 是左结合，foldr 是右结合，一般右折叠效率比较高，同时 foldr 也可以用于无限列表，所以应尽量使用 foldr。

折叠函数调用格式: fold 处理函数 初始值(累加值) 需要折叠的列表

另外还提供了和 foldl/foldr 相似的 foldl1/foldr1，它们默认使用列表第一项为初始值，所以可以省略初始值。

map' :: Foldable t1 => (t2 -> a) -> t1 t2 -> [a]
map' f = foldr (\x acc -> f x:acc) []

filter' :: Foldable t => (a -> Bool) -> t a -> [a]
filter' f = foldr (\x acc -> if f x then x:acc else acc) []

elem' :: (Foldable t, Eq a) => a -> t a -> Bool
elem' y = foldl (\acc x -> if y==x then True else acc) False

and' :: Foldable t => t Bool -> Bool
and' = foldr1 (\x y->if not y then False else if not x then False else True)

-- 执行
map' (*2) [1,2]
> [2,4]

filter (>2) [1,2,3,4]
> [3,4]

elem' 1 [1,2,3]
> True

and' [True,False,True]
> False

与 foldl 和 foldr 相似的scanl 和 scanr，它们会记录下累加值的所有状态到一个 List。
也有 scanl1 和 scanr1。 

scanl (+) 0 [3,5,2,1]  
> [0,3,8,10,11]  

scanr (+) 0 [3,5,2,1]  
> [11,8,3,1,0]

还有 foldl’ 和 foldl1’ 是它们各自惰性实现的严格版本。在用 fold 处理较大的 List 时，经常会遇到堆栈溢出的问题。而这罪魁祸首就是 fold 的惰性: 在执行 fold 时，累加器的值并不会被立即更新，而是做一个”在必要时会取得所需的结果”的承诺。每过一遍累加器，这一行为就重复一次。而所有的这堆”承诺”最终就会塞满你的堆栈。严格的 fold 就不会有这一问题，它们不会作”承诺”，而是直接计算中间值的结果并继续执行下去。如果用惰性 fold 时经常遇到溢出错误，就应换用它们的严格版。

函数组合

（$) 叫作函数呼叫符，它的优先级最低。 

 f $ g x => f (g x)

-- 取>2的列表长度
length (filter (>2) [1,2,3,4])
length $ filter (>2) [1,2,3,4] -- 降低优先级消除括号
> 2

(.) 函数复合运算符，它可以组合函数，并产生新函数，然后传递给其它函数。当然我们可以用 lambda 实现，但大多数情况下，使用函数组合无疑更清楚。

(f . g) x => f(g x) 

-- 验证字符串是否为数字
not ( and ( map isDigit $ "12as"))
not . and . map isDigit $ "12as" -- 使用组合消除括号
> True

这两个运算符是消除括号的神器，有了它们，代码的可读性大大提高。
我们再利用haskell强大的模式匹配能力，改变函数运行方向，改造后的效果类似于unix/linux的管道，把上面两个表达式重写。现在连 ($) (.) 都不需要了，吊炸天了，有木有😊

-- 让参数和结果首尾相连，就是这么简单
x |> f = f x

-- unix/linux 中的管道？
[1,2,3,4] |> filter (>2) |>length
> 2

"12as" |> map isDigit |> and |> not
> True

参考资料

《HASKELL 趣学指南》
《Real World Haskell》