Chapter 3. Defining Types, Streamlining Functions
使用“data”自定义新类型
-- book.hs
data BookInfo = Book Int String [String]
deriving (Show)
mybook = Book 9780135072455 "Algebra of Programming"
["Richard Bird", "Oege de Moor"]
---------------
:load book
mybook
--> Book 9780135072455 "Algebra of Programming" ["Richard Bird","Oege de Moor"]
:type mybook
--> mybook :: BookInfo
“BookInfo”是类型构造器(type constructor)，类型名必须以大写字母开头。
“Book”是值构造器(value constructor)，用于创建类型为BookInfo 的值。值构造器也必须以大写字母开头。
“Int”，“String”，“[String]”是slot，值就装在这些slot 里面。
在ghci 中构造Book
ghci> Book 0 "The Book of Imaginary Beings" ["Jorge Luis Borges"]
ghci> let cities = Book 173 "Use of Weapons" ["Iain M. Banks"]
“:info”命令显示详细类型信息
:info BookInfo
Naming Types and Values
类型名和类型值是彼此独立的。
类型构造器只用于类型声明或类型签名。值构造器只用于真实代码。
类型构造器和值构造器可以有相同的名字
data BookReview = BookReview BookInfo CustomerID String
Type Synonyms
定义类型别名的方法
type B = Int
data A = A BookInfo Int B
type C = (A, B)
这里C 的类型是tupe(A,B)，这些类型别名没有值构造器
Algebraic Data Types
所有使用Data 关键字定义的类型都是代数类型
Bool 是最简单的代数数据类型
代数数据类型可以有多个值构造器
data Bool = False | True
Bool 类型有两个值构造器，Ture 和False。
代数类型的值构造器可以接受零个或多个参数。
type CardHolder = String
type CardNumber = String
type Address = [String]
data BillingInfo = CreditCard CardNumber CardHolder Address
| CashOnDelivery
| Invoice CustomerID
deriving (Show)
BillingInfo 有三个值构造器，而且各自接受的参数也不同。
Tuples, Algebraic Data Types, and When to Use Each
有相同类型签名的pairs tuple 具有相同的类型
a = ("Porpoise", "Grey")
b = ("Table", "Oak")
“==”操作符要求两边有相同的类型
Analogues to Algebraic Data Types in Other Languages
The enumeration
用代数类型实现枚举
data Roygbiv = Red
| Orange
| Yellow
| Green
| Blue
| Indigo
| Violet
deriving (Eq, Show)
Red == Yellow --> False
Green == Green --> True
The discriminated union
用代数类型实现联合(union)
type Vector = (Double, Double)
data Shape = Circle Vector Double
| Poly [Vector]
如果使用Circle 构造器，我们实际上创建了并存储了一个Circle 值，相反用Poly ，就存Poly 值。
Pattern Matching
假设我们得到某类型的一些值：
1. 如果此类型有多个值构造器，我们应能够知道这个值是由哪个构造器构造出来的。
2. 如果值构造器拥有数据域(slot)，我们应能够取出这些数据值。
Haskell 有一个简单但极有用的模式匹配机制，可以完成这两个任务。
实现Not 函数
myNot True = False
myNot False = True
myNot True -->Fale
myNot True -->Ture
看起来像是定义了两个名为myNot 的函数，但Haskell 允许将函数定义为一系列的等式。这样同一个函数对于不同的输入模式具有不同的行为。
排在前面的函数等式优先匹配。
对列表的所有元素求和
sumList (x:xs) = x + sumList xs
sumList [] = 0
sumList [1,2] --> 3
（运算符“:” 在表的前端添加一个元素，前面必须是一个元素，后面必须是一个列表）
[1,2] 是 (1:(2:[])) 的简略写法。但函数参数列表(x:xs) 中的“：”是表示匹配，结果是1 匹配x，2:[] 匹配xs。函数的参数匹配就把list 拆成两部分，part1 + 递归调用part2。注意函数等式的排列顺序，排在前面的优先匹配。
最后，标准函数sum 与上面我们定义的函数有同样的功能。
Construction and Deconstruction
不要被deconstruction 迷惑，模式匹配不解构任何东西，只是让我们“look inside”某个东西。
Further Adventures
返回3-tuple 的第三个值的函数
third (a, b, c) = c
一个稍复杂的参数匹配例子
complicated (True, a, x:xs, 5) = (a, xs)
complicated (True, 1, [1,2,3], 5) -- > (1,[2,3])
complicated (False, 1, [1,2,3], 5) -- 参数匹配失败
data BookInfo = Book Int String [String]
deriving (Show)
bookID (Book id title authors) = id
bookID (Book 1 “tt” [“dsa”]) --> 1
m3list (3:xs) = 3 + m3list xs -- 只匹配全3 为元素的list，不是全3 会引起运行时错误
m3list [] = 0
m3list [3,3,3] --> 9
The Wild Card Pattern
“_”称为wild card
模式中的任意值“_”
data BookInfo = Book Int String [String]
deriving (Show)
bookID (Book id _ _) = id
bookID (Book 1 “tt” [“dsa”]) --> 1
Exhaustive Patterns and Wild Cards
默认匹配
goodExample (x:xs) = x + goodExample xs
goodExample _ = 0
goodExample [1,2] -- > 3
Record Syntax
nicerID (Book id _ _ ) = id 这种代码称为boilerplate，既bulky又irksome。
取出记录里的字段值
type CustomerID = Int
type Address = [String]
data Customer = Customer {
customerID :: CustomerID, -- customerID 是一个函数，输入Customer返回CustomerID
customerName :: String,
customerAddress :: Address
} deriving (Show)
let aa = Customer 1 “dfs” [“dfsa”]
customerID aa --> 1
记录函数(accessor functions)的另一种写法
data Customer = Customer Int String [String]
deriving (Show)
customerID :: Customer -> Int
customerID (Customer id _ _) = id
创建记录类型值的Detail 风格
customer2 = Customer {
customerID = 271828,
customerAddress = ["1048576 Disk Drive",
"Milpitas, CA 95134",
"USA"],
customerName = "Jane Q. Citizen"
}
data CalendarTime = CalendarTime {
ctYear :: Int,
ctDay, ctHour, ctMin, ctSec :: Int
}
ctime = CalendarTime {
ctYear = 1,
ctDay=3, ctHour=4, ctMin=5, ctSec=6
}
使用记录的detail 创建风格可以改变记录的order。这里customerName 就和customerAddress 的顺序就对调了。
使用记录的detail 创建风格打印的时侯也会显示更多信息。
如果不使用记录语法，要从一个类型提取某个字段的值将是一件痛若的事。
Parameterized Types
Maybe a 类型
data Maybe a = Something a
| Nonething
deriving (Eq, Show)
Something 2 --> Something 2
:type Something “string"
--> Something “string" :: Main.Maybe [char]
Something (Something 2) --> 嵌套定义要加括号
Recursive Types
list 类型是递归定义的。
List a 类型
data List a = Cons a (List a)
| Nil
deriving (Show)
fromList (x:xs) = Cons x (fromList xs) -- 用list 来构造List a
fromList [] = Nil
Nil -> Nil
Cons 0 Nil -- > Cons 0 Nil
Cons 1 it -- > Cons 1 (Cons 0 Nil)
fromList "durian"
--> Cons 'd' (Cons 'u' (Cons 'r' (Cons 'i' (Cons 'a' (Cons 'n' Nil)))))
Cons 构造器需要两个参数，一个a, 一个list a
二叉树
data Tree a = Node a (Tree a) (Tree a)
| Empty
deriving (Show)
Node 1 (Node 2 Empty Empty) (Node 3 Empty Empty)
simpleTree = Node "parent" (Node "left child" Empty Empty)
(Node "right child" Empty Empty)
Haskell 没有Null 类型，可以用Maybe 类型获得Null 类型的效果，但是这样做需要模式匹配；替代方法是用无参的值构造器（如Nil，Empty）。
Reporting Errors
error 函数输出错误消息，并立既终止程序。
error :: String -> a
因为返回类型是a ，所以可以在任何地方调用，并返回正确的类型。
返回List 列表的第二个元素，不够两个元素就报错（有问题版）
mySecond :: [a] -> a -- 不写好像也可以自动推断出参数类型因为tail 接受list
mySecond xs = if null (tail xs)
then error "list too short"
else head (tail xs)
mySecond "ab" --> 'b'
mySecond "a" --> Exception: list too short
head (mySecond [[9]]) --> Exception: list too short
mySecond [] --> 参数匹配失败，要求[a]，这里是[]
错误处理函数error 的缺点是不能区分对待可恢复错误和能终止程序的至命错误。
A More Controlled Approach
返回List 列表的第二个元素，不够两个元素就报错（待改进）
safeSecond :: [a] -> Maybe a
safeSecond [] = Nothing
safeSecond xs = if null (tail xs)
then Nothing
else Just (head (tail xs))
safeSecond [] --> Nothing
safeSecond [1] --> Nothing
safeSecond [1,2] -->Just 2
safeSecond [1,2,3] -->Just 2
返回List 列表的第二个元素，不够两个元素就报错
tidySecond :: [a] -> Maybe a
tidySecond (_:x:_) = Just x -- 亮点!
tidySecond _ = Nothing
tidySecond [1,2] -->Just 2
模式“_:x:_”只匹配有两个元素以上的List 列表。
Introducing Local Variables
let 关键字开始一个变量声明块，并以关键字in 作为结束。
函数体内部使用let 定义局部变量。
lend amount balance = let reserve = 100 -- 如果ghci 报错就在行后加个分号“;”
newBalance = balance - amount
in if balance < reserve
then Nothing
else Just newBalance
let 的左边被捆绑到右边的表达式，注意let是与表达式而不是与值捆绑
如果我们能使用一个名字，它就是“in scope”，否则就是“out of scope”；如果一个名字在整个源文件可见，我们就说它位于“top level”
Shadowing
let 可以互相嵌套但不是聪明的做法
foo = let a = 1
in let b = 2
in a + b
print foo -- >3
shadowing 变量(影子变量)
bar = let x = 1
in ((let x = "foo" in x), x)
-- >("foo",1)
里面的x，是外面x 的shadowing ，shadowing 变量是一个同名变量，类型和值都可以不同。
shadow 一个函数的参数
quux a = let a = "foo";
in a ++ "eek!"
type quux -- t -> [Char]
因为函数的参数永远不会被用到，所以参数可以是任意类型t
使用GHC 的选项“-fwarn-name-shadowing”可以开启shadow 警告，以避免发生莫明其妙的问题。
The where Clause
我们可以使用另一种机制引入局部变量：where 子句。
使用where 子句推迟局部变量的定义
lend2 amount balance = if amount < reserve * 0.5
then Just newBalance
else Nothing
where reserve = 100
newBalance = balance – amount -- 注意和上面对齐，不然会出错
where 子句有助于将读者的注意力集中在重要的位置，局部变量的值留到后面用where 来定义。
Local Functions, Global Variables
定义局部函数和定义局部变量一样简单。
定义局部函数
pluralise :: String -> [Int] -> [String]
pluralise word counts = map plural counts
where plural 0 = "no " ++ word ++ "s"
plural 1 = "one " ++ word
plural n = show n ++ " " ++ word ++ "s"
局部函数plural 含有多个等式，并使用了外部函数pluralise 的变量word。
定义全局变量
itemName = "Weighted Companion Cube"
在源文件的top level 定义既可
The Offside Rule and Whitespace in an Expression
Haskell 这种使用缩排的规则称为“offside rule”。
第一个使用top-level 的声明或定义可以从任何列开始，然后Haskell 编译器或解释器就会记住那个缩排层级数；所有后面的top-level 声明都必须和第一个top-level 具有同样的缩进。
bar = let b = 2
c = True
in let a = b
in (a, c)
a 只对里面的let 可见，外面的let 不可见。
foo = x
where x = y
where y = 2 -- 注意这个where 的缩进
A Note About Tabs Versus Spaces
把编辑器调成用空格代替Tab
The Offside Rule Is Not Mandatory
“offside rule”不是强制的
可以用大括号“{}”将equations 括起来，并用分号“;”分隔里面的每项。
用大括号代替缩排
bar = let a = 1
b = 2
c = 3
in a + b + c
foo = let { a = 1; b = 2;
c = 3 }
in a + b + c
The case Expression
函数定义不是唯一可以使用模式匹配的地方。“case”语句也会进行模式匹配。
case 语句
fromMaybe defval wrapped =
case wrapped of
Nothing -> defval
Just value -> value
“-> ” 左边是模式，如被匹配右边就得以evaluate
case 关键字后接一个任意的表达式，并且用这个表达式的值去匹配“of”后面的表达式。匹配的须序是自上往下。
“of”后面的所有表达式必须具有相同的类型。
wild card 表达式“_”可以放在case 语句的最后用作默认匹配。
Common Beginner Mistakes with Patterns
以下是初学者对模式的常见误用
Incorrectly Matching Against a Variable
“of”后面应该写case 对应的表达式的值
错误的版本
data Fruit = Apple | Orange
apple = "apple"
orange = "orange"
whichFruit :: String -> Fruit
whichFruit f = case f of
apple -> Apple
orange -> Orange
正确的版本
data Fruit = Apple | Orange -- 亮点
betterFruit f = case f of
"apple" → Apple
"orange" → Orange
函数betterFruit 的类型签名可以自动推断出来，因为输入与String 型的"apple" 匹配，输出与Fruit 类型的"Apple" 匹配。
Incorrectly Trying to Compare for Equality
模式里的名字只能出现一次
错误的例子
bad_nodesAreSame (Node a _ _) (Node a _ _) = Just a
bad_nodesAreSame _ _ = Nothing
解决这个问题要用到guards
Conditional Evaluation with Guards
对函数的参数进行条件测试
-- Node 是Tree 的值构造器；结点本身也是树，两者是一回事
data Tree a = Node a (Tree a) (Tree a)
| Empty
deriving (Show)
nodesAreSame (Node a _ _) (Node b _ _)
| a == b = Just a
nodesAreSame _ _ = Nothing
“| a == b” 是参数模式的“guards”。一个模式可以有零个或多个“guards”。
“guards” 就是类型为bool 的一个表达式。
“guards”使用符号“|” 引入
使用guards 让代码变得更清晰
myDrop n xs = if n <= 0 || null xs
then xs
else myDrop (n - 1) (tail xs)
niceDrop n xs | n <= 0 = xs
niceDrop _ [] = []
niceDrop n (_:xs) = niceDrop (n - 1) xs
