Haskell学习-高阶函数

原文地址:Haskell学习-高阶函数
高阶函数(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) ymoreThen4 其实就是 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# 就已经引入了 lambdaJavaScript 也在 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 相似的scanlscanr,它们会记录下累加值的所有状态到一个 List。
也有 scanl1scanr1

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》