Theory of Programming Languages 程序设计语言理论 -...

Theory of Programming Languages

程序设计语言理论程序设计语言理论

张昱

S h l f C t S i d T h l School of Computer Science and Technology University of Science and Technology of China

October, 2009

Yu Zhang, USTC

第3章简单类型化演算第3章简单类型化演算

[FPL Ch2, Ch4]简要介绍PCF语言的组成部分之二：带函数和积类型的纯类型化演算.型的纯类型化演算.

介绍简单类型化演算(函数、积以及和类型)的用定型公理和推理规则来描述的上下文有关语法用定型公理和推理规则来描述的上下文有关语法

归约系统(操作语义)和归约策略

Yu Zhang, USTC

PCF: Programming Computable Functions,可计算函数程序设计语言

3.1 引言

演算演算20世纪30年代由Church提出，用于定义可计算函数.1936，Kleene：无类型演算定义的所有自然数函数正好是所有的递归函数.

1937，Turing：可定义的数值函数正好是Turing机可计算的函数.

类型化演算让类型结构对应到程序设计语言中的类型，可以对类让类型结构对应到程序设计语言中的类型，可以对类型化程序设计语言的能力和限制建模.

像多类别代数那样，可以用类型常量(对应到类别)和

Yu Zhang, USTCYu Zhang, USTC

像多类别代数那样，可以用类型常量(对应到类别)和项常量(对应到函数符号)的集合来定义.

程序设计语言理论-简单类型化lambda演算 3

3.2 类型和项

3.2.1 类型的语法

3.2.2 上下文有关的语法

3.2.3 项的语法

3.2.4 带积、和及其他类型的项

3.2.5 定型算法

Yu Zhang, USTCYu Zhang, USTC 程序设计语言理论-简单类型化lambda演算 4

3.2.1 类型的语法

简单类型化演算简单类型化演算是将类型表达式限制到不含任何类型变量的类型化演算.类型表达式的文法 ::= b | null | unit | | | b：类型常量 null：初始类型 unit：终结类型：和类型：积类型：函数类型

是自右向左结合，和的优先级高于是自右向左结合，和的优先级高于.

不同演算的命名：带函数类型的演算：带函数类型的演算, ：带积类型以及函数类型的演算+,, ：带和类型、积类型以及函数类型的演算


+,, ：带和类型、积类型以及函数类型的演算


3.2.2 上下文有关的语法-1

上下文无关文法上下文无关文法常用来描述程序设计语言的语法.满足这种文法的程序或表达式称为是良形的满足这种文法的程序或表达式称为是良形的.只能描述静态类型化语言语法规定的一部分.

例如，只有指明是数值类型，良形表达式才是良类型的例如，只有指明x是数值类型，良形表达式x+3才是良类型的.

不存在上下文无关文法，它正好产生良类型的项.

用一种基于逻辑的形式系统来定义类型语言定型公理c : ——符号c有类型.推理规则 1 1: , , :

:k kM M

N


3.2.2 上下文有关的语法-2

上下文有关的语法上下文有关的语法定型断言 M : ，其中类型指派(也称定型上下文 ) ={x : x : }其中类型指派(也称定型上下文 ) ={x1:1, … , xk:k}.

定型公理c : ——符号c有类型.定型规则：是增加了定型上下文的推理规则定型规则：是增加了定型上下文的推理规则.

1 1 1: , , :k k kM MN

, x: = {x: }, x不出现在中.

:N

给程序的构成方式强加约束的定型公理和定型规则集称为相应语言的类型系统，也称为该语言的静态语义


相应语言的类型系统，也称为该语言的静态语义.

3.2.3 项的语法-1

一个基调 B C 个基调 B, C一个集合B，其基本元素叫做基本类型或类型常量.形式为 c, 的序对集合C ，其中是B上的类型表达式且不会出现 c 在两个不同的序对中.如果 c, C，则c 称为类型的项常量，通常写成c : .

多类代数的基调 S, F可看成基调 B, C , , 令S 为B.若F有f : s s s，则在C中包含项常量若F有f : s1 … sk s，则在C中包含项常量

f : s1 … sk s注意：在中单独的f不是一个项(常量符号除外)，但是在


注意：在中单独的f不是一个项(常量符号除外)，但是在中， f是一个项. 程序设计语言理论-简单类型化lambda演算 8

3.2.3 项的语法-2

例3 1例3.1 代数基调基调sorts :

nat, booltype constants :

nat, boolfctns :

0, 1, 2, … : natf l b l

term constants :0, 1, 2, … : nat

f l b ltrue, false : boolplus : nat nat natEq ?: nat nat bool

true, false : boolplus : nat nat natEq ?: nat nat boolEq ?: nat nat bool

condn: bool nat nat natcond :bool bool bool bool

Eq ?: nat nat boolcond : bool (对每个类型即nat bool


condb:bool bool bool bool (对每个类型，即nat、bool以及由它们构造的函数类型)


3.2.3 项的语法-3

项的语法可以采用如下方式描述项的语法可以采用如下方式描述

用BNF定义类型表达式的语法b | ll | i | | | ::= b | null | unit | | |

e ::= 0 | 1 | 2 |…| true | false | plus e e | Eq ? e e | cond e e用定型公理和定型规则同时定义上的项和它们的用定型公理和定型规则同时定义上的项和它们的类型

定型公理

对每个类型为的常量c，有定型公理 c : (cst)对变量的类型，有定型公理 x : x : (var)


3.2.3 项的语法-4

定型规则（说明复合表达式和它们的类型）定型规则（说明复合表达式和它们的类型）

(add var):, : :

Mx M

抽象及其类型 (Intro)

,

, : :( : ) :x Mx M

(Intro)是函数类型的引入规则，因为它引入一个函数类型的项.

( : . ) :x M

应用及其类型 (Elim): , ::

M NMN

(Elim)是函数类型的消去规则，因为出现在前提中，但在结果中被消去，它表示在函数类型的表达式上可以进行的操作.

每个类型的定型规则一般均由引入规则和消去规则组成


每个类型的定型规则一般均由引入规则和消去规则组成.程序设计语言理论-简单类型化lambda演算 11

3.2.3 项的语法-5

定型断言的证明叫做定型推导定型断言的证明叫做定型推导.例3.2 证明从定型公理，根据规则，得到

: ( : . ) :y x x y

从定型公理，根据(Intro)规则，得到

再由规则，可得

: :x x : . :x x

再由(add var)规则，可得最后由(Elim)规则，可知

: : . :y x x

: ( : . ) :y x x y


3.2.3 项的语法-6

类型化表达式的代换的精确定义类型化表达式的代换的精确定义

[N/x]x = N

，对的变量和常量[N/x] = ，对 x的变量和常量

[N/x](P Q ) = ([N/x]P ) ([N/x]Q )

[N/x]x : . M = x : . M

[N/x]y : M = y : [N/x]M，只要x y并且yFV(N)[N/x]y : . M = y : .[N/x]M，只要x y并且yFV(N)

[N/x]y : . M = (z : .[N/x][z/y]M)，其中zFV(M N)并且y, z x

加上加法和条件算符等后，代换可拓广


例如，[N / x](P + Q ) = ([N / x]P ) + ([N / x]Q )

3.2.3 项的语法-7

引理3 1 如果M : ，那么M中的每个自由变量都出现引理3.1 如果M : ，那么M中的每个自由变量都出现在中.

引理3 2 如果M : ，并且∩'包含M中的所有自由引理3.2 如果M : ，并且∩'包含M中的所有自由变量，则' M : .

引理3 3 如果M ，并且不出现在中，那么引理3.3 如果M : ，并且y不出现在中，那么[y/x] [y/x]M : .

引理3 4 如果 M 和 N 都是项，且引理3.4 如果1, x: M : 和2 N : 都是项，且1 2是良形的类型指派，那么代换实例

[N/ ]M1 2 [N/x]M : 是良形项.

证明基于对定型断言 M 的证明的归纳Yu Zhang, USTCYu Zhang, USTC

证明基于对定型断言1, x: M : 的证明的归纳.程序设计语言理论-简单类型化lambda演算 14

3.2.4 带积、和及其他类型的项-1

积类型（把扩展到, ）积类型（把扩展到, ）如果M和N分别是类型为和类型为的项，则序对〈M N〉的类型为 × 。〈M, N〉的类型为 ×。

可以对序对进行投影操作Proj1 : Proj2 :

等式公理

Proj1M, N = M 和 Proj2M, N = N (proj) (Proj1P), (Proj2P) = P (满射配对，sp )公理(sp)对显式序对是多余的，因为

(Proj1M, N), (Proj2M, N ) = M, (Proj2M, N ) = M, N


但是，如果变量x: ，没有公理(sp)公理就不可能证明 (Proj1x), (Proj2x) = x . 程序设计语言理论-简单类型化lambda演算 15


积类型的定型规则积类型的定型规则

引入规则 (×Intro): , :

:

M N

M N

它引入积类型的项.

消去规则 (×Eli )

, :M N

:M 消去规则 (×Elim)1

×

,1

:Proj :M

M

:M (×Elim)2

× 和 × 分别用来获得 × 的第一和第二成员

,2

:Proj :M

M

(×Elim)1和(×Elim)2分别用来获得M: ×的第一和第二成员.和的上角标常被忽略.,2Proj

,1Proj



积的另一种表示积的另一种表示

对所有的类型和，存在项常量Pair, : ( )Pair, : ( )Proj1, : ( ) Proj , : ( ) Proj2 , : ( )

M, N, 看成Pair, M N的语法美化，上角标常被忽略两种表示的主要区别两种表示的主要区别

第二种表示：Pair、Proj1和Proj2都是项第一种表示：x:.y:.Pair x y、x: .Proj1x和x:.Proj2x才是良形项.



和类型和类型

如果M和N分别是类型为和类型为的项，则左标记项I l ft M和右标记项I i ht 的类型为＋。项Inleft, M和右标记项Inright, 的类型为＋。

可以引入分情况算子case，来区分标记项是来自和类型左边的分支还是右边的分支型左边的分支还是右边的分支

Case, , M N P :，其中M:＋，N: ，P: 等式公理

Case, , (Inleft , x)f g = f x (case)1 Case, , (Inright , x)f g = g x (case)2外延公理


Case, , x (f ◦ Inleft , )(f ◦ Inright ,) = f x (case)3f :＋＋



和类型的定型规则和类型的定型规则

引入规则 (＋Intro)1,

:Inleft :

MM

(＋Intro)2

Inleft :M

,

:Inright :

MM

它引入和类型的项.

消去规则

g

消去规则

＋

: , : , :M N P

(＋Elim)(＋Elim)用来刻画case表达式如何正确使用类型.

, ,Case :MNP



和的另一种表示和的另一种表示

对所有的类型、和，存在项常量Inleft, : ＋Inleft, : ＋Inright, : ＋Case, , : (＋) ( ) ) Case , , : (＋) ( ) )

初始类型和终结类型

初始类型null，即空和类型，它没有任何闭项(引入形式)项常量 Zero : null (null Elim) 空和类型的值表示从0个可选项中选择1个，故没有引入形式 Zero是null的消去形式， Zero M表示中止对M的求值


Zero是空函数，当把函数表示成序对的集合时， Zero是空集.程序设计语言理论-简单类型化lambda演算 20


初始类型和终结类型初始类型和终结类型

终结类型unit，即空积类型，它只有1个项，用*表示项常量 *: unit (unit Intro) *是unit的引入形式，表示空元组；unit没有消去形式许多程序设计语言中的void类型其实就是unit类型

bool类型bool unit＋unit引入形式 true Inleft * false Inright *引入形式 true Inleft false Inright 消去形式

if M h N l P C it it M (K N) (K P)


if M then N else P Caseunit, unit, M (K unit N) (K unit P)其中N ,P:， K unit x:.y : unit. x



多元函数和高阶函数之间的关系多元函数和高阶函数之间的关系

举例 comp f : natnat.g : natnat.x : nat. f (gx)

comp: (natnat) (natnat )nat natadd p : nat nat (Proj p) + (Proj p)add p : nat nat.(Proj1 p) + (Proj2 p)

add: nat nat natadd ho x : nat. y : nat. x + yadd_ho x : nat. y : nat. x + y

add_ho: nat nat nattwicef f : natnat . n : nat. f (f n) twicef add f f f (f )

twicef: (nat nat) nat nat twicef add_ho 2

twicef (add ho 2):nat natadd_ho 2 : nat nat


twicef (add_ho 2):nat nattwicef (add_ho 2) 3:nat,结果为7


add p : nat nat.(Proj1 p) + (Proj2 p)add p : nat nat.(Proj1 p) + (Proj2 p) add_ho x : nat. y : nat. x + y

Curry算子将多元函数变换成高阶函数Curry算子将多元函数变换成高阶函数Curry f : nat nat nat.x : nat.y : nat.f x, y

Uncurry算子将高阶函数变换成多元函数Uncurry算子将高阶函数变换成多元函数Uncurry f :nat nat nat.x :nat nat. f (Proj1x) (Proj2x)

Curry(add) (f :natnat nat.x : nat.y : nat.f x, y) add= x:nat. y : nat.add x, y x:nat.y:nat.(p:natnat.(Proj1 p)+(Proj2 p))

x, y= x : nat y : nat Proj x y + Proj x y


= x : nat. y : nat. Proj1x, y + Proj2 x, y= x : nat. y : nat.x + y


3.2.5 定型算法-1

几个算法问题几个算法问题

给定, M ,，M : 是否为可证明的定型断言.给定, M，判定是否存在一个，使得M : 是可证明的。

基调上的基本表达式(pre-term)M ::= c | x | M M | x: .M 上下文无关的语法M :: c | x | M M | x: .M 上下文无关的语法

类型检查算法

输：给定类型指派和预备项输入：给定类型指派和预备项M输出：返回表明M : 可推导；或者停机表示失败


3.2.5 定型算法-2

TC ( c) =TC (, c) =如果 c: 是该基调的一个常量否则 fail否则 fail

TC (, x) =如果 x: 如果 x: 否则 fail

TC ( M N) =TC (, M N) 如果 TC (, M) = 并且 TC (, N) = 否则 fail否则 fail

TC (, x:.M) = 如果 TC (( M , x:), M) =


如果 TC ((x:.M , x:), M) 否则 fail

3.2.5 定型算法-3

命题3 5 令是一个基调，是使用类型的一个指派，命题3.5 令是一个基调，是使用类型的一个指派，并且M是上的一个预备项.那么，算法TC (, M) 终止且得到类型，当且仅当定型断言 M : 可终止且得到类型，当且仅当定型断言 M : 可推导. 如果对于和M ，不存在可推导的定型断言，那么算如果对于和，不存在可推导的定型断言，那么算法停机，报告失败.

证明对预备项的结构进行归纳来证明.证明对预备项的结构进行归纳来证明.


3.3 证明系统-等式和理论-1

等式等式

代数规范中的等式：M ＝N []类型化项之间的等式： M＝N :

{x1:1, …, xk:k} M＝N : 指变量x1:1, …, xk:k在对应类型上任意取值，表达式和都指称类型的同一应类型上任意取值，表达式M和N都指称类型的同一个元素.等式的另一种表示方式： x1:1 … xk:k. M＝N : 若某个类型为空，则该等式可以无意义地成立.(因为

列在类型指派中的变量都加有全称量词)



类型化演算的等式证明系统类型化演算的等式证明系统(与代数规范类似)

公理 M = M : (ref)推理规则

(sym)::

M NN M

(trans): , :

:

M N N P

M P

(add var):

, : :M N

x M N


,


推理规则(函数抽象和函数应用都是保相等性的)推理规则(函数抽象和函数应用都是保相等性的)

( ), : :: . : . :x M N

x M x N

( )1 2 1 2

1 1 2 2

: , :

:

M M N N

M N M N

( )和( )均是同余规则。代数规范中的同余规则(cong)是导出规则，而这两条不是.

1 1 2 2

的三条公理

x : M =y : [y/x]M : ，其中 y FV(M) () x :.M =y :.[y/x]M : ，其中 y FV(M) ()(x :.M )N = [N/x]M : () ，其中


x : . (Mx) = M : ，其中x FV(M ) ()程序设计语言理论-简单类型化lambda演算 29


引理3 6 如果├ M = N : 并且包含M和N中所有引理3.6 如果├ M = N : 并且包含M和N中所有的自由变量，那么├ M = N: .

基调的类型化理论(或理论)基调的类型化理论(或理论)

是项上包含上述公理的一组良类型的等式，并且封闭于上述推理规则于上述推理规则.

如果E是一个良类型等式的集合，用E ├ M = N : 表示 M N 从公理和E可证示 M = N : 从公理和E可证.

E的理论(Th(E))：从公理和E 可证的等式集合.



代数和简单类型化演算之间的联系代数和简单类型化演算之间的联系在类型化上可以增加代数公理，任何代数等式可以看成等式成等式.

任何一个代数证明都可以在中执行.

代数证明规则(subst)不在中，它是的导出规则.

引理3.7 代数证明规则(subst) 是的导出规则.(subst), : : , :x M N P Q ( )

[ / ] [ / ] :P x M Q x N



命题3 8 令E是代数基调的代数项上的等式集合，令E是命题3.8 令E是代数基调的代数项上的等式集合，令E是单个这样的等式。如果在代数证明系统中E ├ E，那么，把E 和E的元素看成是基调的项上的等式，在证把E 和E的元素看成是基调的项上的等式，在证明系统中也有E ├ E.

命题3 9（守恒性）令E是代数基调的代数项上的等式集命题3.9（守恒性）令E是代数基调的代数项上的等式集合，令E是单个这样的等式。当把E 和E的元素看成是基调的项上的等式时，如果在证明系统中E ├ E，调的项上的等式时，如果在证明系统中E ├ E，那么在代数证明系统中也有E ├ E.

命题3 10 存在有类型化演算理论E及没有自由出现的项命题3.10 存在有类型化演算理论E及没有x自由出现的项M和N，使得E ├ , x:M = N : ,但是 E ├ M = N : 不成立


N : 不成立.


积类型积类型

Proj1M, N = M : (proj1)Proj2M, N = N : (proj2) Proj1M, Proj2M = M : (sp)

和类型

Case, , (Inleft , M)N P = N M : (case ) Case , , (Inleft , M)N P = N M : (case1)Case, , (Inright , M)N P = P M : (case2) C M (N I l ft )(N I i ht ) Case, , M (N ◦ Inleft , )(N ◦ Inright ,)

=N M : + (case3)仅当时，公理才是良形的


仅当 N : ( +) ( +)时，公理(case3)才是良形的.程序设计语言理论-简单类型化lambda演算 33


终结类型终结类型

M = * : unit (unit)对每个类型，存在唯一的函数，可以把对每个类型，存在唯一的函数One : unit，可以把

One写成 x : .* .

初始类型

M = Zero : null (null) ( )对每个类型，存在唯一的函数Zero : null .



简单类型化演算版本之间的联系简单类型化演算版本之间的联系逻辑系统或语言L2在L1上是守恒的如果L2包含L1，并且对L1的任意一组公式F和任意一个公式F，若在L2 的证明系统中有 F ├ F ，则在L1的证明系统中也有有 F ├的证明系统中也有有 F ├ F.

在上是守恒的.


3.3 证明系统-归约规则-1

归约规则归约规则

(x :.M )N [N/x]M ()red，其中x : . (Mx) M ，其中x FV(M ) () red

形式为(x :.M )N的项称为可归约式，形式为x :. (M x)的项称为可归约式的项称为可归约式.

引理3.11 (保持性) 如果M : 并且M N，那么N : .

如果不存在项N使得M N ，那么称M是,范式.合流性：归约在项上是合流的.强范式化：在项上不存在无穷的归约序列.


强范式化：在项上不存在无穷的归约序列归约对于预备项并不合流.如x :.(y :.y)x.


3.3 证明系统-归约规则-3

有其他规则的归约有其他规则的归约

每个代数基调都可以看成一个基调，这就允许把代数项集看成是项的一个子集，并把代数重写规则运用到项集看成是项的一个子集，并把代数重写规则运用到项.

假定是代数基调，是上的代数重写系统，是包含假定是代数基调，R是上的代数重写系统，是包含的(或 )基调

如果R是合流的并且是终止的，那么对上的项，R,归约是合流的和终止的.

如果R是合流的并且是左线性的，那么对上的项，R , , fix归约是合流的.


3.4 语法美化-1

函数声明和语法美化函数声明和语法美化

作为程序设计语言的一种模型语言，演算将抽象对应到普通程序设计语言中的变量约束到普通程序设计语言中的变量约束begin function f (x : nat) : nat;

return x;return x;end;

bodyyend函数f 可写作表达式 x : nat.x整个程序段可翻译成 ) 整个程序段可翻译成( f : nat nat. body ) x : nat.x

let x: =M in N (x :.N) M 在声明体N中，x被约束到M


上述程序段可以写成 let f : nat nat = x : nat.x in body

3.4 语法美化-2

let f(x:): =M in N let f : = x : M in N let f(x:): =M in N let f : = x :. M in N ( f : . N) (x :. M)

多元函数的语法美化 x: y: M p: (x : y : M)(Proj p)(Proj p) x:, y:.M p: .(x :. y :.M)(Proj1 p)(Proj2 p) let x:, y:=M in N ( x:, y:.N) M

M应用于N共n次M (M …(M N)…)的缩写Mn NM0 N NM0 N NMn+1 N M (MnN)


3.4 语法美化-3

例3 7：例3.7：let compose : (nat nat) (nat nat) nat nat

= f : nat nat g : nat nat x : nat f(gx)= f : nat nat.g : nat nat.x : nat.f(gx)in let h : nat nat = x : nat.x + x

in compose h h 5in compose h h 5翻译成纯PCF表达式

(compose : (nat nat) (nat nat) nat nat.(compose : (nat nat) (nat nat) nat nat.(h : nat nat. compose h h 5) x : nat.x + x)

f : nat nat.g : nat nat.x : nat.f(gx)f g f(g )(h:natnat.(f:natnat.g:natnat.x:nat.f(gx)) h h 5)

(x : nat.x + x)


(f:natnat.g:natnat.x:nat.f(gx)) (x : nat.x + x)(x : nat.x + x) 5

3.4 语法美化-4

例3 7：例3.7：(f:natnat.g:natnat.x:nat.f(gx)) (x : nat.x + x)

(x : nat.x + x) 5(x : nat.x + x) 5 (x : nat.x + x) ((x : nat.x + x) 5)((x : nat.x + x) 5) + ((x : nat.x + x) 5)(( ) ) (( ) ) (5 + 5) (5 + 5) 20


3.4 语法美化-5

记录和n元组记录和n元组记录{l1＝M1, …, lk＝Mk}，M1:1, …, Mk:k 记录类型：{l l }记录类型：{l1:1, …, lk:k}该类型的记录r中的成分li (1≤i≤k)的选择可用r.li表示

等式公理等式公理{l1＝M1, …, lk＝Mk}.li＝Mi (record selection)它可作为一个从左到右的归约规则它可作为一个从左到右的归约规则.

记录的好处

其成分无次序之分其成分无次序之分

可选择助记符作为标记：let person={name:string, age:nat,…}


3.4 语法美化-6

记录和n元组记录和n元组n元积 1 …n 1(2 …(n-1n )…)

元组 n元组M1, … , Mn M1 , M2 , … Mn-1 , Mn … 取n元组的成分

1 11 1 2Proj : .Proj (Proj )

n ii nx x

1 11 2Proj : .(Proj )

n nn nx x

记录到n元组的翻译{l1＝M1, …, lk＝Mk} M1, … , Mk

1 2n n

1 1 k k 1 k

{l1:1, …, lk:k} 1 …kM.li 1Proj ni M


M.li ji

3.4 语法美化-7

n元和以及带标签的和(变式)n元和以及带标签的和(变式)n元和 1 + … + n 1 + (2 + …(n-1 + n )…)若第个标记值 1i若M : i , 第i个标记值若M : n , 第n个标记值

1 ... 1In : .Inright (Inleft )n ii ix x

1 ... 1In : .(Inright )n nn ix x

分情况分析值标记组的成分1 ... ,

1 1 1 1Case : . : . . : .n

n n nx f f

1 2

2 3

,( ... ),1 1

,( ... ),2 2 2 2

(Case

( : .Case

n

n

n

x f

x x f

1

2 2 2 2, ,

1 1 1 1(...( : .Case )...)n n

n

n n n n n nx x f f


3.4 语法美化-8

带标签的和(变式)类型l : + +l :带标签的和(变式)类型l1:1+ …+lk:k引入形式 , M:I消去形式

1 ...1In ( ) : ...

k

il kM

1 1,..., ,1Case (In ( )) ...

k k

l k iM f f f M 消去形式

一些有用的和类型：枚举类型

例如：扑克牌的花色

1Case (In ( )) ...il k iM f f f M

例如：扑克牌的花色

类型 card unit + ( unit + ( unit + unit ) )引入形式： hearts | spades | diamonds | clubs引入形式： hearts | spades | diamonds | clubsheartsInleft * spades Inright(Inleft *)di d I i ht2(I l ft *) l b I i ht3 *diamonds Inright2(Inleft *) clubs Inright3 *消去形式：

card,1 4 1Case (hearts) ... *f f f

card, 1 4 2Case (spades) ... *f f f


1 4 1( ) f f f 1 4 2( p ) f f fcard,

1 4 3Case (diamonds) ... *f f f card, 1 4 4Case (clubs) ... *f f f

3.4 语法美化-9

一些有用的和类型：选项类型option一些有用的和类型：选项类型option

类型 option unit +引入形式：引入形式： null | just(M)

null Inleft * just(M) Inright(M), M : 消去形式：消去形式：

ifnull : option(unit ) ( ) ifnull null _:unit.e1 x:.e2 = e1ifnull just(e) _:unit.e1 x:.e2 =[e/x] e2 j _ 1 2 2

_:unit.e中的下划线表示任意不出现在e中的变量（unit类型无消去形式）


3.4 语法美化-10

理解空指针错误——option类型的意义之一理解空指针错误——option类型的意义之一起因：在OO语言中，所有对象都是引用(指针)，对象的引用可能为空，不能通过空引用来访问对象的域的引用可能为空，不能通过空引用来访问对象的域.

如何避免空指针错误?一些语言提供空指针的检测函数 ll b l一些语言提供空指针的检测函数 null : →bool

if null(e) then …error … else …ok …但是空指针异常仍然普遍原因 1)缺少空指针检测 2)但是空指针异常仍然普遍, 原因: 1)缺少空指针检测; 2)极少在程序的异常处进行空指针检测

解决：用描述类型为的可选值类型，其值或解决：用option描述类型为的可选值类型，其值或者为类型的值，或者为空.消去形式 if ll i k


消去形式 ifnulle _:unit. …error… x:. …ok…程序设计语言理论-简单类型化lambda演算 47

3.5 PCF语言(不考虑递归函数)-1 ( )

语法语法

Types ::= nat | bool | Expr’s e ::= x | 0 | 1 | … | e+e | true | false |

x:.e | e e | if e then e else e | Eq?e e

静态语义:用定型规则对程序的形成进行约束: booltrue : boolfalse : :x x

0,1, 2, ....: nat

nn

: booltrue : boolfalse , : :x x

, : :( )x e

1 2: :e e

1 2: nat : nat

t

e e

: natn

( : . ) :x e 1 2 :e e

1 2 3: bool : :e e e 1 2: nat : nate e

1 2 : nate e


1 2 3if then else :e e e 1 2? : boolEq e e


引理(定型的逆转) 假设e : 引理(定型的逆转) 假设e : 1) 如果e=x，则= ', x : ;2) 如果 ( )，则 t且 t2) 如果e=succ(e1)，则 =nat且e1 :nat ;3) 如果e=e1+ e2 ，则 =nat且e1 :nat、e2 :nat ;4) 如果e= x:.e1，则 = 1且, x :e1 :1 ;5) 如果e=e1 e2，则存在使得e1 : 且e2 : ;6) 如果e=if e1 then e2 else e3，则e1 :bool、e2 : 且

e3 : ;37) 如果e=Eq ? e1 e2，则=bool且e1 : nat、e2: nat .证明按定型规则进行归纳证明.


证明按定型规则进行归纳证明.



引理(代换) 如果 x : e : 并且e : ，那么引理(代换) 如果, x : e : 并且e1 : ，那么[e1 / x]e: . (定型断言满足代换性质.)

证明：对 x : e : 的推导进行归纳，考虑定型规则证明：对, x : e : 的推导进行归纳，考虑定型规则中的每条规则，即对e 的每一种情况，分别证明.

动态语义描述程序如何被执行动态语义：描述程序如何被执行

值规则 0,1, 2, ....valn

n

valtrue valfalse : . valx e

归约公理

f

: [ / ]x e e e x e

val

?

n

Eq n n true1 2 1 2 val val

?

n n n n

Eq n n false

1 1: . [ / ]x e e e x e ?Eq n n true

if th lt if th lf l

1 2?Eq n n false

1 2n n n


该操作语义未指定计算次序，比较抽象。程序设计语言理论-简单类型化lambda演算 50

1 2 1if then elsetrue e e e 1 2 2if then elsefalse e e e1 2n n n


引理(范式) 如果e val并且e : ，那么引理(范式) 如果e val并且e : ，那么1) 如果=nat，则e为某个自然数，即0或1或…;

如果，则为或2) 如果 =bool，则e为true或false ;3) 如果 = 1 2，则对某个x和e2，e为x: 1.e2且x: 1

e2: 2 .证明对定型规则和值规则进行归纳.

定理(保持性) 如果e : 并且e e'，那么e' : .证明对转换规则归纳证明，证明中需要使用定型的逆转

引理和代换引理.


引理和代换引理



定理(进展性) 如果e : ，则e或者是一个值，或者存在e'定理(进展性) 如果e : ，则e或者是一个值，或者存在e 使得e e'.

证明对定型规则归纳证明注意这里只考虑闭项，即定型证明对定型规则归纳证明. 注意这里只考虑闭项，即定型上下文为空.证明中需要使用范式引理和转换规则证明中需要使用范式引理和转换规则.

定理(安全性) 若程序设计语言满足保持性和进展性，则定理(安全性) 若程序设计语言满足保持性和进展性，则称该语言是安全的.


3.6 归约策略与动态语义

3.6.1 归约策略

3.6.2 结构语义及其变种

3.6.3 求值语义及其变种求值语义及其变种


3.6.1 归约策略-1

操作语义与符号解释器操作语义与符号解释器

不确定的解释器：每一步可选择任意的子表达式进行归约归约.

确定的解释器：每一步选择一个特定的”下一步归约”.并行的解释器：可以把几个归约同时作用于不相交的子表达式.

确定的归约：归约策略

归约策略：是项到项的部分函数F，它具有性质：归约策略：是项到项的部分函数，它具有性质：如果F(e)=e' ，那么e e'.

求值函数： 1 1if ( ) is not defined( )e F e


求值函数：


1 11

2 1 1 1 2

( ) ( )

if ( ) and ( ) F Feval e

e F e e eval e e

3.6.1 归约策略-2

三种归约策略三种归约策略

例，若e1 e1'且e2 e2'，则(x: .e1) e2可以归约成：最左最外归约，最左归约，惰性归约对于函 [e2/ x] e1：最左最外归约，最左归约，惰性归约. 对于函

数应用，称为按名调用

若e1中有形参x的多次出现，用e2代换x会使函数体中有多个e2 ，从而e2的归约会重复多次.

(x: . e1) e2' ：急切归约.对于函数应用，称为按值调用若e2 无范式，则(x: . e1) e2的急切归约不会终止.若e2在最终的结果中不使用，则最左归约方式因无需归约e2而终止.


(x: .e1') e2：在提供e2前试图“优化”函数x: .e1.程序设计语言理论-简单类型化lambda演算 55

3.6.1 归约策略-3

动态语义的描述方法动态语义的描述方法

小步操作语义：结构语义、上下文语义

大步操作语义：求值语义、环境语义大步操作语义：求值语义、环境语义

PCF子语言的结构语义最左归约：对项中尽可能左边的符号进行归约最左归约：对项中尽可能左边的符号进行归约

惰性归约：最左归约的优化，其中省去一些子项的归约

急切归约：值，只有函数参数是值时才能应用β归约，急切归约：值，只有函数参数是值时才能应用β归约，…


3.6.2 结构语义及其变种-1

PCF子语言的结构语义最左归约PCF子语言的结构语义-最左归约归约(转换)规则 e e'是公理left

e ee e

l fleft1 1

left1 2 1 2

e e

e e e e

left2 2

1left1 2 1 2

e ee

e e e e

是范式

left1 1

left1 2 1 2? ?

e e

Eq e e Eq e e

left2 2

1left1 2 1 2? ?

e ee

Eq e e Eq e e

是范式

left1 1

left1 2 3 1 2 3if then else if then else

e e

e e e e e e

l fleft2 2

1left1 2 3 1 2 3if then else if then else

e ee

e e e e e e

是范式

lefte e


3 31 2left

1 2 3 1 2 3

,if then else if then else

e ee e

e e e e e e

是范式


PCF子语言的结构语义最左归约PCF子语言的结构语义-最左归约归约(转换)规则

left left left1 1

left1 2 1 2

e e

e e e e

left2 2

1left1 2 1 2

e ee

e e e e

是范式

left

left: . : .e e

x e x e

( : . : . )(( : . )20)x nat y nat x y z nat z left

left

( )(( ) )

: .(( : . )20)

: .20

y nat z nat z y

y nat y



PCF子语言的结构语义惰性归约PCF子语言的结构语义-惰性归约归约(转换)规则 e e'是公理lazy

e ee e

lazy1 1

lazy1 2 1 2

e e

e e e e

lazy

lazy

val n e en e n e

lazy1 1

lazy1 2 1 2? ?

e e

Eq e e Eq e e

lazy

lazy

val ? ?n e e

Eq n e Eq n e

lazy1 1

lazy1 2 3 1 2 3if then else if then else

e e

e e e e e e

lazyl lazy1 2 2

lazy1 2 3 1 2 3

val

if then else if then else

e e e

e e e e e e

lazy val val e e e e


1 2 3 3lazy

1 2 3 1 2 3

val val

if then else if then else

e e e e

e e e e e e


PCF子语言的结构语义惰性归约PCF子语言的结构语义-惰性归约归约(转换)规则

lazy lazyl lazy1 1lazy

1 2 1 2

e e

e e e e

lazy2 2lazy

1 2 1 2

val v e e

e e e e

lazy

lazy: . : .e e

x e x e

( : . : . )(( : . )20)x nat y nat x y z nat z lazy : .(( : . )20)y nat z nat z y



PCF子语言的结构语义急切归约PCF子语言的结构语义-急切归约值规则

valtrue valfalse : . valx e

0,1, 2, ....valn

n

归约(转换)规则 e e'是公理eager

e ee e

valn1 2 1 2 val val n n n n

eager?Eq n n true1 2 1 2

eager1 2?Eq n n false

eager1 2 1if then elsetrue e e e

eager1 2 2if then elsefalse e e e

1 2eager

1 2

n n n

n n n

eager val

: . [ / ]v

x e v v x e


上述公理确定了求值的基本步骤，称为指令转换规则.程序设计语言理论-简单类型化lambda演算 61


PCF子语言的结构语义急切归约PCF子语言的结构语义-急切归约归约(转换)规则

eager1 1

eager1 2 1 2

e e

e e e e

eager

eager

val n e en e n e

eager eagerl

eager

eager1 1

eager1 2 1 2? ?

e e

Eq e e Eq e e

eager

eager

val ? ?n e e

Eq n e Eq n e

eager1 1

eager1 2 3 1 2 3if then else if then else

e e

e e e e e e

eager1 1

eager1 2 1 2

e e

e e e e

eager2 2

eager1 2 1 2: . : .

e e

x e e x e e


上述规则确定了求值的次序，称为搜索转换规则.程序设计语言理论-简单类型化lambda演算 62


PCF子语言的结构语义急切归约PCF子语言的结构语义-急切归约归约(转换)规则

eager1 1

eager1 2 1 2

e e

e e e e

eager

eager

val n e en e n e

eager eagerl

eager

eager1 1

eager1 2 1 2? ?

e e

Eq e e Eq e e

eager

eager

val ? ?n e e

Eq n e Eq n e

eager1 1

eager1 2 3 1 2 3if then else if then else

e e

e e e e e e

eager1 1

eager1 2 1 2

e e

e e e e

eager2 2

eager1 2 1 2: . : .

e e

x e e x e e


上述规则确定了求值的次序，称为搜索转换规则.程序设计语言理论-简单类型化lambda演算 63


PCF子语言的上下文语义结构语义的变种PCF子语言的上下文语义-结构语义的变种将结构语义中的指令步骤独立出来变成指令转换断言记成，该断言的推理规则定义如下：记成 e1 e2 ，该断言的推理规则定义如下：注：这里只考虑惰性归约和急切归约，规则中若包含花括号内的部分，则为急切归

约，若去掉花括号部分则是惰性归约

val

?

n

Eq n n true 1 2 1if then elsetrue e e e1 2 1 2

1 2

val val ?

n n n n

Eq n n false

1 2 2if then elsefalse e e e1 2

1 2

n n n

n n n

{ val}: . [ / ]e

x e e e x e

引入求值上下文来定位下条指令，断言C ectxt用来确定项中下条指令的位置，这个位置用“洞”(记为[ ])表示


项中下条指令的位置，这个位置用洞 (记为[ ])表示.洞可以是上述指令转换规则中的任何可归约式之一.



PCF子语言的上下文语义结构语义的变种PCF子语言的上下文语义-结构语义的变种求值上下文的推理规则

[ ] ectxt1

1 2

ectxt ectxt

CC e

2

2

val ectxt ectxt

n Cn C

1 1

1 2 3

ectxtif then else ectxt

C

C e e1 1

1 2

ectxt? ectxtC

Eq C e2

2

val ectxt? ectxt

n C

Eq n C

1

1 2

ectxt ectxt

C

C e2

1 2

ectxt: . ectxtC

x e C

上述规则与结构语义中的搜索规则是一一对应的.

1 2 1 2



PCF子语言的上下文语义结构语义的变种PCF子语言的上下文语义-结构语义的变种求值上下文是一个模板，其中的洞可以实例化为任何要执

行的指令行的指令.断言 e'=C{e}表示e'是用e填充C中的洞所得的结果.

{ }e C e val { }n e C e[ ]{ }e e

1 1

1 2 1 2

{ }

{ }

e C e

e e C e e

2 2

2 2

val { }

{ }

n e C e

n e n C e

{ }e C e val { }n e C e

1 1{ }e C e

1 1

1 2 1 2

{ }

? ? { }

e C e

Eq e e Eq C e e

2 2

2 2

val { }? ? { }n e C e

Eq n e Eq n C e

1 1

1 2 3 1 2 3

{ }

if then else if then else { }e e e C e e e

{ }e C e { }e C e


1 1

1 2 1 2

{ }

{ }

e C e

e e C e e2 2

1 2 1 2

{ }: . : . { }

e C ex e e x e C e


上下文语义与结构语义之间的关系上下文语义与结构语义之间的关系

上下文语义下的归约规则

0 0 0 0

eager/lazy

{ } { }e C e e e e C e

e e

从e到e'是的转换由以下步骤组成：1) 将e分解成求值上下文和一条指令) 将分解成求值上下文和一条指令2) 执行这条指令3) 用这条指令的执行结果取代e中的这条指令，得到e'3) 用这条指令的执行结果取代e中的这条指令，得到e .结构语义和上下文语义定义了相同的转换关系。

定理当且仅当eager/lazy eager/lazy


定理当且仅当 .程序设计语言理论-简单类型化lambda演算 67

eager/lazyCe e eager/lazy Se e

3.6.3 求值语义及其变种-1

求值语义求值语义

建立项与其值之间的关系，求值断言 e v

nn n是自然数

true true false false : . : .x e x e

1 2

1 2?

e n e n

Eq e e true

1 1 2 2 1 2

1 2

e n e n n n n

e e n

1 1 2 2 1 2

1 2?

e n e n n n

Eq e e false

1 2 2

1 2 3 2if then else

e true e v

e e e v

1 3 3

1 2 3 3if then else

e false e v

e e e v

1 2 2 2: . [ / ]e x e e v v x e v

e e v


1 2e e v


求值语义求值语义

引理如果，那么 .定理对于所有的闭项和值，当且仅当

e v valv

定理对于所有的闭项 e 和值v ，当且仅当 .(注：表示的自反传递闭包，表示一小步转换，可以是或 )

e v*e v*e v e v e v

lazy eager转换，可以是或 .)

环境语义

lazye v eagere v

小步语义和求值语义在求值时通过代换用变量的绑定来取代变量.

环境语义将变量及其绑定记录在环境E中，E是一组形如的假设，x是变量，v是值.x v



环境语义环境语义

断言E├ 表示在环境E下e 求值为v.e vn is a natual number

E,x⇓v`x⇓vEè1⇓n1 Eè2⇓n2 Eè1⇓n Eè2⇓n Eè1⇓n1 Eè2⇓n1 n1 6=n2

n is a natual numberE`n⇓n E`true⇓true E`false⇓false

⇓ ⇓Eè1+e2⇓n1+n2

⇓ ⇓EÈq ? e1 e2⇓true EÈq ? e1 e2⇓false

Eè1⇓true Eè2⇓v2Eè1⇓false Eè3⇓v3 1⇓ 2⇓ 2Eìf e1 then e2 else e3⇓v2

1⇓f 3⇓ 3Eìf e1 then e2 else e3⇓v3

Eè1⇓λx:σ.e Eè2⇓v2 E,x⇓v2è⇓v

这个环境语义不正确，因为这里将变量绑定记录到环境与

E`λx:σ.e⇓λx:σ.eEè1⇓λx:σ.e Eè2⇓v2 E,x⇓v2è⇓v

Eè1 e2⇓v


这个环境语义不正确，因为这里将变量绑定记录到环境与

求值语义中的代换语义不一致.程序设计语言理论-简单类型化lambda演算 70


为什么上述环境语义不正确？为什么上述环境语义不正确？它使用环境(记录自由变量元绑定)假设，该假设对那些返回值包含自由变元的函数的求值会不正确返回值包含自由变元的函数的求值会不正确.

例：e＝ x : nat. y : nat.x)) 3由求值语义规则， : [ / ]e x e e v v xe v 由求值语义规则，

由于

1 2 2 2

1 2

: . [ / ]e x e e v v xe v

e e v

由于x : nat. y : nat.x)) 3 y : nat.3 故e 求值为 y : nat.3

对于包含 e 的表达式e'＝ e) 4 由代换语义可得 e' 4



例：e＝ x : nat y : nat x)) 3 ， e'＝ e) 4例：e＝ x : nat. y : nat.x)) 3 ， e ＝ e) 4但是由环境语义规则， Eè1⇓λx:σ.e è2⇓v2 E,x⇓v2è⇓v

Eè1 e2⇓v

e 的值由外层抽象确定,它以 x 3为假设

由环境语义的抽象规则，有 t t

1 2⇓

由环境语义的抽象规则，有y : nat.x y : nat.xe 求值到开式y : nat.x,其中x 是自由的但是对的求值来说其环境没有对的假设这样对

但是对e' 的求值来说,其环境没有对x 的假设,这样对(y : nat.x ) 4求值就有麻烦,因为函数体有自由变量x.这就导致求值受阻因为环境中没有对的绑定

就导致求值受阻,因为环境中没有对x 的绑定.导致麻烦的原因是：出现在e内层抽象中的变量 x 作为外层抽象的值返回时，将逃逸出其作用域。


层抽象的值返回时，将逃逸出其作用域。程序设计语言理论-简单类型化lambda演算 72


求值断言中的环境假设：类似于栈的行为求值断言中的环境假设：类似于栈的行为.高阶语言中的变量：类似于堆的行为. 前者不符合后者！

如何解决在环境语义中遇到的问题?如何解决在环境语义中遇到的问题?必须保证抽象中的自由变量没有从环境中脱离绑定!将环境当作显式代换将环境当作显式代换显式代换是一个数据结构:记录变量将被代换成什么仅当遇到变量时,才将变量代换为在环境中对应的绑定

——延迟代换 [v1, …, vk / x1, …, xk ]x :.e在对抽象求值的地方，将环境附加在该抽象上，从而有: clo(E, x : .e) ——闭包

环境为抽象中的自由变量提供绑定，来“封闭”


环境E为抽象中的自由变量提供绑定，来“封闭”自由变量。程序设计语言理论-简单类型化lambda演算 73


修改后的环境语义将k个变量的求值假设保存到境中修改后的环境语义

E={x1 7→v1,...,xk 7→vk}x1⇓v1,...,xk⇓vk`λx:σ.e⇓clo(E,λx:σ.e)

设保存到环境E中

⇓ , , ⇓ ⇓ ( , )

E ` e1 ⇓ clo(E,λx : σ.e) E ` e2 ⇓ vE { → → }E = {x1 7→ v1, ..., xk 7→ vk}

x1 ⇓ v1, ..., xk ⇓ vk, x ⇓ v ` e ⇓ wE ` e1 e2 ⇓ w

从环境E中取得的假设

例：e＝ x : nat. y : nat.x)) 3 ， e'＝ e) 4⇓

` λx : nat.(λy : nat.x) ⇓ clo({ },λx : nat.(λy : nat.x))x ⇓ 3 ` λy : nat.x ⇓ clo({x 7→ 3},λy : nat.x)

` e ⇓ clo({x 7→ 3};λy : nat.x)


` e 4 ⇓ 3

习题

1 [TPL] 3 6(c) 3 8(b)1. [TPL] 3.6(c), 3.8(b)2. [TPL] 3.27(a)(b)(c), 3.28(a)

试用求值语义和两种环境语义，对twicef 3 (plus 4)求值，其中 twicef = n : nat. f : nat→nat. f ( f n)其中 tw ce n : at. f : at at. f ( f n)

plus = x : nat. y : nat. x+y要求：写出求值所依赖的规则和相应的推导结果。要求：写出求值所依赖的规则和相应的推导结果。


Theory of Programming Languages 程序设计语言理论 -...

Documents

Transcript of Theory of Programming Languages 程序设计语言理论 -...