Haskell系列教程（一）简介

Haskell特性

• 简洁的程序风格
• 强大的类型系统
• List comprehensions（wiki的意思就是有基于存在的lists创建一个list的能力）
• 递归函数
• 高阶函数（接受函数为参数，返回值为函数）
• Effectful函数（就是纯函数的反义词。Haskell提供了统一的框架来处理副作用）
• 泛型函数
• 惰性求值
• 等式推导

Haskell初体验

以下只为体验，不为详解。

第一个例子，求和函数

sum函数的定义

sum [] = 0 -- 等号左边为函数声明，右边为函数体
-- 这里我们定义了一个函数sum，接受一个空列表为参数，返回值为0

sum (n:ns) = n + sum ns --递归定义
-- (n:ns)为一个list，n代表list中的第一个元素，ns代表list中除了第一个元素以外剩下的元素，ns等于是子list
-- 这里相当于重载了sum函数的定义，接受一个list为参数，返回值为：第一个元素 + 子列表的和(递归调用sum)

sum函数的类型

sum :: Num a => [a] -> a
-- 箭头左边限定a的类型为Num；箭头右边的为函数类型定义，即接受一个列表，列表中的数据为a，返回值为a

sum函数的计算过程

sum [1, 2, 3]
-- 1. 根据函数定义可推导出 sum [1, 2, 3] = 1 + sum [2, 3]
-- 2. 以此类推 1 + sum [2, 3] = 1 + 2 + sum [3]
-- 3. 1 + 2 + sum [3] = 1 + 2 + 3 + sum []
-- 4. 1 + 2 + 3 + sum [] = 1 + 2 + 3 + 0 (根据函数定义sum [] = 0)
-- 5. 最后答案为6

第二个例子，快排函数

quicksort函数的定义

quicksort [] = [] --参数值为空列表时，返回值为空列表
quicksort (x:xs) = quicksort smaller ++ [x] ++ quicksort larger
                   where
                     smaller = [a | a <- xs, a <= x]
                     larger = [b | b <- xs, b > x]

• ++操作符把两个list连接起来，[1,2,3] ++ [4,5] = [1,2,3,4,5]
• smaller为子列表，在where中做了限定，即smaller中的元素a，取值于子列表xs，且a的值小于等于x。x为原始列表的第一个值。也就是说，smaller这个子列表中的数据都比x小或者等于x
• 同理，larger这个子列表中的数据都比x来的大

quicksort函数的类型

quickesort :: Ord a => [a] -> [a]
-- 数据a限定为Ord类型。该函数接受一个列表为参数，列表中的数据为a，返回一个列表，列表的数据为a

quicksort函数的计算过程

quicksort [1]
-- 1. quicksort [] ++ [1] ++ quicksort [] (根据定义，比1小的列表为空，比1大的列表为空)
-- 2. [] ++ [1] ++ [] (根据定义，quicksort [] = [])
-- 3. 结果为[1]

quicksort [3, 4, 5, 1, 2, 3]
-- 1. quicksort [1, 2, 3] ++ [3] ++ quicksort[4, 5]
-- 2. (quicksort [] ++ [1] ++ quicksort [2, 3]) ++ [3] ++ (quicksort [] ++ [4] ++ quicksort [5])
-- 3. ([] ++ [1] ++ (quicksort [] ++ [2] ++ quicksort [3])) ++ [3] ++ ([] ++ [4] ++ [5])
-- 4. ([] ++ [1] ++ ([] ++ [2] ++ [3])) ++ [3] ++ ([] ++ [4] ++ [5])
-- 5. 结果为[1, 2, 3, 3, 4, 5]

第三个例子，带有副作用操作的函数

seqacts函数的定义

seqacts函数接受一个列表，列表里是一系列输入或者输出操作，比如在控制台读取或者写入字符。

seqacts [] = return [] -- 此return非彼return。这里的return为一函数，用于将值包装进IO。因此此处的返回值为IO []
seqacts (act:acts) = do x <- act -- 当列表不为空时，先运行第一个操作，返回值为x
                        xs <- seqacts acts -- 对子列表继续调用seqacts函数
                        return (x:xs) -- 返回值为IO [a]

seqacts函数的类型

通过上面的定义可以推导出类型为：

seqacts :: [IO a] -> IO [a]
-- 输入输出操作是有副作用的操作，在Haskell中用IO表示副作用操作（这里可以把IO想成函数）。而a表示副作用操作的返回值(函数的返回值)
-- 返回值是一个副作用操作，这个副作用操作的返回值是一个列表，列表中的数据为a（可以这样想，返回值是个函数，这个函数的返回值是个[a]）。为什么这里不直接返回[a]，因为seqacts函数涉及了IO，返回值则也要用IO包装

IO也是有类型的，因此函数类型可以进一步抽象为：

seqacts :: Monad m => [m a] -> m [a]
-- Monad就像上两例中的Num和Ord

（完）