Haskell 体系

Haskell 体系

编程范式

命令式编程: 修改存储值状态转换(图灵机)

函数式编程: 函数作用于参数函数调用(\(\lambda\) 演算)

结构

Package 集合

Hackage, Stackage, GHC自带, Haskell Platform

• Package 分发依赖
  • Library 功能
    • Module 代码组织
      • Declaration 声明
        • Expression 表达式

模块

导入模块

import Data.List 
import Data.List (f, g) 
import Data.List hiding (f, g)
import qualified Data.List 
import qualified Data.List as L

模块导出

name = "变量 值构造子 | 类型构造子 类型类 | 模块"

module MyModule
( name,			--	仅 name
  name(x, y),	--	name 及 x y
  name(..),		-- 	name 及所有
) where

声明

• 模块/导入声明
• 类型声明
• 绑定声明

表达式

变量

函数

lambda

值构造子

if case let do

range

list comprehension

绑定

名称与表达式永久关联

\(名称 \xleftarrow{绑定} 表达式\)

名称

值命名空间

• 变量名
• 值构造子名

类型命名空间

• 类型变量名
• 类型构造子名
• 类型类名

模块命名空间

• 模块名

关键字

import module foreign default
class instance deriving
data newtype type
if then else case of let in do
infix infixl infixr where

绑定

• 普通绑定

  • 顶层绑定 =

  • 局部绑定 let where

• Case 绑定

  • 模式匹配
  • case 表达式

• Monad 绑定

  • >>=
  • <-

模式匹配

输入值与值构造子匹配成功后, 解构输入值, 绑定到模式变量

占位符 _: 匹配成功后, 不解构输入值的该部分, 也不绑定

类型系统

\(值 \xleftarrow{集合} 类型 \xleftarrow{集合} kind\)

值集合

类型是值的集合, 值构造子是值集合的划分

data Bool = False | True

值构造子无限划分

data Nat = Zero | Succ Nat

ambiguous type 是值集合的交集

read "1"

ADT 类型定义

类型是值的集合, 类型名即集合名

$T_{t_1,t_2,\dots} = C_1 (t_1,t_2,\dots) \ |\ C_2 (t_1,t_2,\dots) \ |\ \dots $

类型 T 定义在类型 t1 t2 ... 的基础上, 构造函数将类型 t1 t2 ... 的值包装为类型 T 的值

data

新数据类型

data TypeName typevars = Constructor1 typevars | Constructor2 typevars | ... deriving (TypeClass)

• 类型构造子类型参数都为 TypeClass 的 instance

newtype

单参数单值构造子

newtype TypeName typevars = Constructor { getType :: typevars } deriving (TypeClass)

• 编译时直接去掉包装
• 模式匹配时直接确定值构造子

type

类型别名

类型变量

代表一类类型中的某个类型

-- 类型变量 a :: *
id :: a -> a

-- 类型变量 a,b :: *
-- 高阶类型变量 f :: * -> *
fmap :: Functor f => (a -> b) -> f a -> f b	

多态类型

有类型变量的类型

多态

参数多态	特设多态
类型变量	类型类
类型行为相同	类型行为不同

类型构造子

高阶类型, 类型构造函数, 附加 context

Maybe :: * -> *
Maybe Int :: *

Either :: * -> * -> *
Either String :: * -> *
Either String Int :: *

柯里化: 部分应用返回新类型构造子

类型类

支持某些重载函数的类型的集合, 分类依据: 重载函数和 laws

分类依据: 重载函数和 laws

class C c where
	f :: 	-- 定义重载函数
instance C T where
	f = 	-- 实现重载函数

deriving

类型归类为类型类, 自动实现重载函数

类型类约束

定义集合包含关系

-- 父集 Functor 子集 Applicative
class Functor f => Applicative f where

-- 类型 a 属于集合 Num
Num a => a

重载类型

有类型类约束的类型

(+) :: Num a => a -> a -> a
3 :: Num a => a

Kind

\(值 \xleftarrow{集合} 类型 \xleftarrow{集合} kind\)

类型构造子集合, 分类依据: 类型构造子参数数量

* = {Int, Bool, [Int], Maybe Int, ...}
* -> * = {[], Maybe, IO, ...}
* -> * -> * = {Either, (->), ...}
.
.
.

\(~\)

语法总结

-- 	注释
{-
	注释
-}

-- 六大名称
name = "变量 值构造子 | 类型变量 类型构造子 类型类 | 模块"


-- 模块导出导入声明
module MyModule
( name,
  name(x, y),
  name(..),	
  OtherModule
) where

import Name					
import Name (x, y) 			
import Name hiding (x, y)	
import qualified Name as N


-- 类型声明
data List a = [] | a : List a deriving Show

newtype Pair b a = Pair { getPair :: (a,b) }

type String = [Char]


-- 类型类声明
class C c where
	f :: 	-- 定义重载函数
instance C T where
	f = 	-- 实现重载函数
	
	
-- 函数声明
f ::
f pattern =
	where bind
f pattern =
...
	
f exp
	| predicate = 
    | predicate =
    | ...
    | otherwise = 
    
\pattern pattern ... -> expr


-- 函数调用
(f) exp exp ...
exp `f` exp

-- 表达式
if expr
then expr
else expr

case expr of
	pattern -> expr
	pattern -> expr
	...

let bind in expr

do
	var <- m a
	var <- m a
	...
	m a

[a..b]
[a,b..c]

[expr | var <- m a, var <- m a, ... , predicate, predicate, ...]