类型系统(一)

本文为学习类型系统的系列文章的第一篇。主要参考资料为大名鼎鼎的$Types$ $and$ $Programming$ $Languages$。

相信有很多跟我一样的读者都是从$C$系语言如$Java$,$C/CPP$等入门开始学习编程。而对我来讲，对于类型系统的概念仅仅停留在$Java$的泛型语言之中。由于$Java$的泛型相对来说较为简单，一度让我以为类型不过是些细枝末节，直到我接触到了$Scala$，$Haskell$这样的语言，才一点一点对类型系统有了较为清楚的认识，同时也开始学习相关方面的知识。

类型系统简介

首先来看看对于类型系统的定义

$A$ $type$ $system$ $is$ $a$ $tractable$ $syntactic$ $method$ $for$ $proving$ $the$ $absence$ $of$
$certain$ $program$ $behaviors$ $by$ $classifying$ $phrases$ $according$ $to$ $the$ $kinds$
$of$ $values$ $they$ $compute.$

类型系统有以下几个优点

• Detecting Errors(错误检查)
• Abstraction(抽象)
• Documentation(文档化)
• Language Safety(语言安全性)
• Efficiency(有效性)
• Further Applications(更多应用)

数学基础

需要读者有集合，序列，归纳等方面的知识，具体可自行查阅

无类型算术表达式

无类型算术表达式主要为了介绍诸如抽象语法，归纳定义和证明，求值，运行时错误等概念的建模。
首先我们需要定义算术表达式的语言形式。以BNF文法形式表达如下

t ::=            terms:
   true         constant true
   false          constant false
   if t then t else t     conditional
   0           constant zero
   succ t         successor
   pred t         predecessor
   iszero t         zero test

语法

归纳定义

• $true,false,0\subseteq T;$
• $ift1\in T,thensucct1,predt1,iszerot1\subseteq T;$
• $ift1\in T,t2\in T,andt3\in T,$ $then$ $if$ $t1$ $then$ $t2$ $else$ $t3\in T.$

推导规则定义

• $true\in \text{T false}\in \text{T 0}\in T$
• $\frac{t1\in T}{\text{pred t1}\in T}$ $\frac{t1\in T}{\text{iszero t1}\in T}$ $\frac{t1\in T}{\text{succ t1}\in T}$
• $\frac{\text{t1 ∈ T iszero t1 ∈ T t1 ∈ T t2 ∈ T t3 ∈ T}}{\text{if t1 then t2 else t3 ∈ }T}$

具体定义

$S_0=\varnothing$
S i + 1 = { true,false,0 } S_{i+1} =\quad \left\{\text{true,false,0}\right\} Si+1​={true,false,0}
     ∪ { succ t1,pred t1,iszero t1  ∣ t 1 ∈ S i } \cup\left\{\text{succ t1,pred t1,iszero t1 }\mid t1 \in S_i\right\} ∪{succ t1,pred t1,iszero t1 ∣t1∈Si​}
     ∪ { if t1,then t2 else t3  ∣ t 1 , t 2 , t 3 ∈ S i } \cup\left\{\text{if t1,then t2 else t3 }\mid t1,t2,t3 \in S_i\right\} ∪{if t1,then t2 else t3 ∣t1,t2,t3∈Si​}

对项的归纳

常量集合

$\text{Consts(true)}=true$
$\text{Consts(false) = false}$
$\text{Consts(0) = 0}$
$\text{Consts(succ t1) = Consts(t1)}$
$\text{Consts(pred t1) = Consts(t1)}$
$\text{Consts(iszero t1) = Consts(t1)}$
$\text{Consts(if t1 then t2 else t3) = Consts(t1) ∪ Consts(t2) ∪ Consts(t3)}$

长度

$\text{size(true)}=1$
$\text{size(false) = 1}$
$\text{size(0) = 1}$
$\text{size(succ t1) = size(t1) + 1}$
$\text{size(pred t1) = size(t1) + 1}$
$\text{size(iszero t1) = size(t1) + 1}$
$\text{size(if t1 then t2 else t3) = size(t1) + size(t2) + size(t3) + 1}$

深度

$\text{depth(true)}=1$
$\text{depth(false) = 1}$
$\text{depth(0) = 1}$
$\text{depth(succ t1) = depth(t1) + 1}$
$\text{depth(pred t1) = depth(t1) + 1}$
$\text{depth(iszero t1) = depth(t1) + 1}$
$\text{depth(if t1 then t2 else t3) = max(depth(t1) , depth(t2) , depth(t3)) + 1}$

引理

$一个项上t中不同常量的个数不大于t的长度size(t)，即|Consts(t)|\le size(t)$

定理(项上归纳原理)

$假设P是项上的一个谓词：$

$对深度的归纳：如果对每个项s$
$假设对所有使得depth(r)<depth(s)的项r有P(r)，我们能证明P(s)$
$则P(s)对所有的s成立$
$对长度的归纳：如果对每个项s$
$假设对所有使得size(r)<size(s)的项r有P(r)，我们能证明P(s)$
$则P(s)对所有的s成立$
$结构归纳：如果对每个项s$
$假设对所有s的直接子项r有P(r)成立，我们能证明P(s)$
$则P(s)对所有的s成立$

语义形式

• 指称语义
• 操作语义
• 公理语义

求值

求值规则

• $\text{if true then }{t}_2\text{ else }{t}_3\to t_2(E-IfTrue)$
• $\text{if false then }{t}_2\text{ else }{t}_3\to t_3(E-IfFalse)$
• $\frac{t_1\to t_1^{\prime }}{\text{if }{t}_1\text{ then }{t}_2\text{ else }{t}_3\to \text{ if }{t}_1^{\prime }\text{ then }{t}_2\text{ else }{t}_3}(E-IF)$

一步求值关系

项上满足求值的最小二元关系

多步求值关系

多步求值关系是一步求值关系的自反，传递闭包。

范式

如果没有求值规则可以作用于项t，则该项是范式

受阻(stuck)

如果一个封闭项是一个范式但不是一个值，则称该项受阻

haskell实现

首先定义项。由于需要限制if的第一项类型为布尔型故添加了GADTs扩展

{-# LANGUAGE ExplicitForAll #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE MultiParamTypeClasses #-}

- term
data Term a where
  TmFalse :: Term Bool
  TmTrue :: Term Bool
  TmIf :: Term Bool -> Term a -> Term a -> Term a
  TmZero :: Term Int
  TmSucc :: Term Int -> Term Int
  TmPred :: Term Int -> Term Int
  TmIsZero :: Term Int -> Term Bool
- show terms
instance Show a => Show (Term a) where
  show TmFalse = "false"
  show TmTrue = "true"
  show TmZero = "zero"
  show (TmSucc a) = "succ " ++ show a
  show (TmPred a) = "pred" ++ show a

然后定义两个方法isnumericval和isVal，分别用来检验当前项是值还是数字

isnumericval :: forall a. Term a -> Bool
isnumericval TmZero = True
isnumericval (TmSucc a) = isnumericval a
isnumericval _ = False

isval :: Term a -> Bool
isval TmTrue = True
isval TmFalse = True
isval t = isnumericval t

然后定义求值方法，穷举所有可能项

eval1 :: Term a -> Term a
eval1 (TmIf TmTrue t2 t3) = t2
eval1 (TmIf TmFalse t2 t3) = t3
eval1 (TmIf t1 t2 t3) =
  let t1' = eval1 t1
  in TmIf t1' t2 t3
eval1 (TmSucc t1) = TmSucc t1'
  where
    t1' = eval1 t1
eval1 (TmPred TmZero) = TmZero
eval1 (TmPred (TmSucc nv1))
  | isnumericval nv1 = nv1
  | otherwise = error "unsupport rules"
eval1 (TmPred t1) = TmPred t1'
  where
    t1' = eval1 t1
eval1 (TmIsZero TmZero) = TmTrue
eval1 (TmIsZero (TmSucc nv1))
  | isnumericval nv1 = TmFalse
eval1 (TmIsZero t1) = TmIsZero (eval1 t1)
eval1 _ = error "unsupport rules"

可以看到上述求值代码有较多冗余，根据多步求值规则重写后如下

eval2 :: Term a -> Term a
eval2 a =
  case a of
    TmIf t1 t2 t3 ->
      case eval2 t1 of
        TmTrue -> eval2 t2
        TmFalse -> eval2 t3
    TmZero -> TmZero
    TmSucc a -> TmSucc (eval2 a)
    TmTrue -> TmTrue
    TmFalse -> TmFalse
    TmPred a ->
      case a of
        TmSucc b -> b
        TmZero -> TmZero
    _ -> error "unsupport rules"

上述实现可以看到，对于受阻项的处理都为打印错误信息。另外一种处理方式则是定义一个名为wrong的项，用来表示受阻项，有兴趣的可自行尝试。

当然，无类型的算术表达式十分简单。接下来就将进入$\lambda$演算的世界…