Haskell 简易指南

安装

用任何你喜欢的方法安装 Glasgow Haskell Compiler (a.k.a. GHC)。Cabal 之类的
依赖管理系统就用不着了。 因为我也不会用。 保证能够执行ghc和ghci命令就行。

GHCi基础

首先，把以下文件保存成helloworld.hs。

helloworld.hs
1
foo = "hello, world"

然后执行ghci helloworld.hs，然后在>提示符后输入foo并回车

1
2
3
4
5
6
GHCi, version 8.6.3: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Main             ( helloworld.hs, interpreted )
Ok, one module loaded.
*Main> foo
"hello, world"
*Main>

你可以使用:r来重新载入文件，也可以使用:l <文件名>来载入代码。

基础表达式

你可以修改你的代码文件，并在GHCi中观察程序行为。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
-- 这里是注释

foo = "hello, world"  -- 名称绑定

-- 定义一个函数，返回参数加一
plus1 x=x+1
-- 函数调用的格式为 <函数名> <参数1> <参数2> ……
-- *Main> plus1 41
-- 42

-- 递归调用，定义的顺序很重要，在前面的定义优先考虑
fact 0 = 1
fact n = n * fact (n-1)

-- 列表 (a.k.a. 数组)
list1 = ["I", "am", "a", "list"]

-- 元组
tuple1 = (1, 2)
triple1 = (1, 2, 3)

-- 元组的模式匹配
sumOfTuple (x1, x2) = x1+x2
-- *Main> sumOfTuple tuple1
-- 3

-- 列表与列表合并
list2 = [1,2,3]
list3 = [4,5,6]
list4 = list2 ++ list3
-- *Main> list4
-- [1,2,3,4,5,6]

-- 字符串是字符组成的列表
str1 = "foo" ++ ['b','a','r']
-- *Main> str1
-- "foobar"

-- 列表头部插入, 以下四种表达方式等价
list5 = [1,2,3]
list6 = 1:[2,3]
list7 = 1:2:[3]
list8 = 1:2:3:[]

-- 列表的模式匹配
sumOfList [] = 0
sumOfList (headElement:remainingElements) = headElement + sumOfList remainingElements

-- 强制前缀表达式
three = (+) 1 2

-- 强制中缀表达式，mod为取模函数
four = 18 `mod` 7

-- 函数部分求值 (Partial application)，以下两个函数等价
-- 单引号没有特殊意义，是合法函数名的一部分
plus2  x = (+) 2 x
plus2'   = (+) 2

-- if 条件 (类似三目运算符)
five = if False then 4 else 5

-- let 名称绑定
six  = let x = 7 in x-1

-- Guard
sign x
    | x < 0     = -1
    | x == 0    = 0
    | otherwise = 1

-- 函数复合
plus4  x = plus2 (plus2 x)
plus4' x = (plus2 . plus2) x
plus4''  = plus2 . plus2

-- Lambda表达式 (a.k.a. 匿名函数)
sum'  = (\x y -> x+y)
plus5 = (\x   -> sum' x 5)

这里仅列出了极少数基本用法。更多关于语言本身的以及数据结构的特定语法规则请参考相关Haskell教程。

类型标记

Haskell 是一门具有类型推导的静态类型语言。每个表达式都有自己的类型，在 GHCi 的交互模式下，可以使用:t <表达式>来检查表达式的类型。类型注记通常写为<表达式> :: <类型>。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
-- 布尔型
*Main> :t True
True::Bool

-- 元组
*Main> :t (True, False)
(True, False) :: (Bool, Bool)

-- 列表
*Main> :t "123"
"123" :: [Char]

-- 函数
*Main> :t (+)
(+) :: Num a => a -> a -> a

-- 部分求值后，新的函数只需要一个参数
*Main> :t (+) 1
(+) 1 :: Num a => a -> a

函数类型以 (参数1的类型) -> (参数2的类型) -> ... -> (返回值的类型) 形式表达。不明显区分参数和返回值。Num是代表数字的类型类，可以近似理解成Java中的接口。Num a => 表示 “在后续的类型定义中，a可以被替换成任何满足Num的类型”。整数Int和浮点数Float都是Num类型类的成员，所以加法函数既可以将整数相加，也可以将浮点数相加。

类型箭头都是右结合，但是你可以手动添加括号来改变类型的意义

1
2
3
4
5
6
7
8
9
10
11
12
-- 接受一个整型参数，返回一个新函数。这个新函数接受一个整型，返回一个整型
product' :: Int -> (Int -> Int)
product' x y = x * y
timesThree = product' 3
nine = timesThree 3
nine' = (product' 3) 3

-- 接受一个参数，该参数是“接受一个整型，返回一个整型”的函数，然后返回一个整型
some_func :: (Int -> Int) -> Int
some_func f = f 42
-- *Main> some_func (* 2)
-- 84

数据结构

Haskell 中定义新类型的基本语法是data <新类型名> [类型参数..] = <构造函数1> [成员类型...] | <构造函数2> [成员类型...] | ...。类型名和构造函数都需要首字母大写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
data NameAndAge = MakeNameAndAge String Int
-- *Main> :t MakeNameAndAge
-- MakeNameAndAge :: String -> Int -> NameAndAge

data IntOrBool = MakeInt Int | MakeBool Bool
-- *Main> :t MakeInt
-- MakeInt :: Int -> IntOrBool
-- *Main> :t MakeBool
-- MakeBool :: Bool -> IntOrBool

data Weekends = Saturday | Sunday
-- Saturday :: Weekends
-- Sunday :: Weekends

data TupleOf a = MakeTupleOf a a
-- MakeTupleOf :: a -> a -> TupleOf a
-- MakeTupleOf False True :: TupleOf Bool
-- MakeTupleOf 1 2 :: Num a => TupleOf a
-- MakeTupleOf plus1 plus2 :: Num a => TupleOf (a -> a)

-- 你可以使用函数的模式匹配来提取数据结构中的成员
printNameAndAge :: NameAndAge -> String
printNameAndAge (MakeNameAndAge name age) =
    "I'm " ++ name ++ " and I'm " ++ (show age) ++ " years old."

-- 你也可以使用模式匹配来判断是哪一个构造函数
printIntOrBool :: IntOrBool -> String
printIntOrBool (MakeInt n) = "Wow, an integer: " ++ (show n)
printIntOrBool (MakeBool b) = "Wow, a boolean: " ++ (show b)

-- 你甚至可以进行递归类型定义 。当然，你需要一个终止条件。
data ListOf a = EmptyList | AppendList (ListOf a) a

-- 相关操作也需要使用递归函数来完成
contains :: (Eq a) => ListOf a -> a -> Bool
contains EmptyList _ = False
contains (AppendList list x') x =
    if x == x' then True else contains list x

-- 为 ListOf a 类型实现 Eq 类型类
instance Eq a => Eq (ListOf a) where
    EmptyList == EmptyList                   = True
    (AppendList l1 a1) == (AppendList l2 a2) = a1 == a2 && l1 == l2
    _ == _                                   = False

注意：a是一个类型，ListOf a是一个类型，但是 ListOf 不是类型，ListOf 不是类型，ListOf 不是类型。 这个定义表示：ListOf a满足Eq 仅当 a满足Eq。要查看类型的相关信息，可以在 GHCi 中执行:info指令。

1
2
3
4
5
6
7
8
*Main> :info Eq
class Eq a where
  (==) :: a -> a -> Bool
  (/=) :: a -> a -> Bool
  {-# MINIMAL (==) | (/=) #-}
  	-- Defined in ‘GHC.Classes’
instance [safe] Eq a => Eq (ListOf a) -- Defined at [omitted]
[... omitted ...]

也许是个单子

Maybe a类似Java中的Optional<T>，常用于表示“会失败”的函数。

1
2
3
4
5
data Maybe a = Nothing | Just a

-- 一些函数
func1 :: Float -> Maybe Int
func2 :: Int -> Maybe Bool

Monad是个类型类

1
2
3
4
5
6
*Main> :info Monad
class Applicative m => Monad (m :: * -> *) where
  (>>=) :: m a -> (a -> m b) -> m b
  (>>) :: m a -> m b -> m b
  return :: a -> m a
  fail :: String -> m a

简化一下

1
2
3
class Monad m where
  (>>=) :: m a -> (a -> m b) -> m b
  return :: a -> m a

当我们说Maybe是一个Monad的时候，一方面指 Maybe 属于 Monad 这个类型类instance Monad Maybe where ...。另一方面指Maybe(数据结构)，(>>=)::Maybe a -> (a -> Maybe b) -> Maybe b (函数)，return::a -> Maybe a (函数)这三者构成了一个满足某些条件的数学结构，这些条件被称为Monad Laws。事实上，Haskell编译器不会检查 Monad Laws 是否满足，你可以胡乱写一些数据结构和函数，然后将其塞入 Monad 这个类型类中。换句话说，Haskell中的Monad就是一个接口，任何实现接口的数据类型都可以称其为Monad。

回到Maybe上，现在你想把这两个会失败的函数连接在一起

1
2
3
4
5
6
7
func3 :: Float -> Maybe Bool
-- 错误示范，类型不匹配
-- func3 = func2.func1
-- 正确示范
func3 n = case (func1 n) of
    Nothing -> Nothing
    Just n' -> func2 n'

看上去不错，我们需要一种操作，能把任意两个可失败的函数连在一起，这样以后再碰到这种情况直接复用就行了。如果第一个函数类型是a->Maybe b，第二个函数类型是b->Maybe c，那么复合函数的类型应该是a->Maybe c

1
2
3
4
5
6
7
composite :: (b -> Maybe c) -> (a -> Maybe b) -> (a -> Maybe c)
composite f g = \x ->
    case g x of
        Nothing -> Nothing
        Just y  -> f y

func3' = composite func2 func1

看上去不错，不过有个小问题，执行的第一步g x并不需要composite函数来操心，完全可以由调用者算好了传进来，于是我们再简化下

1
2
3
4
5
6
7
composite :: (b -> Maybe c) -> (Maybe b) -> (Maybe c)
composite f gx =
    case gx of
        Nothing -> Nothing
        Just y  -> f y

func3'' x = composite func2 (func1 x)

只要交换一下两个参数的顺序，我们就有了Monad Maybe的>>=函数。对于Maybe来说，它恰好有一个操作能满足Monad的定义，于是Maybe就是一个Monad。

做得越多，写得越少

do是Haskell中的一个关于>>=的语法糖，考虑有多个“可失败”函数需要调用的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
f1 x = Just (x+1)
f2 x = Just (x*2)
f3 x = Just (x-3)

-- 使用 >>= 函数
just16 = (Just 5)
         >>= (\x -> f1 (x+1))
         >>= (\y -> f2 (y+2))
         >>= (\z -> f3 (z+1))

-- 使用 do 语法
just16' = do
    x <- Just 5
    y <- f1 (x+1)
    z <- f2 (y+2)
    f3 (z+1)

do会按照规则展开成>>=函数

1
2
3
4
do x <- expr
   more_exprs
会被展开成
expr >>= (\x -> more_exprs)

因此两者是等价的。但是do语法更加整齐易于阅读。

扩展阅读