Haskell

Haskell 是一种标准化的，通用的纯函数式编程语言，有惰性求值和强静态类型。它的命名源自美国逻辑学家哈斯凯尔 · 加里，他在数理逻辑方面上的工作使得函数式编程语言有了广泛的基础。在 Haskell 中，“函数是第一类对象”。作为一门函数编程语言，主要控制结构是函数。Haskell 语言是 1990 年在编程语言 Miranda 的基础上标准化的，并且以 λ 演算为基础发展而来。这也是为什么 Haskell 语言以希腊字母 “λ”（Lambda）作为自己的标志。Haskell 具有“证明即程序、命题为类型”的特征。

———— 维基百科

基础运算 ¶

• + - * / ()：加减乘除
• div：整除
• mod：取模
• True False：布尔值
• || && not：或且非
• ==：条件判断，相等
• /=：条件判断，不等

函数调用 ¶

Haskell 中调用函数不加括号，先写出函数名，然后逐个列出参数，用空格隔开：

ghci> max 1 2
2

• 对前缀函数加``使其变成中缀函数
• 对中缀函数加()使其变成前缀函数

ghci> 4 `div` 2
2
ghci> 1 `max` 2
2
ghci> (+) 1 2
3
ghci> (||) True False
True

List¶

列表是 Haskell 中很常见的数据类型，和 Python 中不同，Haskell 中的列表中的所有元素必须是同一个类型。

以下是列表常用的函数：

• (++) :: [a] -> [a] -> [a]：合并两个列表
• (:) :: a -> [a] -> [a]：将单个元素并入列表。[1, 2, 3] 是 1:2:3:[] 的语法糖
• (!!) :: [a] -> Int -> a：通过索引取出某个位置上的元素。a !! 1 相当于 Python 中的 a[1]
• head :: [a] -> a：返回列表的第一个元素
• tail :: [a] -> [a]：返回列表中除去第一个元素后的列表（若只有一个元素则返回空列表 []）
• last :: [a] -> a：返回列表中的最后一个元素
• init :: [a] -> [a]：返回列表中除去最后一个元素后的列表
• length :: Foldable t => t a -> Int：返回列表的长度
• null :: Foldable t => t a -> Bool：返回列表是否为空
• reverse :: [a] -> [a]：返回翻转后的列表
• take :: Int -> [a] -> [a]：返回列表 a 的前 n 个元素的列表 (take n a)
• drop :: Int -> [a] -> [a]：返回列表 a 中除去前 n 个元素后的列表 (drop n a)
• maximum :: (Foldable t, Ord a) => t a -> a：返回列表中的最大值
• minimum :: (Foldable t, Ord a) => t a -> a：返回列表中的最小值
• sum :: (Foldable t, Num a) => t a -> a：返回列表中所有元素的和
• product :: (Foldable t, Num a) => t a -> a：返回列表中所有元素的积
• elem :: (Foldable t, Eq a) => t a -> Bool：判断值 n 是否在列表 a 中

  elem n a
  -- 或
  n `elem` a --用``包上可以变成中缀函数使用
  

Texas ranges¶

使用..可以表示出范围并自动推导：

ghci> [1 .. 10]  
[1,2,3,4,5,6,7,8,9,10]  
ghci> ['a' .. 'z']  
"abcdefghijklmnopqrstuvwxyz"  
ghci> ['K' .. 'Z']  
"KLMNOPQRSTUVWXYZ" 
ghci> [2, 4 .. 20]  
[2,4,6,8,10,12,14,16,18,20]  
ghci> [3, 6 .. 20]  
[3,6,9,12,15,18]
ghci> [5, 4 .. 1]
[5,4,3,2,1]

• cycle :: [a] -> [a]：将原列表不断循环生成无穷列表
• repeat :: a -> [a]：将传入的值不断重复生成无穷列表
  • replicate :: Int -> a -> [a]：将值 a 重复 n 次，返回生成的列表 (replicate n a)

List comprehension¶

Haskell 中也有列表推导，形式是一个中括号，左侧为表达式，右侧为变量的范围和约束条件

ghci> [x * 2 | x <- [1 .. 10]]  
[2,4,6,8,10,12,14,16,18,20]  
ghci> [x * 2 | x <- [1 .. 10], x * 2 >= 12]  
[12,14,16,18,20]
ghci> [ x | x <- [50 .. 100], x `mod` 7 == 3]  
[52,59,66,73,80,87,94]   
ghci> [x * y | x <- [2, 5, 10], y <- [8, 10, 11]]  
[16,20,22,40,50,55,80,100,110]

Tuple¶

Haskell 中的元组可以有不同长度，元素可以有不同类型。并且一个元组的类型由其中所有元素的类型共同决定。它的常用函数：

• fst :: (a, b) -> a：返回含有两个元素元组中的第一个元素
• snd :: (a, b) -> b：返回含有两个元素元组中的第二个元素
• zip :: [a] -> [b] -> [(a, b)]：接收两个列表，返回一个列表，每个元素是依次将两个列表中元素配对成的二元组

Syntax in Functions¶

函数可以直接定义：

plus x y = x + y

plus :: (Num a) => a -> a -> a
plus x y = x + y

Pattern matching¶

定义函数时可以使用模式匹配语法。运行时依次将输入与给出的模式相匹配，如果匹配，就执行对应操作；不匹配，就继续与下一个模式相匹配，直到匹配成功，也因此，最后必须要给出一种通用的匹配来接收与给出模式全不匹配的输入。如：

factorial :: (Integral a) => a -> a  
factorial 0 = 1  
factorial n = n * factorial (n - 1)  

first :: (a, b, c) -> a  
first (x, _, _) = x  

second :: (a, b, c) -> b  
second (_, y, _) = y  

third :: (a, b, c) -> c  
third (_, _, z) = z  

列表的 (:) 操作也可以用来进行模式匹配：

head' :: [a] -> a  
head' [] = error "Can't call head on an empty list, dummy!"  
head' (x:_) = x

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

在针对列表进行模式匹配时，如果同时需要整个列表、列表的第一个值、列表除第一个值外的内容，可以使用 xs@(q:qs)。比如 [1, 2, 3] 通过 xs@(q:qs) 匹配后，xs 为 [1, 2, 3]，q 为 1，qs 为 [2, 3]

Guard syntax¶

在函数的定义中，也可以使用守卫（guard）语法：

max' :: (Ord a) => a -> a -> a  
max' a b   
    | a > b     = a  
    | otherwise = b 

Case expressions¶

在函数的定义中，也可以使用 case 表达式来配合模式匹配使用：

case expression of pattern -> result  
                   pattern -> result
                   ...  

head' :: [a] -> a  
head' [] = error "No head for empty lists!"  
head' (x:_) = x  
-- 等价于：
head' :: [a] -> a  
head' xs = case xs of [] -> error "No head for empty lists!"  
                      (x:_) -> x  

describeList :: [a] -> String  
describeList xs = "The list is " ++ case xs of [] -> "empty."  
                                               [x] -> "a singleton list."   
                                               xs -> "a longer list."  
-- 等价于：
describeList :: [a] -> String  
describeList xs = "The list is " ++ what xs  
    where what [] = "empty."  
          what [x] = "a singleton list."  
          what xs = "a longer list." 

where¶

声明在函数定义中要使用的局部变量，可以使用 where 关键字：

initials :: String -> String -> String  
initials firstname lastname = [f] ++ ". " ++ [l] ++ "."  
    where (f:_) = firstname  
          (l:_) = lastname  

let¶

let <bindings> in <expression> 语法可以在函数的定义中使用，也可以在普通算式或列表中使用：

cylinder :: (RealFloat a) => a -> a -> a  
cylinder r h = 
    let sideArea = 2 * pi * r * h  
        topArea = pi * r ^2  
    in  sideArea + 2 * topArea  

ghci> 4 * (let a = 9 in a + 1) + 2  
42 
ghci> [let square x = x * x in (square 5, square 3, square 2)]  
[(25,9,4)] 

if statement¶

Haskell 中的 if 语句为：

if ... then ...
else ...
-- or if ... then ... else ...
-- or
if ... then ...
else if ... then ...
else ...

Higher Order Functions¶

Currying¶

Haskell 中的函数是柯里化（Currying）的，可以看作所有函数都只接收一个参数，而接收两个参数的函数实际上是这个函数接收了第一个参数后返回了一个接收第二个参数的函数，然后用这个函数接收第二个参数，返回最终的结果。比如 max 函数，它的类型签名是：

max :: Ord a => a -> a -> a

可以看成 a -> (a -> a)，即接收一个参数，返回一个类型为 a -> a 的函数。比如 max 1 的类型签名是：

max 1 :: (Ord a, Num a) => a -> a

因此 max 1 2，也就等同于 (max 1) 2，即将函数 max 1 应用在数字 2 上

同时，函数也可以接收函数作为参数，参数有函数的函数就被称为高阶函数（Higher Order Functions）

一些高阶函数 ¶

zipWith¶

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

第一个参数为一个函数，然后接收两个列表，将其对应元素传入接收的函数中，得到的结果组成一个新的列表。如果两个传入的列表长度不同，以最短的列表为准，长列表中超出的元素省略。用例：

ghci> zipWith (+) [4,2,5,6] [2,6,2,3]  
[6,8,7,9]  
ghci> zipWith max [6,3,2,1] [7,3,1,5]  
[7,3,2,5]  

flip¶

flip :: (a -> b -> c) -> b -> a -> c

flip 函数接收一个二元函数，返回一个新的二元函数，将其输入的两个参数顺序反过来：

ghci> zip [1,2,3,4,5] "hello"
[(1,'h'),(2,'e'),(3,'l'),(4,'l'),(5,'o')]
ghci> flip zip [1,2,3,4,5] "hello"  
[('h',1),('e',2),('l',3),('l',4),('o',5)]

map¶

map :: (a -> b) -> [a] -> [b]

map 函数接收一个函数 f 和一个列表 a，将函数 f 应用在列表 a 的每个元素中，并返回得到的所有结果组成的列表 b：

ghci> map (+3) [1,5,3,1,6]  
[4,8,6,4,9]  

filter¶

filter :: (a -> Bool) -> [a] -> [a]

filter 函数接收一个函数 f 和一个列表 a，将列表 a 中的每个元素传入函数 f 中，如果结果为 True 就保留，结果为 False 就抛弃，返回所有保留的元素组成的新列表：

ghci> filter even [1..10]  
[2,4,6,8,10] 

takeWhile¶

takeWhile :: (a -> Bool) -> [a] -> [a]

takeWhile 函数接收一个函数 f 和一个列表 a，将列表 a 中从左向右每个元素传入函数 f，直到结果为 False 停止，返回停止前传入的所有元素组成的新列表：

ghci> takeWhile (/=' ') "word1 word2"
"word1"

Function application¶

函数应用可以使用 $，$ 是一个函数，它的类型是：

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

它可以改变函数结合优先级，将左侧函数应用于全部右侧内容上，相当于给右侧整体加上了括号。否则函数默认左结合，会依次向右应用而不会应用在整体上。

f $ g x
-- 等价于
f (g x)
-----
f g x
-- 等价于
(f g) x

Function Composition¶

函数复合可以使用 .，. 也是一个函数，它的类型是：

(.) :: (b -> c) -> (a -> b) -> a -> c

定义是：

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

但是函数复合的优先级要比函数执行低，比如：

sum . replicate 5 . max 6.7 8.9

sum . replicate 5 . max 6.7 $ 8.9

lambda¶

Haskell 语言中的 lambda 表达式是用 \ 来表示的（因为看着像 \(\mathtt{\lambda}\)？）
具体语法是

\para1 para2 ... -> return

fold 和 scan ¶

fold 和 scan 都接收三个参数（一个二元函数，一个初始值 accumulator，一个要折叠的列表），fold 返回一个值，而 scan 返回一个列表
传入的二元函数 f :: a -> b -> b 将 accumulator 和从列表中取出的值一同传入（l 则 accumulator 在左边为第一个参数，r 则 accumulator 在右边为第二个参数）

foldl¶

左折叠，每次从列表最左侧取出一个值，和 accumulator 一起传入二元函数，并且 accumulator 在左边为第一个参数，如：

foldl f a xs

> foldl f a [x1, x2, x3]
[1.] a = f a x1
[2.] a = f a x2 = f (f a x1) x2
[3.] a = f a x3 = f (f (f a x1) x2) x3

foldr¶

右折叠，每次从列表最右侧取出一个值，和 accumulator 一起传入二元函数，并且 accumulator 在右边为第二个参数，如：

foldr f a xs

> foldr f a [x1, x2, x3]
[1.] a = f x3 a
[2.] a = f x2 a = f x2 (f x3 a)
[3.] a = f x1 a = f x1 (f x2 (f x3 a))

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

例如：

ghci> foldr (||) False (repeat True)
True    -- 由于逻辑运算存在短路，计算值全应为True，所以直接返回了
ghci> foldl (||) False (repeat True)
-- 这里什么都不会发生，直到电脑内存被爆掉
-- 因为函数刚开始就需要列表最右侧的值，所以在不断计算这个无穷列表

scanl 和 scanr ¶

scan 类似 fold，只是将中间得到的每一个值都添加进一个列表中并返回这个列表 scanl 则向右延伸这个列表，scanr 则向左延伸这个列表 但是它和 fold 恰恰相反，scanl 能用于无穷列表，而 scanr 不能

> scanr f a [x1, x2, x3]
[1.] 最右侧元素(-1 in python) : a
[2.] 右侧第二个元素(-2) : f x3 a
[3.] 右侧第三个元素(-3) : f x2 (f x3 a)
[4.] 右侧第四个元素(-4) : f x1 (f x2 (f x3 a))

scanr' :: (a -> b -> b) -> b -> [a] -> [b]
scanr' _ x [] = [x]
-- scanr' f a (x:xs) = f x (foldr f a xs) : scanr' f a xs
scanr' f a (x:xs) = f x q : qs
                    where qs@(q:_) = scanr' f a xs

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

也可以看出，scanr 返回的列表的第一个元素是最后添加进去的，所以它无法用于无穷列表。而 scanl 返回的列表中的元素是从左到右依次添加，可以用于无穷列表截取前一部分结果：

ghci> take 10 (scanl (+) 0 [1..])
[0,1,3,6,10,15,21,28,36,45]
ghci> take 10 (scanr (+) 0 [1..])
[*** Exception: stack overflow

使用 foldr 编写 foldl ¶

pdcxs 还给我介绍了一个神奇的操作，用 foldl 来定义 foldr：

foldl' f z xs = foldr (\x g y -> g (f y x)) id xs z

它利用 foldr (\x g y -> g (f y x)) id xs 生成一个函数，作用于 z 得到结果。

先来看一下 foldr 的类型：

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
-- 可以看成 (a -> b -> b) -> b -> [a] -> b

所以这里 foldr 的类型可以写成：

(a -> (b -> b) -> (b -> b)) -> (b -> b) -> [a] -> (b -> b)

对应于用法 foldr (\x g y -> g (f y x)) id xs ，它返回的值应该是一个函数，类型为 b -> b（后面要作用于 z） 而 xs 对应于 [a]；id 对应于 (b -> b) 所以 (\x g y -> g (f y x)) 要对应于：

(a -> (b -> b) -> (b -> b))

因此可以推断出 x 的类型是 a；y 的类型是 b；而返回的值为一个类型为 (b -> b) 的函数。

再看，返回的值是 g (f y x) ，其中 f y x 返回的是一个值，类型为 b 所以 g 接收一个类型 b，返回一个类型 b -> b。即 g 的类型为：

b -> (b -> b)

现在根据 foldr 的定义：

foldr f a (x:xs) = f x (foldr f a xs)

带入计算一下：

xs 即为 [x1..xn]，为了方便，用 xs' 来表示 [x2..xn]，用 xs'' 来表示 [x3..xn]

定义中的 f 即为 (\x g y -> g (f y x))，a 即为 id

  foldr (\x g y -> g (f y x)) id xs z
= (\x g y -> g (f y x)) x1 (foldr (...) id xs') z

  (\x g y -> g (f y x)) x1 (foldr (...) id xs') z
= (foldr (...) id xs') (f z x1)

(foldr (...) id xs') (f z x1)

跟着这个思路，xs 每次少一个开头的元素 x'，z 每次变换成为 f z x' 因此下一步：

  (\x g y -> g (f y x)) x1 (foldr (...) id xs') z
= (foldr (...) id xs') (f z x1)
= (foldr (...) id xs'') (f (f z x1) x2)
= (foldr (...) id xs''') (f (f (f z x1) x2) x3)
= ...

最后到了不能在展开时，最前面的 foldr (...) id xs 已经变成了 foldr (...) id [] 而根据前面 foldr 的定义 foldr _ x [] = x ，它应该返回 id

所以最后的结果： (id 的定义：id x = x)

  ...
= (foldr (...) id xs') (f z x1)
= (foldr (...) id xs'') (f (f z x1) x2)
= ...
= (foldr (...) id []) (f (.. (f z x1) ..) xn)
= id (f (.. (f z x1) ..) xn)
= f (.. (f z x1) ..) xn

Modules¶

Haskell 会自动加载 Prelude 模块（module），如果在 GHCi 中再加载其他模块，需要使用 :m + ...，比如加载 Data.List 模块：

Prelude> :m + Data.List

而在 hs 文件中引入模块，需要使用 import 语句，下面和 python 的对比可以便于理解：

import Data.List
-- from Data.List import *

import Data.List (nub, sort)
-- from Data.List import nub, sort

import Data.List hiding (nub)
-- 从Data.List中引入所有，但不引入nub函数

import qualified Data.List
-- import Data.List

import qualified Data.List as Li
-- import Data.List as Li

编写 Modules ¶

模块中要包含将要使用的一些函数，像正常的 hs 文件一样写即可，但头部需要有导出语句（export）。比如一个模块文件名叫 ModuleA.hs，那它的头部需要写：

module ModuleA
( functionA
, functionB
, functionC
) where

Types & Typeclasses¶

Types¶

Haskell 有一个静态类型系统，任何变量、函数都会具有类型，并且有类型判断功能，没给出的类型会自动识别。
Type 的首字母全为大写，常用的有：

• Int：整型，有上下界范围，-2147483647～2147483648
• Integer：整数，无界，但是效率比 Int 低
• Float：单精度浮点型
• Double：双精度浮点型
• Bool：布尔值
• Char：字符
• String：字符串，等同于[Char]
• Ordering：大小关系，包含 LT、EQ、GT，且它们有大小关系 LT < EQ < GT

列表的类型是由其中元素决定的，并且列表中元素必须是同一类型，所以列表的类型就是其元素类型外加[]。

元组的类型由其中各个元素的类型共同决定，因为元组中的元素可以是不同类型。如 ("abc", 'a', True) 的类型是 ([Char], Char, Bool)。

Typeclasses¶

类型类（Typeclass）是定义一系列功能的接口，如果一个 Type 属于一个 Typeclass 的成员，那么它可以实现这个类型类所规定的功能。一个 Type 也可以属于多个 Typeclass
Typeclass的首字母也全为大写，常见的有：

• Eq：可判断是否相等
• Ord：可比较大小
• Show：可展示成字符串
• Read：可从字符串转换成特定类型
• Enum：可枚举（连续），即可以使用 pred 和 succ 函数得到前驱和后缀
• Bounded: 有上下界，如果元组中所有元素都属于 Bounded，那这个元组的类型也属于 Bounded
• Integral：是整数，包括 Int 和 Integer
• RealFloat： 是实浮点数，包括 Float 和 Double
• RealFrac：是实分数，包括 Float、Double 和 Ratio（在 Data.Ratio 模块中）
• Floating：是浮点数，包括 Float、Double 和 Complex（在 Data.Complex 模块中）
• Real：是实数，包括 Integral 和 RealFrac 的成员
• Fractional：是分数，包括 RealFrac 和 Floating 的成员
• Num：是数字，包括上述所有数字相关的类型

Type variables¶

如果查看一个函数的类型，比如 head，那么将会返回以下类型：

head :: [a] -> a

其中的 a 就是一个类型变量（type variable），它在 head 中可以属于任何类型，在这里只是表示返回值的类型和输入的列表中的元素的类型相一致。

在函数的类型表达式其实可以看作 \(\lambda\) 表达式，它适用于 \(\alpha\) 变换（\(\alpha\)-conversion）。即 a 在这里可以指 Int、Char 等类型，也可以指 [Char], (Int, Char), 甚至函数 Int -> Int 等。

在大部分函数的类型中，类型变量需要保证是某个 Typeclass 的成员才能完成操作。比如 (==) 函数，它需要传入的参数是可判断相等的，即是 Eq 的成员，那么 (==) 的类型就是：

(==) :: (Eq a) => a -> a -> Bool

其中 => 前的部分 (Eq a) 就是类约束（class constraint），它规定了 a 是 Eq 的成员，所以 (==) 函数传入的两个参数都是 a 类型，且都是 Eq 的成员，保证了它们之间是可以比较是否相等的。

定义新 Type ¶

定义一个新的 Type 需要使用 data 关键字，比如定义 Bool 需要使用：

data Bool = False | True

其中 = 左侧的部分定义了新类型的名称 Bool，右侧的部分叫做值构造器（value constructors），表示了 Bool 类型的值为 False 或 True。
并且名称和值构造器的首字母都需要大写。

另外，值构造器也是函数，它们可以有参数，叫做项（field）。比如：

data Shape = Circle Float Float Float | Rectangle Float Float Float Float   

Circle :: Float -> Float -> Float -> Shape

如果想要让它能给直接显示出来，需要让它属于 Show 类型类。在代码中只需要在结尾加上deriving (Show) :

data Shape = Circle Float Float Float | Rectangle Float Float Float Float deriving (Show)

类型的名称和值构造器名称也可以相同，比如：

data Point = Point Float Float deriving (Show)

导出 Type ¶

在文件中定义了新的 Type 之后，如果在别的文件中将其作为模块导入，则需要先导出。比如文件 Shapes.hs 中定义了 Shape 和 Point，以及其他的一些函数，那么文件开头需要写：

module Shapes
( Shape(..)
, Point(..)
, functionA
, functionB
) where

如果不想要导出值构造器，即不允许使用值构造器的方法来创建 Shape 类型的变量。那么需要将 Shape(..) 替换为 Shape，这样就只导出了 Shape 类型，而不导出其值构造器。

Record Syntax¶

如果想要方便地取出类型实例中的参数，可以使用 Record 语法，如：

data Point = Point { xcoord :: Float
                   , ycoord :: Float
                   } deriving (Show)

ghci> let point = Point 1.0 2.0
ghci> xcoord point
1.0
ghci> ycoord point
2.0

point = Point {ycoord=2.0, xcoord=1.0}

Type parameters¶

值构造器可以接收参数，类型也可以接收参数，这样它就成为了类型构造器（type constructors）。如 Maybe 的定义：

data Maybe a = Nothing | Just a

它的值是 Nothing 时，类型为 Maybe a，是多态的（polymorphic）。
它的值不是 Nothing 时，类型取决于值 Just a 中 a 的类型，可以构造出 Maybe Int、Maybe [Char] 等多种类型：

Nothing :: Maybe a
Just 1 :: Num a => Maybe a
Just 'a' :: Maybe Char
Just "abc" :: Maybe [Char]

可以用这种方法改写 Point：

data Point x y = Point { xcoord :: x
                       , ycoord :: y
                       } deriving (Show)

但使用类型参数（type parameters）并不是总是方便，比如在声明函数类型的时候不能只使用 Point 来表示 Point 类型，而是必须写成 Point Float Float。

而且不能在定义类型构造器时添加类约束（class constraint），不然在之后声明函数类型的时候也都需要添加类约束，如：

data (Ord k) => Map k v = ... 
toList :: (Ord k) => Map k a -> [(k, a)]

Either¶

Either 是一个类型构造器，它有两个值构造器，定义是：

data Either a b = Left a | Right b deriving (Eq, Ord, Read, Show)  

ghci> Right 20  
Right 20  
ghci> Left "w00t"  
Left "w00t"  
ghci> :t Right 'a'  
Right 'a' :: Either a Char  
ghci> :t Left True  
Left True :: Either Bool b  

safeDiv :: Int -> Int -> Maybe Int
safeDiv _ 0 = Nothing
safeDiv x y = Just (x `div` y)

ghci> safeDiv 4 2
Just 2
ghci> safeDiv 1 0
Nothing

safeDiv :: Int -> Int -> Either String Int
safeDiv _ 0 = Left "Divided by zero"
safeDiv x y = Right (x `div` y)

ghci> safeDiv 4 2
Right 2
ghci> safeDiv 1 0
Left "Divided by zero"

Derived instances¶

想要使一个定义的类满足某些 Typeclass 的需求，需要从其派生（derive），比如：

data Day = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday   
           deriving (Eq, Ord, Show, Read, Bounded, Enum)  

Type synonyms¶

为了阅读方便，书写简便，可以使用 type 关键字为已有类型创建别名（synonyms）。比如 String 的定义：

type String = [Char]

在所有需要使用字符串（即 [Char]）的地方都可以使用 String 来代替，它们是完全一致的，只是 String 更简便易读。
同时，类型别名也可以接收类型参数

newtype keyword¶

除了 data、type 关键字之外，还可以用 newtype 关键字来定义一个新的类型，比如 Control.Applicative 模块中的 ZipList：

newtype ZipList a = { getZipList :: [a] }

Recursive data structures¶

一个类型也可以递归定义，比如一颗二叉树：

data Tree a = EmptyTree | Node a (Tree a) (Tree a) deriving (Show, Read, Eq)  

定义新 Typeclass ¶

定义一个新的 Typeclass 需要使用 class 关键字，例如定义 Eq 类型类：

class Eq a where  
    (==) :: a -> a -> Bool  
    (/=) :: a -> a -> Bool  
    x == y = not (x /= y)  
    x /= y = not (x == y)  

包含了后两行之后，只定义 (==) 函数或者 (/=) 函数都可以完成全部定义，它们（(==) | (/=)）成为这个类型类的最小完整定义（minimal complete definition）

查看一个类型类的成员需要实现的函数可以在 GHCi 中使用 :info：

ghci> :info Eq

手动创建实例 ¶

使一个类型成为一个类型类的实例可以直接使用 deriving 来自动完成，也可以通过使用 instance 关键字来手动完成。比如使 Point 成为 Show 的实例：

instance Show Point where
    show (Point x y) = "(" ++ show x ++ ", " ++ show y ++ ")"

-- in ghci
ghci> Point 1.0 2.0
(1.0, 2.0)

同时也要注意类型和类型构造器的区别，传入给 instance 的第二个参数应该为类型而不是类型构造器，比如 Maybe：

instance Eq Maybe where  
    ...    
-- 错误用法，因为Maybe是类型构造器而不是类型

instance Eq (Maybe m) where  
    ...
-- 错误用法，因为m不一定是Eq的成员

instance (Eq m) => Eq (Maybe m) where  
    Just x == Just y = x == y  
    Nothing == Nothing = True  
    _ == _ = False  

Functor Typeclass¶

Functor 也是一种类型类，它只规定了一个函数：

class Functor f where
    fmap :: (a -> b) -> f a -> f b

Kinds¶

一个值的类型叫做类型（Type），而一个类型的类型叫做 Kind。可以通过 GHCi 中 :k 来查看 Kind：

ghci> :k Int
Int :: *
ghci> :k Maybe
Maybe :: * -> *
ghci> :k Maybe Int
Maybe Int :: *
ghci> :k Either
Either :: * -> * -> *

Input/Output¶

运行 Haskell 程序 ¶

不在 GHCi 中运行一个 Haskell 程序有两种方式：

1. 编译运行：

   $ ghc --make code
   $ ./code
   

2. 通过 runhaskell 命令直接运行：

   $ runhaskell code.hs
   

输出文本 ¶

在一个 Haskell 程序中输出文字需要定义一个 main 函数：

main = putStrLn "Hello World"

putStrLn :: String -> IO ()

putStrLn 接收一个 String 类型，并返回一个结果为 () 类型的 IO 动作（I/O action）。所以 main 函数的类型为 IO ()。（IO 的 Kind 是 * -> *）

除此之外，还有其他默认提供的输出文本的函数：

• putStr：输出文本，结尾不换行
• putChar：输出单个字符，结尾不换行。接收的参数为单个 Char，不是 String（用单引号不是双引号）
• print：可以接收任何 Show 的成员，先用 show 转化为字符串然后输出。等同于 putStrLn . show

do block¶

在 main 函数中使用多个 putStrLn 需要使用 do 语句：

main = do
    putStrLn "Line1"
    putStrLn "Line2"

输入文本 ¶

输入文字需要在 do 块中使用 getLine：

main = do
    line <- getLine
    putStrLn line

getLine :: IO String

而 <- 操作符将 getLine 中的 String 提取了出来给到了 line，使 line 变成了 String 类型的一个字符串

而且使用输入的字符串必须要经过一次 <-，不能直接使用 getLine 作为字符串，因为 getLine 不是 String 类型，而是 IO String 类型

除此之外，还可以使用 getChar 来获取单个字符，但仍然需要使用 <- 操作符来提取 Char

其他 IO 相关函数用法 ¶

return¶

Haskell 中的 return 和其他命令式语言中的 return 完全不同，它不会使函数直接结束并返回一个值。

main 函数必须定义为类型为 IO () 的函数，所以在 main 函数中使用 if 语句，如果不输出的话也不可以直接放下什么都不干，因为这时候 main 函数的类型不是 IO ()。所以这时需要使用 return () 来为 main 函数指定为 IO () 类型，例如：

main = do 
    line <- getLine
    if null line
        then return () -- <-这里
        else do
            ...

when¶

when 包含在 Control.Monad 模块中，它表示在满足第一个参数的条件下会执行第二个函数，否则会 return ()。比如：

import Control.Monad   

main = do  
    c <- getChar  
    when (c /= ' ') $ do  
        putChar c  
        main  

main = do     
    c <- getChar  
    if c /= ' '  
        then do  
            putChar c  
            main  
        else return () 

sequence¶

sequence 在 IO 中使用时可以达成 [IO a] -> IO [a] 的效果，所以可以用作：

[a, b, c] <- sequence [getLine, getLine, getLine]

mapM & mapM_¶

在 IO 相关的地方使用 map，可以使用 mapM 和 mapM_，其中 mapM 有返回值而 mapM_ 直接扔掉了返回值：

ghci> mapM print [1,2,3]  
1  
2  
3  
[(),(),()]  
ghci> mapM_ print [1,2,3]  
1  
2  
3  

forever¶

forever 函数包含在 Control.Monad 模块中。在 main 函数开头加上 forever 函数可以使后面的 do 块一直重复执行直到程序被迫终止，如：

import Control.Monad

main = forever $ do
    ...

forM¶

forM 函数包含在 Control.Monad 模块中，它的功能和 mapM 类似，从第一个参数中逐个取出元素传入第二个参数（一个接收一个参数的函数）中，并且第二个参数可以返回 IO a 类型。比如：

import Control.Monad

main = do 
    colors <- forM [1, 2, 3, 4] (\a -> do
        putStrLn $ "Which color do you associate with the number " ++ show a ++ "?"  
        color <- getLine  
        return color)
    putStrLn "The colors that you associate with 1, 2, 3 and 4 are: "  
    mapM putStrLn colors

getContents¶

getLine 获取一整行，而 getContents 从标准输入中获取全部内容直到遇到 EOF，并且它是 lazy 的，在执行了 foo <- getContents 后，它并不会读取标准输入并且赋值到 foo，而是等到需要使用 foo 的时候再从标准输入读取。

getContents 在使用管道传入文字时很常用，可以代替 forever+getLine 使用，比如一个 Haskell 程序文件 code.hs：

import Data.Char  

main = do  
    contents <- getContents  
    putStr (map toUpper contents)  

cat text.txt | ./code

interact¶

上述功能还可以转化为一个 String -> String 的函数：

upperStrings = unlines . map (map toUpper) . lines

main = do
    contents <- getContents
    putStr (upperStrings contents)

interact :: (String -> String) -> IO ()

可以看出它接收一个 String -> String 的函数，并返回一个 IO () 类型，所以可以直接用在 main 上。

于是整个转换为大写的程序就可以简化为：

main = interact $ unlines . map (map toUpper) . lines

文件和流 ¶

以下与文件和流相关的函数都包含在 System.IO 模块中

openFile¶

openFile 函数可以用来打开一个文件，它的类型是：

openFile :: FilePath -> IOMode -> IO Handle

其中 FilePath 是 String 的 type synonyms，用一个字符串来表示需要打开的文件的路径

IOMode的定义是：

data IOMode = ReadMode | WriteMode | AppendMode | ReadWriteMode

openFile 返回一个 IO Handle 类型的值，将其用 <- 操作符提取后会出现一个 Handle 的值。但不能从 Handle 中直接使用文字，还需要使用一系列函数：

• hGetContents :: Handle -> IO String ，从 Handle 中读取全部内容，返回一个 IO String
• hGetChar :: Handle -> IO Char ，从 Handle 中读取一个字符
• hGetLine :: Handle -> IO String ，从 Handle 中读取一行，返回一个 IO String
• hPutStr :: Handle -> String -> IO () ，向 Handle 中输出字符串
• hPutStrLn :: Handle -> String -> IO () ，同上

在使用 openFile 进行文件操作后，需要使用 hClose 手动关闭 Handle。hClose :: Handle -> IO ()，接收一个 Handle 并返回 IO ()，可以直接放在 main 函数末尾

所以使用 openFile 读取一个文件中的全部内容并输出的全部代码是：

import System.IO

main = do
    handle <- openFile "text.txt" ReadMode
    contents <- hGetContents handle
    putStrLn contents
    hClose handle

withFile¶

withFile 类似 Python 中的 with open，它在读取文件使用之后不需要手动 close 文件。它的类型是：

withFile :: FilePath -> IOMode -> (Handle -> IO a) -> IO a

可以看出，它接收三个参数：

• FilePath：一个表示文件路径的 String
• IOMode：打开文件的模式
• (Handle -> IO a)：一个函数，表示对读取文件后的 Handle 索要进行的操作，需要返回一个 I/O action；而这个返回值也将作为 withFile 的返回值

现在使用 withFile 来改写上述代码：

import System.IO

main = withFile "text.txt" ReadMode (\handle -> do
    contents <- hGetContents handle
    putStrLn contents)

withFile 的功能相当于以下函数：

withFile' :: FilePath -> IOMode -> (Handle -> IO a) -> IO a  
withFile' path mode f = do  
    handle <- openFile path mode   
    result <- f handle  
    hClose handle  
    return result  

readFile¶

readFile 可以更加简化读取文件内容的操作，它的类型：

readFile :: FilePath -> IO String

它只需要输入一个表示文件路径的字符串，返回其中以其中内容为内容的 I/O action：

import System.IO

main = do
    contents <- readFile "text.txt"
    putStrLn contents

writeFile¶

writeFile 简化了写入文件的操作，它的类型：

writeFile :: FilePath -> String -> IO ()

传入的第一个参数是要写入的文件的路径，第二个参数是要写入的字符串，返回一个 IO ()

appendFile¶

appendFile 类似 writeFile，但使用它不会覆盖文件中原来内容，而是直接把字符串添加到文件末尾

buffer¶

文件以流的形式被读取，默认文字文件的缓冲区（buffer）大小是一行，即每次读取一行内容；默认二进制文件的缓冲区大小是以块为单位，如果没有指定则根据系统默认来选择。

也可以通过 hSetBuffering 函数来手动设置缓冲区大小，这个函数的类型：

hSetBuffering :: Handle -> BufferMode -> IO ()

它接收一个 handle，和一个 BufferMode，并返回 IO ()。其中 BufferMode 有以下几种：

• NoBuffering：没有缓冲区，一次读入一个字符
• LineBuffering：缓冲区大小是一行，即每次读入一行内容
• BlockBuffering (Maybe Int)：缓冲区大小是一块，块的大小由 Maybe Int 指定：
  • BlockBuffering (Nothing)：使用系统默认的块大小
  • BlockBuffering (Just 2048)：一块的大小是 2048 字节，即每次读入 2048 bytes 的内容

缓冲区的刷新是自动的，也可以通过 hFlush 来手动刷新

hFlush :: Handle -> IO ()

传入一个 handle，返回 IO ()，即刷新对应 handle 的缓冲区

openTempFile¶

openTempFile 可以新建一个临时文件：

openTempFile :: FilePath -> String -> IO (FilePath, Handle)

FilePath 指临时文件要创建的位置路径，String 指临时文件名字的前缀，返回一个 I/O action，其内容第一个 FilePath 是创建得到的临时文件的路径，Handle 是临时文件的 handle

例如：

import System.IO

main = do
    (tempFile, tempHandle) <- openTempFile "." "temp"
    ...
    hClose tempHandle

路径操作 ¶

相关函数都包含在 System.Directory 模块中，全部内容见 System.Directory

getCurrentDirectory¶

getCurrentDirectory :: IO FilePath

直接返回一个 I/O action，其内容是一个字符串表示当前路径的绝对路径

removeFile¶

removeFile :: FilePath -> IO ()

输入一个文件路径，并删除掉它

renameFile¶

renameFile :: FilePath -> FilePath -> IO ()

输入一个原路径，一个新路径，为原路径的文件重命名为新路径的名

doesFileExist¶

doesFileExist :: FilePath -> IO Bool

检查文件是否存在，返回一个包含布尔值的 I/O action

Command line arguments¶

System.Environment 模块中提供了两个函数可以用来处理传入命令行的参数

getArgs¶

getArgs :: IO [String]

不需要输入参数，直接返回一个 I/O action，内容为传入命令行的参数（一个由 String 组成的列表）。相当于 C 语言中的 argv[1:]

getProgName¶

getProgName :: IO String

返回 I/O action，内容为程序的名字，相当于 C 语言中的 argv[0]

Randomness¶

和随机数有关的函数都包含在 System.Random 模块中。GHCi 启动时可能不会包含 System.Random 的配置，导致无法找到模块。需要通过 stack 打开 :

stack ghci --package random

Haskell 要求同样的程序需要运行出同样的结果，除了用到了 I/O action，所有会造成不同结果的函数都要交给 I/O action 来完成

那要使随机数脱离 IO 存在，就要用到随机生成器（random generator）

System.Random 模块提供了几个生成随机数的函数：

random¶

random :: (Random a, RandomGen g) => g -> (a, g)

其中又有两个新的 typeclass，Random 表示可以取随机，RandomGen 表示随机数生成器。random 函数接收一个随机数生成器，返回一个元组，其中第一个元素是生成的随机数，第二个元素是一个新的随机数生成器

获取随机数生成器可以使用 mkStdGen 函数：

mkStdGen :: Int -> StdGen

其中 StdGen 是一个 RandomGen 的实例

运用 random 生成随机数需要指定类型，不然程序无法确定 a 是什么类型。例如：

ghci> random (mkStdGen 100) :: (Int, StdGen)
(9216477508314497915,StdGen {unStdGen = SMGen 712633246999323047 2532601429470541125})
ghci> random (mkStdGen 100) :: (Char, StdGen)
('\537310',StdGen {unStdGen = SMGen 712633246999323047 2532601429470541125})
ghci> random (mkStdGen 100) :: (Bool, StdGen)
(True,StdGen {unStdGen = SMGen 712633246999323047 2532601429470541125})

threeCoins :: StdGen -> (Bool, Bool, Bool)  
threeCoins gen =   
    let (firstCoin, newGen) = random gen  
        (secondCoin, newGen') = random newGen  
        (thirdCoin, newGen'') = random newGen'  
    in  (firstCoin, secondCoin, thirdCoin) 

randoms¶

randoms :: (Random a, RandomGen g) => g -> [a]

randoms 接收一个 RandomGen，返回一个随机的无穷列表。因为它是无穷的，所以不会返回新的随机数生成器

randomR¶

randomR :: (Random a, RandomGen g) => (a, a) -> g -> (a, g)

可以用来生成有范围的随机数，第一个参数是一个元组，表示生成随机数的范围 ( 闭区间 )

randomRs¶

randomRs :: (Random a, RandomGen g) => (a, a) -> g -> [a]

同上两个，生成有范围的无穷随机数列表

getStdGen¶

如果想要让程序每次运行得到不同的随机结果，需要使用 getStdGen 来获取全局随机数生成器，它会在每次运行的时候产生不同的值，也因此，它返回的是一个 I/O action，而不是一个直接的 StdGen

getStdGen :: Control.Monad.IO.Class.MonadIO m => m StdGen

即可以看成 getStdGen :: IO StdGen，需要使用 <- 操作符将 StdGen 提取出来

但是在同一个程序中，getStdGen 的结果是相同的，全局随机数生成器不会自动更新，所以就需要另一个函数 newStdGen

newStdGen¶

newStdGen :: Control.Monad.IO.Class.MonadIO m => m StdGen

执行 newStdGen 会进行两个操作：

• 更新全局随机数生成器，下次执行 getStdGen 会获得不同的结果
• 返回一个 I/O action，包含一个新的 StdGen（但是这个生成器和全局生成器也不同）

Exceptions¶

程序在运行失败时会抛出异常，可以通过 Control.Exception 模块中的 catch 函数来捕获异常：

catch :: Exception e => IO a -> (e -> IO a) -> IO a

第一个参数是要进行的操作，以 IO a 为返回值的类型，第二个参数是一个函数，它接收异常并进行操作，例如：

import Control.Exception

main = main' `catch` handler

main' :: IO ()
main' = do
    ...

handler :: Exception e => e -> IO ()
handler e =  putStrLn "..."

也可以利用守卫（guard）语法和 System.IO.Error 中的函数来判断 IO 异常的类型来进行不同操作：

import System.Environment
import System.IO.Error
import Control.Exception

main = toTry `catch` handler

toTry :: IO ()  
toTry = do (fileName:_) <- getArgs  
           contents <- readFile fileName  
           putStrLn $ "The file has " ++ show (length (lines contents)) ++ " lines!"  

handler :: IOError -> IO ()  
handler e  
    | isDoesNotExistError e = putStrLn "The file doesn't exist!"  
    | otherwise = ioError e  

具体相关全部函数见文档：System.IO.Error、Control.Exception

Functors¶

函子（Functor）是一个类型类（typeclass），和其他类型类一样，它规定了其实例类必须实现的功能（例如 Eq 类型类规定了它的实例必须是可以比较是否相等的），Functor 规定类它的实例必须是可以进行映射的。Functor 要求使用fmap :: (a -> b) -> f a -> f b 函数来实现这个功能，它接收一个 a -> b 类型的函数、一个内部元素为 a 类型的函子，返回一个内部元素为 b 类型的函子

Functor 可以比作盒子，那 fmap 函数就相当于给定一个函数和一个盒子，将盒子中的全部元素都应用这个函数，再返回应用函数后的盒子

函子的实例必须是一个 Kind 为 * -> * 的类型构造器，因为它要求其是一个盒子，盒子在接收内容后才会成为一个具体的类型。fmap 中的 f a 和 f b 也是因为 f 是一个类型构造器，在接收类型 a/b 后才会变成一个具体类型（f a 和 f b）出现在函数类型声明中

Functor 的定义是 :

class Functor f where
    fmap :: (a -> b) -> f a -> f b
    (<$) :: a -> f a -> f b
    (<$) = fmap . const

ghci> 'a' <$ [1, 2, 3]
"aaa"

const :: a -> b -> a

即接收两个参数，但始终只返回第一个参数

Functor 实例 ¶

[]¶

列表 [] 是一个函子，它通过 map 函数来实现 fmap 的功能：

instance Functor [] where
    fmap = map

map :: (a -> b) -> [a] -> [b]

map 和 fmap 要求的相同，达成的目的也一致。map 接收一个函数和一个列表，它会将列表中的所有元素都应用这个函数后再返回这个列表

Maybe¶

Maybe 也具有 kind * -> *，它也是一个函子：

instance Functor Maybe where
    fmap f Nothing = Nothing
    fmap f (Just x) = Just (f x)

ghci> fmap (*2) Nothing
Nothing
ghci> fmap (*2) (Just 2)
Just 4

Either a¶

Either 的 kind 是 * -> * -> *，显然它不是函子，但是固定了一个传入类型的 Either a 的 kind 是 * -> *，也是一个函子：

instance Functor (Either a) where
    fmap f (Left x) = Left x
    fmap f (Right x) = Right (f x)

ghci> fmap (*2) (Left 4)
Left 4
ghci> fmap (*2) (Right 4)
Right 8

IO¶

IO 也是一个函子，使用 fmap 对 IO 中内容应用函数：

instance Functor IO where
    fmap f action = do
        result <- action
        return (f result)

ghci> fmap ("input: "++) getLine
test
"input: test"

(,) a¶

(,) 表示一个二元组的类型构造器，(,) :: * -> * -> *，而确定了第一个元素的类型后就变成了 (,) a，它的 kind 是 * -> *。也是一个函子，进行 fmap 函数时只对第二个元素应用：

instance Functor ((,) a) where
    fmap f (x, y) = (x, f y)

instance Functor ((,,) a b) where
    fmap f (a, b, c) = (a, b, f c)

instance Functor ((,,,) a b c) where
    fmap f (a, b, c, d) = (a, b, c, f d)

(->) r¶

-> 也是一个类型构造器，它的 kind：

(->) :: * -> * -> *

一个映射（一元函数）的类型 a -> b 也可以写成 (->) a b，它是由类型 a 和类型 b 输入到类型构造器 -> 中后形成的一个具体类型。所以确定了输入类型后的一元函数的类型就是 (->) r（其中 r 是输入的类型）

规定的 fmap 的类型签名是：

fmap :: (a -> b) -> f a -> f b

其中的 f 是函子，而在这个实例中 (->) r 就是函子，将其带入 f 可以得到：

fmap :: (a -> b) -> ((-> r) a) -> ((-> r) b)

把其中的 (->) 换成中缀可以得到：

fmap :: (a -> b) -> (r -> a) -> (r -> b)

传入两个函数，一个类型为 a -> b，一个类型为 r -> a，返回一个函数，类型为 r -> b。
不难推测这个 fmap 是将这两个函数复合了，先对输入对 r 应用第二个函数产生类型 a 的结果，然后在应用第一个函数产生类型 b 的结果，所以 (->) r 定义的 fmap 是：

instance Functor ((->) r) where
    fmap f g = (\x -> f (g x))

instance Functor ((->) r) where
    fmap = (.)

ghci> :t fmap (*3) (+100)  
fmap (*3) (+100) :: (Num a) => a -> a  
ghci> fmap (*3) (+100) 1  
303  
ghci> (*3) `fmap` (+100) $ 1  
303  
ghci> (*3) . (+100) $ 1  
303

Functor Laws¶

所有的函子都应该满足两个定律。这两个定律不是 Haskell 强制要求的，但应该确保一个函子满足这两个定律：

1. fmap id = id（其中 id 为函数 (\x -> x)）：即对一个函子 fmap id，那它应该返回本身（fmap id a = id a = a，a 为一个函子），比如：

   ghci> fmap id [1, 2, 3]
   [1,2,3]
   ghci> fmap id (Just 2)
   Just 2
   

2. fmap (f . g) = fmap f . fmap g：即函子的 fmap 支持结合律 fmap (f . g) a = fmap f . fmap g $ a = fmap f (fmap g a)，其中a为一个函子 fmap (f . g) (Just x) = fmap f (fmap g (Just x)) = fmap f (Just (g x)) = Just (f (g x))

   ghci> fmap ((*3) . (+100)) (Just 1)
   Just 303