个人博客https://www.yotroy.cool/，欢迎关注我哦～

============================================================

类型

特性

强（strong）类型

静态（static）

可以通过自动推导（automatically inferred）得出

基本类型

Char
Bool
Int 常用 定长（fixed-width）整数 一般32/64位宽
Integer 不常用 不定长
Double 常用 浮点数
Float 不常用 计算慢

Prelude> :type 'a'
'a' :: CharPrelude> 'a'            -- 自动推导
'a'::符号
Prelude> 'a' :: Char    -- 显式签名
'a'

调用函数

Prelude> odd 3
TruePrelude> compare 2 3
LT
e.g. LT EQ GTPrelude> (compare 2 3) == LT
TruePrelude> 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]
1Prelude> head []
*** Exception: Prelude.head: empty listPrelude> 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')
1Prelude> 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.hsmyDrop :: 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]

个人博客https://www.yotroy.cool/，欢迎关注我哦～

============================================================

多态

参数多态

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]