类型
特性
强（strong）类型
静态（static）
可以通过自动推导（automatically inferred）得出
基本类型
Char
Bool
Int 常用 定长（fixed-width）整数 一般32/64位宽
Integer 不常用 不定长
Double 常用 浮点数
Float 不常用 计算慢
Prelude> :type 'a'
'a' :: Char
Prelude> 'a' -- 自动推导
'a'
::符号
Prelude> 'a' :: Char -- 显式签名
'a'
调用函数
Prelude> odd 3
True
Prelude> compare 2 3
LT
e.g. LT EQ GT
Prelude> (compare 2 3) == LT
True
Prelude> compare (sqrt 3) (sqrt 6) -- 此处括号不可去
LT
复合数据类型：列表和元组
不同？
列表可以任意长，且只能包含类型相同的值。
元组的长度是固定的，但可以包含不同类型的值。
可递归性
[[Int]] 是一个包含 [Int] 类型值的列表，而 [Int] 又是一个包含 Int 类型值的列表即用 Int 类型替换了类型变量 a 。
列表[]及 head, tail, last ; take, drop
head 取第一个元素， tail 取除第一个外所有
last 取最后一个元素
Prelude> head [1, 2, 3, 4]
1
Prelude> head []
*** Exception: Prelude.head: empty list
Prelude> tail "list"
"ist"
ghci> last [1,2,3]
3
Prelude> take 2 [1, 2, 3, 4, 5]
[1,2]
Prelude> drop 2 [1, 2, 3, 4, 5]
[3,4,5]
Prelude> drop 4 [1, 2]
[]
Prelude> drop (-1) "foo" --第一个参数小于或等于 0时， drop 函数返回整个输入列表
"foo"
元组 () 及 fst, snd
大小至少为2
元组的类型由它所包含元素的数量、位置和类型决定
Prelude> :type (True, "hello")
(True, "hello") :: (Bool, [Char])
Prelude> (4, ['a', 'm'], (16, True))
(4,"am",(16,True))
Prelude> :t ()
() :: ()
Prelude> fst (1, 'a')
1
Prelude> snd (1, 'a')
'a'
元组使用场景e.g.
-
如果一个函数需要返回多个值，那么可以将这些值都包装到一个元组中，然后返回元组作为函数的值。
-
当需要使用定长容器，但又没有必要使用自定义类型的时候，就可以使用元组来对值进行包装。
利用括号将表达式传给函数
a b c d 等于 (((a b) c) d)
纯度
带副作用的函数称为 不纯（impure）函数 ，而将不带副作用的函数称为 纯（pure）函数。
副作用即函数中全局变量可修改如取决于某一时刻的值，本质上是函数的一种不可见的（invisible）输入或输出。Haskell 的函数在默认情况下都是无副作用的：函数的结果只取决于显式传入的参数。
不纯函数的类型签名都以 IO 开头，以下为检测e.g.：
Prelude> :type readFile
readFile :: FilePath -> IO String
-- 不纯函数的类型签名都以 IO 开头
加载.hs文件
ghci中通过:load
变量
一旦变量绑定了（也即是，关联起）某个表达式，那么这个变量的值就不会改变。如.hs文件中就不行，但ghci命令行里可以。
e.g. [Assign.hs]
条件求值
不同分支之间的类型必须相同。
e.g.:
[myDrop.hs]
-- file: ch02/myDrop.hs
myDrop :: Int -> [a] -> [a]
myDrop n xs = if n <= 0 || null xs -- ## null用法
then xs -- 缩进不可省略
else myDrop (n - 1) (tail xs) -- 缩进不可省略
-- 代换（substitution）和重写（rewriting）
-- 代换了变量n和xs
-- 重写了myDrop函数
-- ## 惰性求值
-- 也可写成一行 e.g.[myDropX.hs](ch02/myDrop.hs)
-- ## 条件求值
-- null xs not equals to xs == null
-- then 和 else 之后的表达式称为“分支”，
-- 不同分支之间的类型必须相同。
-- 而if不是分支。
-- e.g.
-- Prelude> if True then 1 else "foo"
-- <interactive>:2:14:
-- No instance for (Num [Char])
-- arising from the literal `1'
-- Possible fix: add an instance declaration for (Num [Char])
-- In the expression: 1
-- In the expression: if True then 1 else "foo"
-- In an equation for `it': it = if True then 1 else "foo"
->
可精简到一行 [myDropX.hs]
-- file: ch02/myDropX.hs
myDropX n xs = if n <= 0 || null xs then xs else myDropX (n - 1) (tail xs)
惰性求值
e.g. [isOdd.hs]
-- file: ch02/isOdd.hs
isOdd n = mod n 2 == 1
-- ghci> isOdd (1+2)
-- True
--in general:XXXXXX
-- first: (1+2)
-- second: mod 3 2
-- third: 1 == 1
-- True
--but in haskell:
--(1+2) 最后算！当真正有需要的时候再计算出 isOdd (1 + 2) 的值
--追踪未求值表达式的记录被称为块（chunk）
递归
注意惰性求值，递归 -> 终止递归 -> 递归返回
解释
e.g. [myDrop.hs]
多态
参数多态
Prelude> :type last
last :: [a] -> a
ghci> last [1,2,3]
3
如果将一个类型为 [Char] 的列表传给 last ，那么编译器就会用 Char 代换 last 函数类型签名中的所有 a ，从而得出一个类型为 [Char] -> Char 的 last 函数。诸如此类可以是Int，可以是任何类型。这种类型的多态被称为参数多态。
参数多态没有办法知道输入参数的实际类型
缺少
Haskell没有子类多态和强制多态（coercion polymorphism）。
多参数函数的类型
e.g.
Prelude> :type take
take :: Int -> [a] -> [a]