Bool、Int、Char、Maybe 等等，不过在 Haskell 中该如何构造自己的型别呢？好问题，一种方法是使用 data 关键字。首先我们来看看 Bool 在标准函式库中的定义：= 的左端标明型别的名称即 Bool，= 的右端就是_值构造子_ (Value Constructor)，它们明确了该型别可能的值。| 读作"或"，所以可以这样阅读该声明：Bool 型别的值可以是 True 或 False。型别名和值构造子的首字母必大写。Int 型别的声明：Int 型别的最小值和最大值，注意到真正的型别宣告不是长这个样子的，这样写只是为了便于理解。我们用省略号表示中间省略的一大段数字。(43.1,55.0,10.4)，前两项表示圆心的位置，末项表示半径。听着不错，不过三维矢量或其它什么东西也可能是这种形式！更好的方法就是自己构造一个表示图形的型别。假定图形可以是圆 (Circle) 或长方形 (Rectangle)：Circle 的值构造子有三个项，都是 Float。可见我们在定义值构造子时，可以在后面跟几个型别表示它包含值的型别。在这里，前两项表示圆心的坐标，尾项表示半径。Rectangle 的值构造子取四个 Float 项，前两项表示其左上角的坐标，后两项表示右下角的坐标。Shape 值并返回一个 Float 值。写 Circle -> Float 是不可以的，因为 Circle 并非型别，真正的型别应该是 Shape。这与不能写True->False 的道理是一样的。再就是，我们使用的模式匹配针对的都是值构造子。之前我们匹配过 []、False 或 5，它们都是不包含参数的值构造子。Circle 10 20 到控制台，就会得到一个错误。这是因为 Haskell 还不知道该型别的字符串表示方法。想想，当我们往控制台输出值的时候，Haskell 会先调用 show 函数得到这个值的字符串表示才会输出。因此要让我们的 Shape 型别成为 Show 型别类的成员。可以这样修改：data 声明的后面加上 deriving (Show)，那 Haskell 就会自动将该型别至于 Show 型别类之中。好了，由于值构造子是个函数，因此我们可以拿它交给 map，拿它不全调用，以及普通函数能做的一切。Shape 更加容易理解：Point 的定义，它的型别与值构造子用了相同的名字。没啥特殊含义，实际上，在一个型别含有唯一值构造子时这种重名是很常见的。好的，如今我们的 Circle 含有两个项，一个是 Point 型别，一个是 Float 型别，好作区分。Rectangle 也是同样，我们得修改 surface 函数以适应型别定义的变动。Circle 的模式中，我们无视了整个 Point。而在 Rectangle 的模式中，我们用了一个嵌套的模式来取得 Point 中的项。若出于某原因而需要整个 Point，那么直接匹配就是了。Shape 和表示位移的两个数，返回一个位于新位置的图形。Shape 的点加上位移的量。Point，我们可以搞个辅助函数 (auxilliary function)，初始从原点创建图形，再移动它们。Shape (..)，我们就导出了 Shape 的所有值构造子。这一来无论谁导入我们的模块，都可以用 Rectangle 和 Circle 值构造子来构造 Shape 了。这与写 Shape(Rectangle,Circle) 等价。Shape 的值构造子，这一来使用我们模块的人就只能用辅助函数 baseCircle 和 baseRect 来得到 Shape 了。Data.Map 就是这一套，没有 Map.Map [(1,2),(3,4)]，因为它没有导出任何一个值构造子。但你可以用，像 Map.fromList 这样的辅助函数得到 map。应该记住，值构造子只是函数而已，如果不导出它们，就拒绝了使用我们模块的人调用它们。但可以使用其他返回该型别的函数，来取得这一型别的值。{}。先写出项的名字，如 firstName，后跟两个冒号(也叫 Paamayim Nekudotayim，哈哈~(译者不知道什么意思~囧))，标明其型别，返回的数据型别仍与以前相同。这样的好处就是，可以用函数从中直接按项取值。通过 Record Syntax，Haskell 就自动生成了这些函数：firstName, lastName, age, height, phoneNumber 和 flavor。Show 型别类，它的显示是不同的。假如我们有个型别表示一辆车，要包含生产商、型号以及出场年份：Vector = Vector Int Int Int 就足够明白了。但一个值构造子中若含有很多个项且不易区分，如一个人或者一辆车啥的，就应该使用 Record Syntax。Car 的构造子是取三个参数返回一个 Car。与之相似，型别构造子可以取型别作参数，产生新的型别。这咋一听貌似有点深奥，不过实际上并不复杂。如果你对 C++ 的模板有了解，就会看到很多相似的地方。我们看一个熟悉的型别，好对型别参数有个大致印象：Maybe 就成为了一个型别构造子。在它的值不是 Nothing 时，它的型别构造子可以搞出 Maybe Int，Maybe String 等等诸多态别。但只一个 Maybe 是不行的，因为它不是型别，而是型别构造子。要成为真正的型别，必须得把它需要的型别参数全部填满。Char 作参数交给 Maybe，就可以得到一个 Maybe Char 的型别。如，Just 'a' 的型别就是 Maybe Char 。[Int]，[Char] 也可以是 [String]，但不会跟在 [] 的后面。Maybe！: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型别从Car String String Int 型别的函数，像以前，我们还可以弄个简单函数来描述车的属性。Car a b c 又会怎样？(Show a) => Car String String a 的型别约束。看得出来，这要繁复得多。而唯一的好处貌似就是，我们可以使用 Show 型别类的 instance 来作 a 的型别。Car String String Int 在大多数情况下已经满够了。所以给 Car 型别加型别参数貌似并没有什么必要。通常我们都是都是在一个型别中包含的型别并不影响它的行为时才引入型别参数。一组什么东西组成的 List 就是一个 List，它不关心里面东西的型别是啥，然而总是工作良好。若取一组数字的和，我们可以在后面的函数体中明确是一组数字的 List。Maybe 与之相似，它表示可以有什么东西可以没有，而不必关心这东西是啥。Data.Map 中的 Map k v。 k 表示 Map 中键的型别，v 表示值的型别。这是个好例子，Map 中型别参数的使用允许我们能够用一个型别索引另一个型别，只要键的型别在 Ord 型别类就行。如果叫我们自己定义一个 Map 型别，可以在 data 声明中加上一个型别类的约束。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 声明中加型别约束 --- 即便看起来没问题。免得在函数声明中写出过多无谓的型别约束。vplus 用来相加两个矢量，即将其所有对应的项相加。scalarMult 用来求两个矢量的标量积，vectMult 求一个矢量和一个标量的积。这些函数可以处理 Vector Int，Vector Integer，Vector Float 等等型别，只要 Vector a 里的这个 a 在 Num 型别类中就行。同样，如果你看下这些函数的型别声明就会发现，它们只能处理相同型别的矢量，其中包含的数字型别必须与另一个矢量一致。注意，我们并没有在 data 声明中添加 Num 的类约束。反正无论怎么着都是给函数加约束。Vector t t t -> Vector t t t -> t 作函数的型别就会产生一个错误，因为在型别声明中只能写型别，而 Vector 的型别构造子只有个参数，它的值构造子才是有三个。我们就慢慢耍：Eq 型别类的一个 instance，Eq 类就定义了判定相等性的行为。Int 值可以判断相等性，所以 Int 就是 Eq 型别类的成员。它的真正威力体现在作为 Eq 接口的函数中，即 == 和 /=。只要一个型别是 Eq 型别类的成员，我们就可以使用 == 函数来处理这一型别。这便是为何 4==4 和 "foo"/="bar" 这样的表达式都需要作型别检查。Eq 型别类的 instance。什么东西若可以比较大小，那就可以让它成为 Ord 型别类的 instance。Eq, Ord, Enum, Bounded, Show, Read。只要我们在构造型别时在后面加个 deriving(派生)关键字，Haskell 就可以自动地给我们的型别加上这些行为。Eq 的成员就很靠谱了。直接 derive 这个 instance：Eq 的 instance 后，就可以直接使用 == 或 /= 来判断它们的相等性了。Haskell 会先看下这两个值的值构造子是否一致(这里只是单值构造子)，再用 == 来检查其中的所有数据(必须都是 Eq 的成员)是否一致。在这里只有 String 和 Int，所以是没有问题的。测试下我们的 Eqinstance：Person 如今已经成为了 Eq 的成员，我们就可以将其应用于所有在型别声明中用到 Eq 类约束的函数了，如 elem。Show 和 Read 型别类处理可与字符串相互转换的东西。同 Eq 相似，如果一个型别的构造子含有参数，那所有参数的型别必须都得属于 Show 或 Read 才能让该型别成为其 instance。就让我们的 Person 也成为 Read 和 Show 的一员吧。Person 到控制台了。Person 型别作为 Show 的成员就尝试输出它，Haskell 就会向我们抱怨，说它不知道该怎么把它表示成一个字符串。不过现在既然已经 derive 成为了 Show 的一个 instance，它就知道了。Read 几乎就是与 Show 相对的型别类，show 是将一个值转换成字符串，而 read 则是将一个字符串转成某型别的值。还记得，使用 read 函数时我们必须得用型别注释注明想要的型别，否则 Haskell 就不会知道如何转换。read 的结果会在后面用到参与计算，Haskell 就可以推导出是一个 Person 的行为，不加注释也是可以的。read 带参数的型别，但必须填满所有的参数。因此 read "Just 't'" :: Maybe a 是不可以的，read "Just 't'" :: Maybe Char 才对。Ord 型别类 derive instance 的行为。首先，判断两个值构造子是否一致，如果是，再判断它们的参数，前提是它们的参数都得是 Ord 的 instance。Bool 型别可以有两种值，False 和 True。为了了解在比较中进程的行为，我们可以这样想象：False 安排在 True 的前面，我们可以认为 True 比 False 大。Maybe a 数据型别中，值构造子 Nothing 在 Just 值构造子前面，所以一个 Nothing 总要比 Just something 的值小。即便这个 something 是 -100000000 也是如此。Just (*3) > Just (*2) 之类的代码是不可以的。因为 (*3) 和 (*2) 都是函数，而函数不是 Ord 类的成员。Enum 和 Bounded 型别类会更好，看下这个型别：nullary 的(也就是没有参数)，每个东西都有前置子和后继子，我们可以让它成为 Enum 型别类的成员。同样，每个东西都有可能的最小值和最大值，我们也可以让它成为 Bounded 型别类的成员。在这里，我们就同时将它搞成其它可 derive型别类的 instance。再看看我们能拿它做啥：Show 和 Read 型别类的成员，我们可以将这个型别的值与字符串相互转换。Eq 与 Ord 的成员，因此我们可以拿 Day 作比较。Bounded 的成员，因此有最早和最晚的一天。Enum 的 instance，可以得到前一天和后一天，并且可以对此使用 List 的区间。[Char] 和 String 等价，可以互换。这就是由型别别名实现的。型别别名实际上什么也没做，只是给型别提供了不同的名字，让我们的代码更容易理解。这就是 [Char] 的别名 String 的由来。type 关键字，这个关键字有一定误导性，它并不是用来创造新类（这是 data 关键字做的事情），而是给一个既有型别提供一个别名。toUpperString 或其他什么名字，将一个字符串变成大写，可以用这样的型别声明 toUpperString :: [Char] -> [Char]， 也可以这样 toUpperString :: String -> String，二者在本质上是完全相同的。后者要更易读些。Data.Map 那部分，我们用了一个关联 List 来表示 phoneBook，之后才改成的 Map。我们已经发现了，一个关联 List 就是一组键值对组成的 List。再看下我们 phoneBook 的样子：phoneBook 的型别就是 [(String,String)]，这表示一个关联 List 仅是 String 到 String 的映射关系。我们就弄个型别别名，好让它型别声明中能够表达更多信息。phoneBook 的型别声明就可以是 phoneBook :: PhoneBook 了。再给字符串加上别名：String -> String -> [(String ,String)] -> Bool 了。在这里使用型别别名是为了让型别声明更加易读，但你也不必拘泥于它。引入型别别名的动机既非单纯表示我们函数中的既有型别，也不是为了替换掉那些重复率高的长名字体别(如 [(String,String)])，而是为了让型别对事物的描述更加明确。key 和 value，我们可以这样：(Eq k) => k -> AssocList k v -> Maybe。AssocList 是个取两个型别做参数生成一个具体型别的型别构造子，如 Assoc Int String 等等。IntMap 的型别构造子都是取一个参数，而它就是这整数指向的型别。qualified import 来导入 Data.Map。这时，型别构造子前面必须得加上模块名。所以应该写个 type IntMap = Map.Map IntIntMap 或者 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 了，它大约是这样定义的：Left，那它内容的型别就是 a；用了 Right，那它内容的型别就是 b。我们可以用它来将可能是两种型别的值封装起来，从里面取值时就同时提供 Left 和 Right 的模式匹配。Maybe 是最常见的表示可能失败的计算的型别了。但有时 Maybe 也并不是十分的好用，因为 Nothing 中包含的信息还是太少。要是我们不关心函数失败的原因，它还是不错的。就像 Data.Map 的 lookup 只有在搜索的项不在 Map 时才会失败，对此我们一清二楚。但我们若想知道函数失败的原因，那还得使用 Either a b，用 a 来表示可能的错误的型别，用 b 来表示一个成功运算的型别。从现在开始，错误一律用 Left 值构造子，而结果一律用 Right。Data.Map 的一个 Map 来表示这些壁橱，把一个号码映射到一个表示壁橱占用情况及密码的 Tuple 里。Either String Code 型别表示我们的结果，因为 lookup 可能会以两种原因失败。橱子已经让别人用了或者压根就没有这个橱子。如果 lookup 失败，就用字符串表明失败的原因。lookup，如果得到一个 Nothing，就返回一个 Left String 的值，告诉他压根就没这个号码的橱子。如果找到了，就再检查下，看这橱子是不是已经让别人用了，如果是，就返回个 Left String 说它已经让别人用了。否则就返回个 Right Code 的值，通过它来告诉学生壁橱的密码。它实际上就是个 Right String，我们引入了个型别别名让它这型别声明更好看。lookup 某个橱子号..Maybe a 来表示它的结果，但这样一来我们就对得不到密码的原因不得而知了。而在这里，我们的新型别可以告诉我们失败的原因。[5]。他其实是 5:[] 的语法糖。在 : 的左边是一个普通值，而在右边是一串 List。只是在这个案例中是空的 List。再考虑 [4,5]。他可以看作 4:(5:[])。看看第一个 :，我们看到他也有一个元素在左边，一串 List 5:[] 在右边。同样的道理 3:(4:(5:6:[])) 也是这样。: 接了另一串 List。Cons 构造子不太清楚。cons 其实就是指 :。对 List 而言，: 其实是一个构造子，他接受一个值跟另一串 List 来构造一个 List。现在我们可以使用我们新定义的 List 型态。换句话说，他有两个 field，其中一个 field 具有型态 a，另一个有型态 [a]。Cons 构造子，这样你可以很清楚地看到他就是 :。Empty 代表 []，而 4 `Cons` (5 `Cons` Empty) 就是 4:(5:[])。* 的 fixity 是 infixl 7 *，而 + 的 fixity 是 infixl 6。代表他们都是 left-associative。(4 * 3 * 2) 等于 ((4 * 3) * 2)。但 * 拥有比 + 更高的优先级。所以 5 * 4 + 3 会是 (5 * 4) + 3。a :-: (List a) 而不是 Cons a (List a)：deriving Show 的时候，他会仍视构造子为前缀函数，因此必须要用括号括起来。++ 在操作普通 List 的时候是这样的：.++：