構造我們自己的 Types 和 Typeclasses

Algebraic Data Types 入門

在前面的章節中,我們談了一些 Haskell 內建的型別和 Typeclass。而在本章中,我們將學習構造型別和 Typeclass 的方法。
我們已經見識過許多型別,如 BoolIntCharMaybe 等等,不過在 Haskell 中該如何構造自己的型別呢?好問題,一種方法是使用 data 關鍵字。首先我們來看看 Bool 在標準函式庫中的定義:
1
data Bool = False | True
Copied!
data 表示我們要定義一個新的型別。= 的左端標明型別的名稱即 Bool= 的右端就是值構造子 (Value Constructor),它們明確了該型別可能的值。| 讀作"或",所以可以這樣閲讀該聲明:Bool 型別的值可以是 TrueFalse。型別名和值構造子的首字母必大寫。
相似,我們可以假想 Int 型別的聲明:
1
data Int = -2147483648 | -2147483647 | ... | -1 | 0 | 1 | 2 | ... | 2147483647
Copied!
頭尾兩個值構造子分別表示了 Int 型別的最小值和最大值,注意到真正的型別宣告不是長這個樣子的,這樣寫只是為了便於理解。我們用省略號表示中間省略的一大段數字。
我們想想 Haskell 中圖形的表示方法。表示圓可以用一個 Tuple,如 (43.1,55.0,10.4),前兩項表示圓心的位置,末項表示半徑。聽著不錯,不過三維向量或其它什麼東西也可能是這種形式!更好的方法就是自己構造一個表示圖形的型別。假定圖形可以是圓 (Circle) 或長方形 (Rectangle):
1
data Shape = Circle Float Float Float | Rectangle Float Float Float Float
Copied!
這是啥,想想?Circle 的值構造子有三個項,都是 Float。可見我們在定義值構造子時,可以在後面跟幾個型別表示它包含值的型別。在這裡,前兩項表示圓心的坐標,尾項表示半徑。Rectangle 的值構造子取四個 Float 項,前兩項表示其左上角的坐標,後兩項表示右下角的坐標。
談到「項」 (field),其實應為「參數」 (parameters)。值構造子的本質是個函數,可以返回一個型別的值。我們看下這兩個值構造子的型別聲明:
1
ghci> :t Circle
2
Circle :: Float -> Float -> Float -> Shape
3
ghci> :t Rectangle
4
Rectangle :: Float -> Float -> Float -> Float -> Shape
Copied!
Cool,這麼說值構造子就跟普通函數並無二致囉,誰想得到?我們寫個函數計算圖形面積:
1
surface :: Shape -> Float
2
surface (Circle _ _ r) = pi * r ^ 2
3
surface (Rectangle x1 y1 x2 y2) = (abs $ x2 - x1) * (abs $ y2 - y1)
Copied!
值得一提的是,它的型別聲明表示了該函數取一個 Shape 值並返回一個 Float 值。寫 Circle -> Float 是不可以的,因為 Circle 並非型別,真正的型別應該是 Shape。這與不能寫True->False 的道理是一樣的。再就是,我們使用的模式匹配針對的都是值構造子。之前我們匹配過 []False5,它們都是不包含參數的值構造子。
我們只關心圓的半徑,因此不需理會表示坐標的前兩項:
1
ghci> surface $ Circle 10 20 10
2
314.15927
3
ghci> surface $ Rectangle 0 0 100 100
4
10000.0
Copied!
Yay,it works!不過我們若嘗試輸出 Circle 10 20 到控制台,就會得到一個錯誤。這是因為 Haskell 還不知道該型別的字元串表示方法。想想,當我們往控制台輸出值的時候,Haskell 會先呼叫 show 函數得到這個值的字元串表示才會輸出。因此要讓我們的 Shape 型別成為 Show 型別類的成員。可以這樣修改:
1
data Shape = Circle Float Float Float | Rectangle Float Float Float Float deriving (Show)
Copied!
先不去深究 deriving(派生),可以先這樣理解:若在 data 聲明的後面加上 deriving (Show),那 Haskell 就會自動將該型別至于 Show 型別類之中。好了,由於值構造子是個函數,因此我們可以拿它交給 map,拿它不全呼叫,以及普通函數能做的一切。
1
ghci> Circle 10 20 5
2
Circle 10.0 20.0 5.0
3
ghci> Rectangle 50 230 60 90
4
Rectangle 50.0 230.0 60.0 90.0
Copied!
我們若要取一組不同半徑的同心圓,可以這樣:
1
ghci> map (Circle 10 20) [4,5,6,6]
2
[Circle 10.0 20.0 4.0,Circle 10.0 20.0 5.0,Circle 10.0 20.0 6.0,Circle 10.0 20.0 6.0]
Copied!
我們的型別還可以更好。增加加一個表示二維空間中點的型別,可以讓我們的 Shape 更加容易理解:
1
data Point = Point Float Float deriving (Show)
2
data Shape = Circle Point Float | Rectangle Point Point deriving (Show)
Copied!
注意下 Point 的定義,它的型別與值構造子用了相同的名字。沒啥特殊含義,實際上,在一個型別含有唯一值構造子時這種重名是很常見的。好的,如今我們的 Circle 含有兩個項,一個是 Point 型別,一個是 Float 型別,好作區分。Rectangle 也是同樣,我們得修改 surface 函數以適應型別定義的變動。
1
surface :: Shape -> Float
2
surface (Circle _ r) = pi * r ^ 2
3
surface (Rectangle (Point x1 y1) (Point x2 y2)) = (abs $ x2 - x1) * (abs $ y2 - y1)
Copied!
唯一需要修改的地方就是模式。在 Circle 的模式中,我們無視了整個 Point。而在 Rectangle 的模式中,我們用了一個嵌套的模式來取得 Point 中的項。若出於某原因而需要整個 Point,那麼直接匹配就是了。
1
ghci> surface (Rectangle (Point 0 0) (Point 100 100))
2
10000.0
3
ghci> surface (Circle (Point 0 0) 24)
4
1809.5574
Copied!
表示移動一個圖形的函數該怎麼寫?它應當取一個 Shape 和表示位移的兩個數,返回一個位於新位置的圖形。
1
nudge :: Shape -> Float -> Float -> Shape
2
nudge (Circle (Point x y) r) a b = Circle (Point (x+a) (y+b)) r
3
nudge (Rectangle (Point x1 y1) (Point x2 y2)) a b = Rectangle (Point (x1+a) (y1+b)) (Point (x2+a) (y2+b))
Copied!
簡潔明瞭。我們再給這一 Shape 的點加上位移的量。
1
ghci> nudge (Circle (Point 34 34) 10) 5 10
2
Circle (Point 39.0 44.0) 10.0
Copied!
如果不想直接處理 Point,我們可以搞個輔助函數 (auxilliary function),初始從原點創建圖形,再移動它們。
1
baseCircle :: Float -> Shape
2
baseCircle r = Circle (Point 0 0) r
3
4
baseRect :: Float -> Float -> Shape
5
baseRect width height = Rectangle (Point 0 0) (Point width height)
Copied!
1
ghci> nudge (baseRect 40 100) 60 23
2
Rectangle (Point 60.0 23.0) (Point 100.0 123.0)
Copied!
毫無疑問,你可以把你的數據型別導出到模組中。只要把你的型別與要導出的函數寫到一起就是了。再在後面跟個括號,列出要導出的值構造子,用逗號隔開。如要導出所有的值構造子,那就寫個..。
若要將這裡定義的所有函數和型別都導出到一個模組中,可以這樣:
1
module Shapes
2
( Point(..)
3
, Shape(..)
4
, surface
5
, nudge
6
, baseCircle
7
, baseRect
8
) where
Copied!
一個 Shape (..),我們就導出了 Shape 的所有值構造子。這一來無論誰導入我們的模組,都可以用 RectangleCircle 值構造子來構造 Shape 了。這與寫 Shape(Rectangle,Circle) 等價。
我們可以選擇不導出任何 Shape 的值構造子,這一來使用我們模組的人就只能用輔助函數 baseCirclebaseRect 來得到 Shape 了。Data.Map 就是這一套,沒有 Map.Map [(1,2),(3,4)],因為它沒有導出任何一個值構造子。但你可以用,像 Map.fromList 這樣的輔助函數得到 map。應該記住,值構造子只是函數而已,如果不導出它們,就拒絶了使用我們模組的人呼叫它們。但可以使用其他返回該型別的函數,來取得這一型別的值。
不導出數據型別的值構造子隱藏了他們的內部實現,令型別的抽象度更高。同時,我們模組的使用者也就無法使用該值構造子進行模式匹配了。

Record Syntax

OK,我們需要一個數據型別來描述一個人,得包含他的姓、名、年齡、身高、電話號碼以及最愛的冰淇淋。我不知你的想法,不過我覺得要瞭解一個人,這些資料就夠了。就這樣,實現出來!
1
data Person = Person String String Int Float String String deriving (Show)
Copied!
O~Kay,第一項是名,第二項是姓,第三項是年齡,等等。我們造一個人:
1
ghci> let guy = Person "Buddy" "Finklestein" 43 184.2 "526-2928" "Chocolate"
2
ghci> guy
3
Person "Buddy" "Finklestein" 43 184.2 "526-2928" "Chocolate"
Copied!
貌似很酷,就是難讀了點兒。弄個函數得人的某項資料又該如何?如姓的函數,名的函數,等等。好吧,我們只能這樣:
1
firstName :: Person -> String
2
firstName (Person firstname _ _ _ _ _) = firstname
3
4
lastName :: Person -> String
5
lastName (Person _ lastname _ _ _ _) = lastname
6
7
age :: Person -> Int
8
age (Person _ _ age _ _ _) = age
9
10
height :: Person -> Float
11
height (Person _ _ _ height _ _) = height
12
13
phoneNumber :: Person -> String
14
phoneNumber (Person _ _ _ _ number _) = number
15
16
flavor :: Person -> String
17
flavor (Person _ _ _ _ _ flavor) = flavor
Copied!
唔,我可不願寫這樣的程式碼!雖然 it works,但也太無聊了哇。
1
ghci> let guy = Person "Buddy" "Finklestein" 43 184.2 "526-2928" "Chocolate"
2
ghci> firstName guy
3
"Buddy"
4
ghci> height guy
5
184.2
6
ghci> flavor guy
7
"Chocolate"
Copied!
你可能會說,一定有更好的方法!呃,抱歉,沒有。
開個玩笑,其實有的,哈哈哈~Haskell 的發明者都是天才,早就料到了此類情形。他們引入了一個特殊的型別,也就是剛纔提到的更好的方法 -- Record Syntax
1
data Person = Person { firstName :: String
2
, lastName :: String
3
, age :: Int
4
, height :: Float
5
, phoneNumber :: String
6
, flavor :: String
7
} deriving (Show)
Copied!
與原先讓那些項一個挨一個的空格隔開不同,這裡用了花括號 {}。先寫出項的名字,如 firstName,後跟兩個冒號(也叫 Paamayim Nekudotayim,哈哈~(譯者不知道什麼意思~囧)),標明其型別,返回的數據型別仍與以前相同。這樣的好處就是,可以用函數從中直接按項取值。通過 Record Syntax,Haskell 就自動生成了這些函數:firstName, lastName, age, height, phoneNumberflavor
1
ghci> :t flavor
2
flavor :: Person -> String
3
ghci> :t firstName
4
firstName :: Person -> String
Copied!
還有個好處,就是若派生 (deriving) 到 Show 型別類,它的顯示是不同的。假如我們有個型別表示一輛車,要包含生產商、型號以及出場年份:
1
data Car = Car String String Int deriving (Show)
Copied!
1
ghci> Car "Ford" "Mustang" 1967
2
Car "Ford" "Mustang" 1967
Copied!
若用 Record Syntax,就可以得到像這樣的新車:
1
data Car = Car {company :: String, model :: String, year :: Int} deriving (Show)
Copied!
1
ghci> Car {company="Ford", model="Mustang", year=1967}
2
Car {company = "Ford", model = "Mustang", year = 1967}
Copied!
這一來在造車時我們就不必關心各項的順序了。
表示三維向量之類簡單數據,Vector = Vector Int Int Int 就足夠明白了。但一個值構造子中若含有很多個項且不易區分,如一個人或者一輛車啥的,就應該使用 Record Syntax。

Type parameters

值構造子可以取幾個參數產生一個新值,如 Car 的構造子是取三個參數返回一個 Car。與之相似,型別構造子可以取型別作參數,產生新的型別。這咋一聽貌似有點深奧,不過實際上並不複雜。如果你對 C++ 的模板有瞭解,就會看到很多相似的地方。我們看一個熟悉的型別,好對型別參數有個大致印象:
1
data Maybe a = Nothing | Just a
Copied!
這裡的a就是個型別參數。也正因為有了它,Maybe 就成為了一個型別構造子。在它的值不是 Nothing 時,它的型別構造子可以搞出 Maybe IntMaybe String 等等諸多型別。但只一個 Maybe 是不行的,因為它不是型別,而是型別構造子。要成為真正的型別,必須得把它需要的型別參數全部填滿。
所以,如果拿 Char 作參數交給 Maybe,就可以得到一個 Maybe Char 的型別。如,Just 'a' 的型別就是 Maybe Char
你可能並未察覺,在遇見 Maybe 之前我們早就接觸到型別參數了。它便是 List 型別。這裡面有點語法糖,List 型別實際上就是取一個參數來生成一個特定型別,這型別可以是 [Int][Char] 也可以是 [String],但不會跟在 [] 的後面。
把玩一下 Maybe
1
ghci> Just "Haha"
2
Just "Haha"
3
ghci> Just 84
4
Just 84
5
ghci> :t Just "Haha"
6
Just "Haha" :: Maybe [Char]
7
ghci> :t Just 84
8
Just 84 :: (Num t) => Maybe t
9
ghci> :t Nothing
10
Nothing :: Maybe a
11
ghci> Just 10 :: Maybe Double
12
Just 10.0
Copied!
型別參數很實用。有了它,我們就可以按照我們的需要構造出不同的型別。若執行 :t Just "Haha",型別推導引擎就會認出它是個 Maybe [Char],由於 Just a 裡的 a 是個字元串,那麼 Maybe a 裡的 a 一定也是個字元串。
注意下,Nothing 的型別為 Maybe a。它是多態的,若有函數取 Maybe Int 型別的參數,就一概可以傳給它一個 Nothing,因為 Nothing 中不包含任何值。Maybe a 型別可以有 Maybe Int 的行為,正如 5 可以是 Int 也可以是 Double。與之相似,空 List 的型別是 [a],可以與一切 List 打交道。因此,我們可以 [1,2,3]++[],也可以 ["ha","ha,","ha"]++[]
型別參數有很多好處,但前提是用對了地方才行。一般都是不關心型別裡面的內容,如 Maybe a。一個型別的行為若有點像是容器,那麼使用型別參數會是個不錯的選擇。我們完全可以把我們的Car型別從
1
data Car = Car { company :: String
2
, model :: String
3
, year :: Int
4
} deriving (Show)
Copied!
改成:
1
data Car a b c = Car { company :: a
2
, model :: b
3
, year :: c
4
} deriving (Show)
Copied!
但是,這樣我們又得到了什麼好處?回答很可能是,一無所得。因為我們只定義了處理 Car String String Int 型別的函數,像以前,我們還可以弄個簡單函數來描述車的屬性。
1
tellCar :: Car -> String
2
tellCar (Car {company = c, model = m, year = y}) = "This " ++ c ++ " " ++ m ++ " was made in " ++ show y
Copied!
1
ghci> let stang = Car {company="Ford", model="Mustang", year=1967}
2
ghci> tellCar stang
3
"This Ford Mustang was made in 1967"
Copied!
可愛的小函數!它的型別聲明得很漂亮,而且工作良好。好,如果改成 Car a b c 又會怎樣?
1
tellCar :: (Show a) => Car String String a -> String
2
tellCar (Car {company = c, model = m, year = y}) = "This " ++ c ++ " " ++ m ++ " was made in " ++ show y
Copied!
我們只能強制性地給這個函數安一個 (Show a) => Car String String a 的型別約束。看得出來,這要繁複得多。而唯一的好處貌似就是,我們可以使用 Show 型別類的 instance 來作 a 的型別。
1
ghci> tellCar (Car "Ford" "Mustang" 1967)
2
"This Ford Mustang was made in 1967"
3
ghci> tellCar (Car "Ford" "Mustang" "nineteen sixty seven")
4
"This Ford Mustang was made in \"nineteen sixty seven\""
5
ghci> :t Car "Ford" "Mustang" 1967
6
Car "Ford" "Mustang" 1967 :: (Num t) => Car [Char] [Char] t
7
ghci> :t Car "Ford" "Mustang" "nineteen sixty seven"
8
Car "Ford" "Mustang" "nineteen sixty seven" :: Car [Char] [Char] [Char]
Copied!
其實在現實生活中,使用 Car String String Int 在大多數情況下已經滿夠了。所以給 Car 型別加型別參數貌似並沒有什麼必要。通常我們都是都是在一個型別中包含的型別並不影響它的行為時才引入型別參數。一組什麼東西組成的 List 就是一個 List,它不關心裡面東西的型別是啥,然而總是工作良好。若取一組數字的和,我們可以在後面的函數體中明確是一組數字的 List。Maybe 與之相似,它表示可以有什麼東西可以沒有,而不必關心這東西是啥。
我們之前還遇見過一個型別參數的應用,就是 Data.Map 中的 Map k vk 表示 Map 中鍵的型別,v 表示值的型別。這是個好例子,Map 中型別參數的使用允許我們能夠用一個型別索引另一個型別,只要鍵的型別在 Ord 型別類就行。如果叫我們自己定義一個 Map 型別,可以在 data 聲明中加上一個型別類的約束。
1
data (Ord k) => Map k v = ...
Copied!
然而 Haskell 中有一個嚴格的約定,那就是永遠不要在 data 聲明中添加型別約束。為啥?嗯,因為這樣沒好處,反而得寫更多不必要的型別約束。Map k v 要是有 Ord k 的約束,那就相當於假定每個 Map 的相關函數都認為 k 是可排序的。若不給數據型別加約束,我們就不必給那些不關心鍵是否可排序的函數另加約束了。這類函數的一個例子就是 toList,它只是把一個 Map 轉換為關聯 List 罷了,型別聲明為 toList :: Map k v -> [(k, v)]。要是加上型別約束,就只能是 toList :: (Ord k) =>Map k a -> [(k,v)],明顯沒必要嘛。
所以說,永遠不要在 data 聲明中加型別約束 --- 即便看起來沒問題。免得在函數聲明中寫出過多無謂的型別約束。
我們實現個表示三維向量的型別,再給它加幾個處理函數。我麼那就給它個型別參數,雖然大多數情況都是數值型,不過這一來它就支持了多種數值型別。
1
data Vector a = Vector a a a deriving (Show)
2
vplus :: (Num t) => Vector t -> Vector t -> Vector t
3
(Vector i j k) `vplus` (Vector l m n) = Vector (i+l) (j+m) (k+n)
4
vectMult :: (Num t) => Vector t -> t -> Vector t
5
(Vector i j k) `vectMult` m = Vector (i*m) (j*m) (k*m)
6
scalarMult :: (Num t) => Vector t -> Vector t -> t
7
(Vector i j k) `scalarMult` (Vector l m n) = i*l + j*m + k*n
Copied!
vplus 用來相加兩個向量,即將其所有對應的項相加。scalarMult 用來求兩個向量的標量積,vectMult 求一個向量和一個標量的積。這些函數可以處理 Vector IntVector IntegerVector Float 等等型別,只要 Vector a 裡的這個 aNum 型別類中就行。同樣,如果你看下這些函數的型別聲明就會發現,它們只能處理相同型別的向量,其中包含的數字型別必須與另一個向量一致。注意,我們並沒有在 data 聲明中添加 Num 的類約束。反正無論怎麼著都是給函數加約束。
再度重申,型別構造子和值構造子的區分是相當重要的。在聲明數據型別時,等號=左端的那個是型別構造子,右端的(中間可能有|分隔)都是值構造子。拿 Vector t t t -> Vector t t t -> t 作函數的型別就會產生一個錯誤,因為在型別聲明中只能寫型別,而 Vector 的型別構造子只有個參數,它的值構造子才是有三個。我們就慢慢耍:
1
ghci> Vector 3 5 8 `vplus` Vector 9 2 8
2
Vector 12 7 16
3
ghci> Vector 3 5 8 `vplus` Vector 9 2 8 `vplus` Vector 0 2 3
4
Vector 12 9 19
5
ghci> Vector 3 9 7 `vectMult` 10
6
Vector 30 90 70
7
ghci> Vector 4 9 5 `scalarMult` Vector 9.0 2.0 4.0
8
74.0
9
ghci> Vector 2 9 3 `vectMult` (Vector 4 9 5 `scalarMult` Vector 9 2 4)
10
Vector 148 666 222
Copied!

Derived instances

在 [types-and-type-classes.html#Typeclasses入門 Typeclass 101] 那一節裡面,我們瞭解了 Typeclass 的基礎內容。裡面提到,型別類就是定義了某些行為的介面。例如,Int 型別是 Eq 型別類的一個 instance,Eq 類就定義了判定相等性的行為。Int 值可以判斷相等性,所以 Int 就是 Eq 型別類的成員。它的真正威力體現在作為 Eq 介面的函數中,即 ==/=。只要一個型別是 Eq 型別類的成員,我們就可以使用 == 函數來處理這一型別。這便是為何 4==4"foo"/="bar" 這樣的表達式都需要作型別檢查。
我們也曾提到,人們很容易把型別類與 Java,Python,C++ 等語言的類混淆。很多人對此都倍感不解,在原先那些語言中,類就像是藍圖,我們可以根據它來創造對象、保存狀態並執行操作。而型別類更像是介面,我們不是靠它構造數據,而是給既有的數據型別描述行為。什麼東西若可以判定相等性,我們就可以讓它成為 Eq 型別類的 instance。什麼東西若可以比較大小,那就可以讓它成為 Ord 型別類的 instance。
在下一節,我們將看一下如何手工實現型別類中定義函數來構造 instance。現在呢,我們先瞭解下 Haskell 是如何自動生成這幾個型別類的 instance,Eq, Ord, Enum, Bounded, Show, Read。只要我們在構造型別時在後面加個 deriving(派生)關鍵字,Haskell 就可以自動地給我們的型別加上這些行為。
看這個數據型別:
1
data Person = Person { firstName :: String
2
, lastName :: String
3
, age :: Int
4
}
Copied!
這描述了一個人。我們先假定世界上沒有重名重姓又同齡的人存在,好,假如有兩個 record,有沒有可能是描述同一個人呢?當然可能,我麼可以判定姓名年齡的相等性,來判斷它倆是否相等。這一來,讓這個型別成為 Eq 的成員就很靠譜了。直接 derive 這個 instance:
1
data Person = Person { firstName :: String
2
, lastName :: String
3
, age :: Int
4
} deriving (Eq)
Copied!
在一個型別 derive 為 Eq 的 instance 後,就可以直接使用 ==/= 來判斷它們的相等性了。Haskell 會先看下這兩個值的值構造子是否一致(這裡只是單值構造子),再用 == 來檢查其中的所有數據(必須都是 Eq 的成員)是否一致。在這裡只有 String 和 Int,所以是沒有問題的。測試下我們的 Eqinstance:
1
ghci> let mikeD = Person {firstName = "Michael", lastName = "Diamond", age = 43}
2
ghci> let adRock = Person {firstName = "Adam", lastName = "Horovitz", age = 41}
3
ghci> let mca = Person {firstName = "Adam", lastName = "Yauch", age = 44}
4
ghci> mca == adRock
5
False
6
ghci> mikeD == adRock
7
False
8
ghci> mikeD == mikeD
9
True
10
ghci> mikeD == Person {firstName = "Michael", lastName = "Diamond", age = 43}
11
True
Copied!
自然,Person 如今已經成為了 Eq 的成員,我們就可以將其應用於所有在型別聲明中用到 Eq 類約束的函數了,如 elem
1
ghci> let beastieBoys = [mca, adRock, mikeD]
2
ghci> mikeD `elem` beastieBoys
3
True
Copied!
ShowRead 型別類處理可與字元串相互轉換的東西。同 Eq 相似,如果一個型別的構造子含有參數,那所有參數的型別必須都得屬於 ShowRead 才能讓該型別成為其 instance。就讓我們的 Person 也成為 ReadShow 的一員吧。
1
data Person = Person { firstName :: String
2
, lastName :: String
3
, age :: Int
4
} deriving (Eq, Show, Read)
Copied!
然後就可以輸出一個 Person 到控制台了。
1
ghci> let mikeD = Person {firstName = "Michael", lastName = "Diamond", age = 43}
2
ghci> mikeD
3
Person {firstName = "Michael", lastName = "Diamond", age = 43}
4
ghci> "mikeD is: " ++ show mikeD
5
"mikeD is: Person {firstName = \"Michael\", lastName = \"Diamond\", age = 43}"
Copied!
如果我們還沒讓 Person 型別作為 Show 的成員就嘗試輸出它,Haskell 就會向我們抱怨,說它不知道該怎麼把它表示成一個字元串。不過現在既然已經 derive 成為了 Show 的一個 instance,它就知道了。
Read 几乎就是與 Show 相對的型別類,show 是將一個值轉換成字元串,而 read 則是將一個字元串轉成某型別的值。還記得,使用 read 函數時我們必須得用型別註釋註明想要的型別,否則 Haskell 就不會知道如何轉換。
1
ghci> read "Person {firstName =\"Michael\", lastName =\"Diamond\", age = 43}" :: Person
2
Person {firstName = "Michael", lastName = "Diamond", age = 43}
Copied!
如果我們 read 的結果會在後面用到參與計算,Haskell 就可以推導出是一個 Person 的行為,不加註釋也是可以的。
1
ghci> read "Person {firstName =\"Michael\", lastName =\"Diamond\", age = 43}" == mikeD
2
True
Copied!
也可以 read 帶參數的型別,但必須填滿所有的參數。因此 read "Just 't'" :: Maybe a 是不可以的,read "Just 't'" :: Maybe Char 才對。
很容易想象 Ord 型別類 derive instance 的行為。首先,判斷兩個值構造子是否一致,如果是,再判斷它們的參數,前提是它們的參數都得是 Ord 的 instance。Bool 型別可以有兩種值,FalseTrue。為了瞭解在比較中程序的行為,我們可以這樣想象:
1
data Bool = False | True deriving (Ord)
Copied!
由於值構造子 False 安排在 True 的前面,我們可以認為 TrueFalse 大。
1
ghci> True `compare` False
2
GT
3
ghci> True > False
4
True
5
ghci> True < False
6
False
Copied!
Maybe a 數據型別中,值構造子 NothingJust 值構造子前面,所以一個 Nothing 總要比 Just something 的值小。即便這個 something-100000000 也是如此。
1
ghci> Nothing < Just 100
2
True
3
ghci> Nothing > Just (-49999)
4
False
5
ghci> Just 3 `compare` Just 2
6
GT
7
ghci> Just 100 > Just 50
8
True
Copied!
不過類似 Just (*3) > Just (*2) 之類的程式碼是不可以的。因為 (*3)(*2) 都是函數,而函數不是 Ord 類的成員。
作枚舉,使用數字型別就能輕易做到。不過使用 EnumBounded 型別類會更好,看下這個型別:
1
data Day = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday
Copied!
所有的值構造子都是 nullary 的(也就是沒有參數),每個東西都有前置子和後繼子,我們可以讓它成為 Enum 型別類的成員。同樣,每個東西都有可能的最小值和最大值,我們也可以讓它成為 Bounded 型別類的成員。在這裡,我們就同時將它搞成其它可 derive型別類的 instance。再看看我們能拿它做啥:
1
data Day = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday
2
deriving (Eq, Ord, Show, Read, Bounded, Enum)
Copied!
由於它是 ShowRead 型別類的成員,我們可以將這個型別的值與字元串相互轉換。
1
ghci> Wednesday
2
Wednesday
3
ghci> show Wednesday
4
"Wednesday"
5
ghci> read "Saturday" :: Day
6
Saturday
Copied!
由於它是 EqOrd 的成員,因此我們可以拿 Day 作比較。
1
ghci> Saturday == Sunday
2
False
3
ghci> Saturday == Saturday
4
True
5
ghci> Saturday > Friday
6
True
7
ghci> Monday `compare` Wednesday
8
LT
Copied!
它也是 Bounded 的成員,因此有最早和最晚的一天。
1
ghci> minBound :: Day
2
Monday
3
ghci> maxBound :: Day
4
Sunday
Copied!
它也是 Enum 的 instance,可以得到前一天和後一天,並且可以對此使用 List 的區間。
1
ghci> succ Monday
2
Tuesday
3
ghci> pred Saturday
4
Friday
5
ghci> [Thursday .. Sunday]
6
[Thursday,Friday,Saturday,Sunday]
7
ghci> [minBound .. maxBound] :: [Day]
8
[Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday]
Copied!
那是相當的棒。

Type synonyms

在前面我們提到在寫型別名的時候,[Char]String 等價,可以互換。這就是由型別別名實現的。型別別名實際上什麼也沒做,只是給型別提供了不同的名字,讓我們的程式碼更容易理解。這就是 [Char] 的別名 String 的由來。
1
type String = [Char]
Copied!
我們已經介紹過了 type 關鍵字,這個關鍵字有一定誤導性,它並不是用來創造新類(這是 data 關鍵字做的事情),而是給一個既有型別提供一個別名。
如果我們隨便搞個函數 toUpperString 或其他什麼名字,將一個字元串變成大寫,可以用這樣的型別聲明 toUpperString :: [Char] -> [Char], 也可以這樣 toUpperString :: String -> String,二者在本質上是完全相同的。後者要更易讀些。
在前面 Data.Map 那部分,我們用了一個關聯 List 來表示 phoneBook,之後才改成的 Map。我們已經發現了,一個關聯 List 就是一組鍵值對組成的 List。再看下我們 phoneBook 的樣子:
1
phoneBook :: [(String,String)]
2
phoneBook =
3
[("betty","555-2938")
4
,("bonnie","452-2928")
5
,("patsy","493-2928")
6
,("lucille","205-2928")
7
,("wendy","939-8282")
8
,("penny","853-2492")
9
]
Copied!
可以看出,phoneBook 的型別就是 [(String,String)],這表示一個關聯 List 僅是 String 到 String 的映射關係。我們就弄個型別別名,好讓它型別聲明中能夠表達更多資訊。
1
type PhoneBook = [(String,String)]
Copied!
現在我們 phoneBook 的型別聲明就可以是 phoneBook :: PhoneBook 了。再給字元串加上別名:
1
type PhoneNumber = String
2
type Name = String
3
type PhoneBook = [(Name,PhoneNumber)]
Copied!
Haskell 程序員給 String 加別名是為了讓函數中字元串的表達方式及用途更加明確。
好的,我們實現了一個函數,它可以取一名字和號碼檢查它是否存在於電話本。現在可以給它加一個相當好看明了的型別聲明:
1
inPhoneBook :: Name -> PhoneNumber -> PhoneBook -> Bool
2
inPhoneBook name pnumber pbook = (name,pnumber) `elem` pbook
Copied!
如果不用型別別名,我們函數的型別聲明就只能是 String -> String -> [(String ,String)] -> Bool 了。在這裡使用型別別名是為了讓型別聲明更加易讀,但你也不必拘泥于它。引入型別別名的動機既非單純表示我們函數中的既有型別,也不是為了替換掉那些重複率高的長名字型別(如 [(String,String)]),而是為了讓型別對事物的描述更加明確。
型別別名也是可以有參數的,如果你想搞個型別來表示關聯 List,但依然要它保持通用,好讓它可以使用任意型別作 keyvalue,我們可以這樣:
1
type AssocList k v = [(k,v)]
Copied!
好的,現在一個從關聯 List 中按鍵索值的函數型別可以定義為 (Eq k) => k -> AssocList k v -> Maybe v. AssocList iAssocList 是個取兩個型別做參數生成一個具體型別的型別構造子,如 Assoc Int String 等等。
1
*Fronzie 說*:Hey!當我提到具體型別,那我就是說它是完全呼叫的,就像 ``Map Int String``。要不就是多態函數中的 ``[a]`` 或 ``(Ord a) => Maybe a`` 之類。有時我和孩子們會說 "Maybe 型別",但我們的意思並不是按字面來,傻瓜都知道 ``Maybe`` 是型別構造子嘛。只要用一個明確的型別呼叫 ``Maybe``,如 ``Maybe String`` 可得一個具體型別。你知道,只有具體型別才可以儲存值。
Copied!
我們可以用不全呼叫來得到新的函數,同樣也可以使用不全呼叫得到新的型別構造子。同函數一樣,用不全的型別參數呼叫型別構造子就可以得到一個不全呼叫的型別構造子,如果我們要一個表示從整數到某東西間映射關係的型別,我們可以這樣:
1
type IntMap v = Map Int v
Copied!
也可以這樣:
1
type IntMap = Map Int
Copied!
無論怎樣,IntMap 的型別構造子都是取一個參數,而它就是這整數指向的型別。
Oh yeah,如果要你去實現它,很可能會用個 qualified import 來導入 Data.Map。這時,型別構造子前面必須得加上模組名。所以應該寫個 type IntMap = Map.Map Int
你得保證真正弄明白了型別構造子和值構造子的區別。我們有了個叫 IntMap 或者 AssocList 的別名並不意味着我們可以執行類似 AssocList [(1,2),(4,5),(7,9)] 的程式碼,而是可以用不同的名字來表示原先的 List,就像 [(1,2),(4,5),(7,9)] :: AssocList Int Int 讓它裡面的型別都是 Int。而像處理普通的 Tuple 構成的那種 List 處理它也是可以的。型別別名(型別依然不變),只可以在 Haskell 的型別部分中使用,像定義新型別或型別聲明或型別註釋中跟在::後面的部分。
另一個很酷的二參型別就是 Either a b 了,它大約是這樣定義的:
1
data Either a b = Left a | Right b deriving (Eq, Ord, Read, Show)
Copied!
它有兩個值構造子。如果用了 Left,那它內容的型別就是 a;用了 Right,那它內容的型別就是 b。我們可以用它來將可能是兩種型別的值封裝起來,從裡面取值時就同時提供 LeftRight 的模式匹配。
1
ghci> Right 20
2
Right 20
3
ghci> Left "w00t"
4
Left "w00t"
5
ghci> :t Right 'a'
6
Right 'a' :: Either a Char
7
ghci> :t Left True
8
Left True :: Either Bool b
Copied!
到現在為止,Maybe 是最常見的表示可能失敗的計算的型別了。但有時 Maybe 也並不是十分的好用,因為 Nothing 中包含的信息還是太少。要是我們不關心函數失敗的原因,它還是不錯的。就像 Data.Maplookup 只有在搜尋的項不在 Map 時才會失敗,對此我們一清二楚。但我們若想知道函數失敗的原因,那還得使用 Either a b,用 a 來表示可能的錯誤的型別,用 b 來表示一個成功運算的型別。從現在開始,錯誤一律用 Left 值構造子,而結果一律用 Right
一個例子:有個學校提供了不少壁櫥,好給學生們地方放他們的 Gun'N'Rose 海報。每個壁櫥都有個密碼,哪個學生想用個壁櫥,就告訴管理員壁櫥的號碼,管理員就會告訴他壁櫥的密碼。但如果這個壁櫥已經讓別人用了,管理員就不能告訴他密碼了,得換一個壁櫥。我們就用 Data.Map 的一個 Map 來表示這些壁櫥,把一個號碼映射到一個表示壁櫥占用情況及密碼的 Tuple 裡。
1
import qualified Data.Map as Map
2
3
data LockerState = Taken | Free deriving (Show, Eq)
4
5
type Code = String
6
7
type LockerMap = Map.Map Int (LockerState, Code)
Copied!
很簡單,我們引入了一個新的型別來表示壁櫥的占用情況。併為壁櫥密碼及按號碼找壁櫥的 Map 分別設置了一個別名。好,現在我們實現這個按號碼找壁櫥的函數,就用 Either String Code 型別表示我們的結果,因為 lookup 可能會以兩種原因失敗。櫥子已經讓別人用了或者壓根就沒有這個櫥子。如果 lookup 失敗,就用字元串表明失敗的原因。
1
lockerLookup :: Int -> LockerMap -> Either String Code
2
lockerLookup lockerNumber map =
3
case Map.lookup lockerNumber map of
4
Nothing -> Left $ "Locker number " ++ show lockerNumber ++ " doesn't exist!"
5
Just (state, code) -> if state /= Taken
6
then Right code
7
else Left $ "Locker " ++ show lockerNumber ++ " is already taken!"
Copied!
我們在這裡個 Map 中執行一次普通的 lookup,如果得到一個 Nothing,就返回一個 Left String 的值,告訴他壓根就沒這個號碼的櫥子。如果找到了,就再檢查下,看這櫥子是不是已經讓別人用了,如果是,就返回個 Left String 說它已經讓別人用了。否則就返回個 Right Code 的值,通過它來告訴學生壁櫥的密碼。它實際上就是個 Right String,我們引入了個型別別名讓它這型別聲明更好看。
如下是個 Map 的例子:
1
lockers :: LockerMap
2
lockers = Map.fromList
3
[(100,(Taken,"ZD39I"))
4
,(101,(Free,"JAH3I"))
5
,(103,(Free,"IQSA9"))
6
,(105,(Free,"QOTSA"))
7
,(109,(Taken,"893JJ"))
8
,(110,(Taken,"99292"))
9
]
Copied!
現在從裡面 lookup 某個櫥子號..
1
ghci> lockerLookup 101 lockers
2
Right "JAH3I"
3
ghci> lockerLookup 100 lockers
4
Left "Locker 100 is already taken!"
5
ghci> lockerLookup 102 lockers
6
Left "Locker number 102 doesn't exist!"
7
ghci> lockerLookup 110 lockers
8
Left "Locker 110 is already taken!"
9
ghci> lockerLookup 105 lockers
10
Right "QOTSA"
Copied!
我們完全可以用 Maybe a 來表示它的結果,但這樣一來我們就對得不到密碼的原因不得而知了。而在這裡,我們的新型別可以告訴我們失敗的原因。

Recursive data structures (遞迴地定義資料結構)

如我們先前看到的,一個 algebraic data type 的構造子可以有好幾個 field,其中每個 field 都必須有具體的型態。有了那個概念,我們能定義一個型態,其中他的構造子的 field 的型態是他自己。這樣我們可以遞迴地定義下去,某個型態的值便可能包含同樣型態的值,進一步下去他還可以再包含同樣型態的值。
考慮一下 List: [5]。他其實是 5:[] 的語法糖。在 : 的左邊是一個普通值,而在右邊是一串 List。只是在這個案例中是空的 List。再考慮 [4,5]。他可以看作 4:(5:[])。看看第一個 :,我們看到他也有一個元素在左邊,一串 List 5:[] 在右邊。同樣的道理 3:(4:(5:6:[])) 也是這樣。
我們可以說一個 List 的定義是要碼是空的 List 或是一個元素,後面用 : 接了另一串 List。
我們用 algebraic data type 來實作我們自己的 List!
1
data List a = Empty | Cons a (List a) deriving (Show, Read, Eq, Ord)
Copied!
這讀起來好像我們前一段提及的定義。他要碼是空的 List,或是一個元素跟一串 List 的結合。如果你被搞混了,看看用 record syntax 定義的可能比較清楚。
1
data List a = Empty | Cons { listHead :: a, listTail :: List a} deriving (Show, Read, Eq, Ord)
Copied!
你可能也對這邊的 Cons 構造子不太清楚。cons 其實就是指 :。對 List 而言,: 其實是一個構造子,他接受一個值跟另一串 List 來構造一個 List。現在我們可以使用我們新定義的 List 型態。換句話說,他有兩個 field,其中一個 field 具有型態 a,另一個有型態 [a]