Haskell 笔记 ③

①循环?NO!请递归思考问题！

手艹一个求列表中最大值代码，C语言中习惯性for扫一下比较出最大值。但是可以用递归！

maximum'::(Ord a)=>[a]->a
maximum' []=error "empty!"
maximum' [x]=x
maximum' (x:xs) = max x (maximum' xs)　

同样的对列表的递归技巧可以手艹出take、reverse、repeat、zip、elem

rev::[a]->[a]
rev []=[]
rev (x:xs)=rev xs++[x]  //后端插入用++

zip'::[a]->[b]->[(a,b)]
zip' [] _=[]
zip' _ []=[]
zip' (x:xs) (y:ys)=[(x,y)]++zip' xs ys

甚至是一个低效率的快排(递归扫了两遍数据，没有左右推进效率高）

qsort:: (Ord a) =>[a]->[a]
qsort []=[]
qsort (key:xs) = let left=[x|x<-xs,x<=key]
                     right=[x|x<-xs,x>key]
                 in qsort left ++ [key] ++ qsort right

注意一下Haskell中的命名方式，大写字母不可以作为首字母（目测这样是为了推广  首单词小写-剩余单词大写   这种命名方式)

QuickSort是错误的，quickSort才是理想的命名方式 (参照Qt的库)

②函数作为函数的参数？

看起来有点不可思议，这其实是Haskell的一大亮点，在Haskell中，函数的参数是逐个取的，而不是像C语言那样一次取完。

如 Three x y z=x*y*z，先取x，再取y，计算x*y，再取z，用前面x*y的结果*z

慢着，这不就是递归么，递归又递归，递归还是递归。难怪有人吐槽，Haskell就是递归！

函数嵌套时，可以用这种特性减少参数的书写，让你的代码看起来更吊。（好难改=。=）

如f x=compare x 100，可以改写成f compare 100

这样就衍生一种叫“截断”的用法，可以copy一个中缀函数的功能，如+、-（例外）、*、/

如copy “/”，divTen = (/10), subTen = (-10)是不行的，-10会被当成数值，可以用库的subtract函数，这么写subTen=subtract 10

③2333，为什么我之前写的函数在Console运行时，都给了警告？

你会看见一坨屎一样的东西

Defaulting the following constraint(s) to type ‘Integer’
      (Show a0) arising from a use of ‘print’ at <interactive>::-
      (Ord a0) arising from a use of ‘it’ at <interactive>::-
      (Num a0) arising from a use of ‘it’ at <interactive>::-
In a stmt of an interactive GHCi command: print it

原因是console只能输出字符串，要显示必须调用show函数，console为了显示自动帮我们加了，然后很无耻地给了一个警告，其实这和我们有半毛钱关系啊？

④当函数作为参数之后...

手艹zipWith函数：参数是一个二参一回的函数f、两个列表，分别取列表扔到f里，结果存到一个列表中。

zipWith'::(a->b->c)->[a]->[b]->[c]
zipWith' _ [] _ =[]
zipWith' _ _ []=[]
zipWith' f (x:xs) (y:ys)=f x y:zipWith' f xs ys

需要注意的是函数作为参数时，类型的写法，一定要把这个函数的类型声明给完整写出来。

有许多二参一回函数：+、max/min,++,符号作为函数时，要用()，如（+）才是函数

手艹flip函数：反转一个函数的两个参数，常用来flip掉zip函数

flip'::(a->b->c)->b->a->c
flip' f x y = f y x

手艹map函数: 将一个一参一回函数作用于一个列表。

map'::(a->b)->[a]->[b]
map' _ []=[]
map' f (x:xs)=f x:map' f xs

如(+3)、（++ “fuck!”)

手艹filter函数: 从一个列表中抽取符合谓词（布尔）条件的新列表

filter'::(a->Bool)->[a]->[a]
filter' _ []=[]
filter' p (x:xs)
   |p x==True =x:filter' p xs
   |otherwise =filter' p xs

如 (>3)、odd/even、elem

其实map和filter都能由列表表达式实现,2333,不过用函数看起来吊吊的。

⑤lambda表达式

lambda表达式不是什么稀奇东西，就是个匿名（起名字好麻烦）的单行函数

如三个数相加，普通写成  addThree x y z=x+y+z

lambda表达式就是  addThree= (\x y z->x+y+z)

由参数区和函数区两部分构成，”\“起手，“->”隔开，好处嵌套不要重新外部写一个函数了

当然有更极端的推导写法：\x->\y->\z->x+y+z,阐述了lambda递归调用参数的事实。

那么addThree=\x y z=z+y+x 这样写就会报错了，addThree x y z=z+y+x却是对的。

Lambda表达式虽然简单，但是参数的使用必须严格按照参数顺序。

当然，lambda的类型推导还是得和原来一样标出来的。addThree::Int->Int->Int->Int

⑥适用于二元函数的隐式递归foldl、foldr

fold函数三个参数：函数、初始值、列表，其中初始值+列表=凑出二元式子

fold分为左折叠和右折叠，区别是左折叠初始（累计）值作为左操作数，并且从列表左边取值，而右折叠则作为右操作数，从列表右边取值。

手艹sum函数（左折叠）（fold折叠的函数无须写类型推导）

sum'::(Num a)=>[a]->a
sum'  xs=foldl (\acc x->acc+x) 0 xs

由于操作符无顺序，所以左右折叠都行。

手艹map函数（右折叠、左折叠）

map'::(a->b)->[a]->[b]
map' f xs=foldr (\x acc->f x:acc) [] xs

map'::(a->b)->[a]->[b]
map' f xs=foldl (\acc x->acc++[f x]) [] xs

注意观察一下左右操作数的变化以及lambda表达式的参数顺序。

由于”:”的效率好于”++”,所以生成列表通常使用右折叠。

简化版：foldl1、foldr1（是数字1），无须传入初始值，很方便，但是无法处理空列表，如手艹maximum

maximum'::(Ord a)=>[a]->a
maximum'=  foldl1 max

Debug版:scanl、scanr,追踪fold的过程，产生含有n+1元素的执行过程列表

⑦ $函数

这是一个奇怪的函数。

($)::(a->b)->a->b

f $ x = f x

你会觉得它什么也没干。其实它做了一件伟大的事，它挡在f前面多跑了一步。

所以配上$函数之后，那个函数的优先级就被降低了（挡枪的$)

$可以用来去括号，因为是右结合函数，所以只要把优先级高的函数往右边写，然后不停用$就可以全程不写难看的括号了（C语言的括号写多了，整个代码就和屎一样）

f = sum $ filter (>) $ map (^) [,,,]

执行顺序（平方->map->filter->sum)，没有括号一身清。

$结合map，可以用来投射一组一元函数，到一个对象上。

f = map ($ ) [(+),(*),(-),(^)]

结果是[5,9,1,9]。