Haskell中的類型與類型系統編程語言分類編程語言Domain

Specific

Language

(特定領域語言)General

Purpose

programming

language

(通用編程語言)

SQL,

HTML

命令式語言

C/C++,

Java,

Python,

C#

混合范式型語言Scala,

OCaml,

F#

函數型語言

Haskell,

Coq,

Agda,

Lisp,

Clojure,

ML什么是Haskell？一個強類型的、純的、惰性的函數式編程語言第一個編譯器的版本于1990年4月發布每年有相當多的博士在改進它，進化速度非常快see

什么是Haskell？每個值都有嚴格的類型，不能任意轉型，也沒有隱式轉型。對于純函數只要輸入確定結果必然確定，與計算機當前的狀態無關。Haskell可以嚴格求值，7.10前需要我們

手動控制，但7.12中會有-XStrict擴展演示用SMT

Solver解百雞問題公雞每只5元，母雞每只3元，小雞3只1元，用100元錢買100只雞，求公雞、母雞、小雞各有多少只。函數反應式編程模擬小球下落函數/運算符（位置、結合性、

優先級）值

Haskell中的主要概念

Kind（多態kind、實體kind、data

kind）類型(多態類型、類型類限定類型、實體類型)類型類Haskell中的值‘1’,

True函數not

::

Bool

->

Boolid

::

a

->

ashow

::

Show

a

=>

a

->

String運算符只是有優先級的函數，它們可以相互轉化(+)

1

2與1

+

2相同mod

19

7與19

`mod`

7相同Haskell中的類型基本類型：Int,

Integer,

Char,

type

String

=

[Char]基于基本類型的函數ord

::

Char

->

Intchr

::

Int

->

Char多態類型：[a],

Maybe

a,

(a,b)多態類型函數：id

::

a

->

a,const

::

a

->

b

->

alength

::

[a]

->

Intsize

::

Tree

a

->

Intfst

::

(a,b)

->

a所以的值都有精確的類型，

‘1’

::

Char,

True

::

Bool

代數類型枚舉類型data

Bool

=

False

|

True

deriving

(Eq,

Show,

Ord,

Enum,

Bounded,

Read)參數化類型類似于Java中的泛型data

Maybe

a

=

Nothing

|

Just

a

deriving

(Eq,

Show,

Ord,

Read)

--

解決了Tony

Hoare的十億美元的null問題!遞歸類型data

Nat

=

Zero

|

Succ

Nat

deriving

(Eq,

Show,

Ord,

Read)構造類型data

Pair

a

b

=

Pair

a

b--

類型構造器與數據構造器名字一樣data

Person

=

Person

{name

::

String,

age::

Int}data

List

a

=

Nil

|

Cons

a

(List

a)--

data

[]

a

=

[]

|

a

:

[a]deriving

(Eq,

Show,

Ord,

Read)基于這些類型的函數每個模式實際上是匹配的構造器與參數。not

::

Bool

->

Boolnot

False

=

Truenot

True

=

FalsefromJust

::

Maybe

a

->

afromJust

(Just

x)

=

xfromJust

Nothing

=

error

“cannot

get

value

from

nothing”error的類型是什么？

基于這些類型的函數每個模式實際上是匹配的構造器與參數。not

::

Bool

->

Boolnot

False

=

Truenot

True

=

FalsefromJust

::

Maybe

a

->

afromJust

(Just

x)

=

xfromJust

Nothing

=

error

“cannot

get

value

from

nothing”error的類型是什么？error

::

String

->

a基于這些類型的函數add

::

Nat

->

Nat

->

Natadd

Zero

n

=

nadd

(Succ

n)

m

=

add

n

(Succ

m)foo

::

Person

->

Stringfoo

(Person

n

s)

=

n

++

if

s

>

18then

“

is

an

adult”else

“

is

a

child”sum

::

[Int]

->

Intsum

[]

=

0sum

(x:xs)

=

x

+

sum

xs

類型類相當于多種類型的公共屬性

(==)

::

Eq

a

=>

a

->

a

->

Bool類型類間的有依賴關系

class

Eq

a

=>

Ord

a

(>=),(>),(<=),(<)

::

Ord

a

=>

a

->

a

->

Boolshow

::

Show

a

=>

a

->

String函數的重載(+)

::

Num

a

=>

a

->

a

->

a

Int,

Integer,

Double,

Float都可相加Show,

Eq,

Ord,

Enum,

Read,

Bounded定義類型類class

Eq

a

where(==)

::

a

->

a

->

Bool(/=)

::

a

->

a

->

Bool(==)

x

y

=

not

(x

/=

y)(/=)

x

y

=

not

(x

==

y){-#

MINIMAL

(==)

|

(/=)

#-}class

Show

a

where

show

::

a

->

Stringdata

Person

=

Person

Name

Intinstance

Eq

Person

where(Person

n1

i1)

==

(Person

n2

i2)

=

n1

==

n2

&&

i1

==

i2instance

Show

Person

whereshow

(Person

name

age)

=

name

++

show

ageFunctor函子類型類中的fmap函數data

List

a

=

Nil

|

Cons

a

(List

a)class

List<T>{T

e

=

null;List<T>

list

=

null;}data

Tree

a

=

Leaf

|

Node

a

(Tree

a)

(Tree

a)list

::

List

Intlist

=

Cons

10

(Cons

11

(Cons

6

(Cons

1

Nil)))tree

::

Tree

Inttree

=

Node

10

(Node

11

Leaf

Leaf)

(Node

6

(Node

1

Leaf

Leaf)Leaf)Functor函子類型類中的fmap函數class

Functor

f

wherefmap

::

(a

->

b)

->

f

a

->

f

binstance

Functor

List

wherefmap

f

Nil

=

Nilfmap

f

(Cons

a

l)

=

Cons

(f

a)

(fmap

f

l)instance

Functor

Tree

wherefmap

f

Leaf

=

Leaffmap

f

(Node

v

l

r)

=

Node

(f

v)

(fmap

f

l)

(fmapf

r)可以使用DeriveFunctor編譯器擴展自動生成數學對于Functor的指導意義F(g)

?

F(f)

=

F(g

?

f)fmap

g

.

fmap

f

=

fmap

(g.f)fmap

g

(fmap

f

v)

=

fmap

(g.f)

v{-#

RULE

“fmap”forall

g

f

v

fmap

g

(fmap

f

v)

=

fmap

(g.f)

v

#-}fmap

(+10)

(fmap

(*2)

[1..10])

=

fmap

((+10).(*2))

[1..10]int[]

arrfor(int

i

=

0

;

i

<

arr.length;

i++){arr[i]

=

arr[i]

*

2;}for(int

i

=

0

;

i

<

arr.length;

i++){arr[i]

=

arr[i]

+

10;}類型類與Java的接口的不同1、接口在Haskell相當于是一個字典，函數調用會根據不同的類型來傳遞。多幾個類型類限定相當于是多傳入了幾個字典。Java中要把接口合并起來有些啰嗦。2、由于Haskell的類型是代數數據類型，即全部可以用單位元、類型加法、類型乘法、類型復合來定義，所以類型類實例可以自動實現能力極強，而且方法特別多——通用編程、摒棄模板化編程、元編程。3、還有很多其他不同。演示：處理JSON數據的aeson庫、漂亮打印的generic-pretty庫，類型的序列化。interface

Show<T>{

String

show

(T

a);}interface

Eq<T>{

boolean

eq(T

a);}interface

ShowEq<T>

extends

Eq<T>,

Show<T>{}class

Person

implements

Eq<Person>,

Show<Person>{

String

name

;

int

age;

Person(String

name,

int

age){

=

name;

this.age

=

age;}

public

boolean

eq(Person

a)

{

return

.equals()

&&

this.age

==

a.age;}

public

String

show()

{return

+

“

”

+

this.age;}}foo

::

(Show

a,

Eq

a)

=>

a

->

a

->

(Bool,

String)類型系統與Java的不同1、Java中沒有“高階泛型”

高階Kindclass

Mk<T,K>{T<K>

m

;

}new

Mk<Vector,

Integer>()new

Mk<ArrayList,

Node>()2、沒有“多態泛型”

Kind多態

類型的Kind類型的類型為kind，類型把值分類，class給類型賦予了屬性，kind把類型分類。*代表一個實體的kind如：3

::

Int

,

Int

::

*Just

3

::

Maybe

Int,Maybe

::

*

->

*,

Maybe

Int

::

*

--

只有kind為*的類型下面才有值

--

沒有一個值的類型是Maybe，只有Maybe

Int或Maybe

Char等Either

::

*

->

*

->

*

--

同理也沒有一個值的類型是Either(,)

::

*

->

*

->

*--

元組類型的構造器--

RNodea

([]

(RoseTree

a))>:kind

[]*

->

*data

BinTree

a

=

BLeaf

a

|

BNode

a

(Pair

(BinTree

a))--

(a,a)data

Pair

a

=

MkPair

a

a>:kind

Pair*

->

*

高階Kinddata

RoseTree

a

=

RLeaf

a

|

RNode

a

[RoseTree

a]高階Kinddata

Tree

k

a

=

Leaf

a

|

Node

a

(k

(Tree

k

a))type

RoseTree

a

=

Tree

[]

atype

BinTree

a

=

Tree

Pair

atype

AnnTree

a

=

Tree

AnnPair

adata

Pair

a

=

MkPair

a

adata

AnnPair

a

=

AnnPair

String

a

a>:kind

Tree(*

->

*)

->

*

->

*Kind多態Typeableclass

Typeable