编程语言：类型系统的本质

0. 引子

我一直对编写更好的代码有浓厚的兴趣。如果你能真正理解什么是抽象，什么是具象，就能理解为什么现代编程语言中，接口和函数类型为什么那么普遍存在了。在使用函数式语言进行编程后，就能够很清晰地理解为什么随着时间的推移，更主流的语言开始采用函数式语言中的一些被认为理所当然的特性。

我将多年间学习类型系统和编程语言开发的经验汇聚起来，加以提炼，并辅以现实世界的应用，撰写了这篇文章。本文脉络如下：

1. 概述：什么是类型？为什么要引入类型的概念？

2. 编程语言中的基本类型

3. 类型组合

4. OOP与接口类型

5. 函数类型

6. 函子（Functor）和单子（Monad）

1. 概述：什么是类型？为什么要引入类型的概念？

类型系统设计的理论与日常生产软件之间存在直接的联系。这并不是一个革命性的发现：复杂的类型系统特性之所以存在，就是为了解决现实世界的问题。

本节介绍类型和类型系统，讨论它们为什么存在以及为什么有用。我们将讨论类型系统的类型，并解释类型强度、静态类型和动态类型。

两个术语：类型、类型系统

类型

类型是对数据做的一种分类，定义了能够对数据执行的操作、数据的意义，以及允许数据接受的值的集合。编译器和运行时会检查类型，以确保数据的完整性，实施访问限制，以及按照开发人员的意图来解释数据。

类型系统

类型系统是一组规则，为编程语言的元素分配和实施类型。这些元素可以是变量、函数和其他高级结构。类型系统通过两种方式分配类型：程序员在代码中指定类型，或者类型系统根据上下文，隐式推断出某个元素的类型。类型系统允许在类型之间进行某些转换，而阻止其他类型的转换。

从复杂系统的约束开始

“系统”一词由来已久，在古希腊是指复杂事物的总体。到近代，一些科学家和哲学家常用系统一词来表示复杂的具有一定结构的整体。在宏观世界和微观世界，从基本粒子到宇宙，从细胞到人类社会，从动植物到社会组织，无一不是系统的存在方式。

控制论（维纳，1948，《控制论(或关于在动物和机器中控制和通讯的科学)》）告诉我们，负反馈就是系统稳定的机制，一个组织系统之所以能够受到干扰后能迅速排除偏差恢复恒定的能力，关键在于存在着“负反馈调节”机制：系统必须有一种装置，来测量受干扰的变量和维持有机体生存所必需的恒值之间的差别。例如，一个实时系统复杂性任务的约束，包括时间约束、资源约束、执行顺序约束和性能约束。

类型检查：类型检查确保程序遵守类型系统的规则。编译器在转换代码时进行类型检查，而运行时在执行代码时进行类型检查。编译器中负责实施类型规则的组件叫作类型检查器。如果类型检查失败，则意味着程序没有遵守类型系统的规则，此时程序将会编译失败，或者发生运行时错误。“遵守类型系统规则的程序相当于一个逻辑证明。”

类型系统，就是复杂软件系统的“负反馈调节器”。通过一套类型规范，加上编译监控和测试机制，来实现软件系统的数据抽象和运行时数据处理的安全。

随着软件变得越来越复杂，我们越来越需要保证软件能够正确运行。通过监控和测试，能够说明在给定特定输入时，软件在特定时刻的行为是符合规定的。但类型为我们提供了更加一般性的证明，说明无论给定什么输入，代码都将按照规定运行。

例如，将一个值标记为 const，或者将一个成员变量标记为 private，类型检查将强制限制实施其他许多安全属性。

从 01 到现实世界对象模型

类型为数据赋予了意义。类型还限制了一个变量可以接受的有效值的集合。

在低层的硬件和机器代码级别，程序逻辑（代码）及其操作的数据是用位来表示的。在这个级别，代码和数据没有区别，所以当系统误将代码当成数据，或者将数据当成代码时，就很容易发生错误。这些错误可能导致系统崩溃，也可能导致严重的安全漏洞，攻击者利用这些漏洞，让系统把他们的输入数据作为代码执行。

通过对编程语言的研究，人们正在设计出越来越强大的类型系统（例如，Elm或Idris语言的类型系统）。Haskell正变得越来越受欢迎。同时，在动态类型语言中添加编译时类型检查的工作也在推进中：Python添加了对类型提示的支持，而TypeScript这种语言纯粹是为了在JavaScript中添加编译时类型检查而创建的。

显然，为代码添加类型是很有价值的，利用编程语言提供的类型系统的特性，可以编写出更好、更安全的代码。

编程语言中的数据类型

类型系统是每个编程语言都会有的基本概念。

1. Lisp 数据类型可分类为：

• 标量类型 - 例如，数字类型，字符，符号等。
  -数据结构 - 例如，列表，向量，比特向量和字符串。

1. C 语言的类型系统分为：基本类型和复合类型。基本类型又可以细分为：整型数值类型和浮点数数值类型，不同类型所占用的内存长度不相同：

整型数值基本类型

char 占用一个字节
short 占用两个字节
int 目前基本都是4字节
long int (可以简写为 long) (32位系统是4字节，64位系统是8字节)
long long int ( 可以简写为long long) 占用8节字

浮点数数值基本类型

float 占用4字节 (单精度)
double 占用8节字 (双精度浮点数)

复合类型包含如下几种

struct 结构体
union 联合体
enum 枚举 (长度等同 int )
数组
指针

1. Go语言中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有数组，切片（slice），结构体（struct），接口（interface），函数（func），map , 通道（channel）等。

• 整型：int8 int6 int32 int64；对应的无符号整型：uint8 uint16 uint32 uint64。uint8 就是我们熟知的 byte 型,int16对应C语言中的short型，int64 对应C语言中 long 型。

• 浮点类型：float32和 float64, 浮点这两种浮点型数据格式遵循 IEEE 754标准。

• 切片：可变数组，是对数组的一种抽象。切片是引用类型。

• 接口：实现多态，面向接口编程。定义一个接口 I , 然后使用不同的结构体对接口 I 进行实现,然后利用接口对象作为形式参数,将不同类型的对象传入并调用相关的函数,实现多态。接口可以进行嵌套实现,通过大接口包含小接口。

类型强度

强类型和弱类型的区别没有权威的定义。大多数早期关于强类型和弱类型的讨论可以概括为静态类型和动态类型之间的区别。

但流行的说法是强类型倾向于不容忍隐式类型转换，而弱类型倾向于容忍隐式类型转换。这样，强类型语言通常是类型安全的，也就是说，它只能以允许的方式访问它被授权访问的内存。

通常，动态类型语言倾向于与 Python、Ruby、Perl 或 Javascript 等解释型语言相关联，而静态类型语言倾向于编译型语言，例如 Golang、Java 或 C。

我总结了一个常见编程语言类型的分类图，注意拆分的四个区域是分区，比如PHP和JS都是动态弱类型。

静态类型与动态类型

我们经常听到“静态与动态类型”这个问题，其实，两者的区别在于类型检查发生的时间。

1. 静态类型系统在编译时确定所有变量的类型，并在使用不正确的情况下抛出异常。静态类型系统，将运行时错误转换成编译时错误，能够使代码更容易维护、适应性更强，对于大型应用程序，尤其如此。

2. 而在动态类型中，类型绑定到值。检查是在运行时进行的。动态类型系统在运行时确定变量类型，如果有错误则抛出异常，如果没有适当的处理，可能会导致程序崩溃。动态类型不会在编译时施加任何类型约束。日常交流中有时会将动态类型叫作“鸭子类型”（duck typing），这个名称来自俗语：“如果一种动物走起来像鸭子，叫起来像鸭子，那么它就是一只鸭子。”代码可按照需要自由使用一个变量，运行时将对变量应用类型。

静态类型系统的早期类型错误报告保证了大规模应用程序开发的安全性，而动态类型系统的缺点是编译时没有类型检查，程序不够安全。只有大量的单元测试才能保证代码的健壮性。但是使用动态类型系统的程序，很容易编写并且不需要花费很多时间来确保类型正确。所谓“鱼和熊掌不可兼得”，这就是关于“效率”与“质量”的哲学问题了。

不过，现代类型检查器具有强大的类型推断算法，使它们能够确定变量或者函数的类型，而不需要我们显式地写出类型。

小结

• 类型是一种数据分类，定义了可以对这类数据执行的操作、这类数据的意义以及允许取值的集合。

• 类型系统是一组规则，为编程语言的元素分配并实施类型。

• 类型限制了变量的取值范围，所以在一些情况中，运行时错误就被转换成了编译时错误。

• 不可变性是类型施加的一种数据属性，保证了值在不应该发生变化时不会发生变化。

• 可见性是另外一种类型级别的属性，决定了哪些组件能访问哪些数据。

• 类型标识符使得阅读代码的人更容易理解代码。

• 动态类型（或叫“鸭子类型”）在运行时决定类型。

• 静态类型在编译时检查类型，捕获到原本有可能成为运行时错误的类型错误。

• 类型系统的强度衡量的是该系统允许在类型之间进行多少隐式转换。

• 现代类型检查器具有强大的类型推断算法，使它们能够确定变量或者函数的类型，而不需要我们显式地写出类型。

2. 编程语言中的基本类型

本节介绍编程语言类型系统的特性，从基本类型开始，到函数类型、OOP、泛型编程和高阶类型（如函子和单子）。

基本类型

常用的基本类型包括空类型、单元类型、布尔类型、数值类型、字符串类型、数组类型和引用类型。

函数类型

“函数类型是类型系统在基本类型及其组合的基础上发展的又一个阶段。”

大部分现代编程语言都支持匿名函数，也称为lambda。lambda与普通的函数类似，但是没有名称。每当我们需要使用一次性函数时，就会使用lambda。所谓一次性函数，是指我们只会引用这种函数一次，所以为其命名就成了多余的工作。

lambda或匿名函数：lambda，也称为匿名函数，是没有名称的函数定义。lambda通常用于一次性的、短期存在的处理，并像数据一样被传来传去。

函数能够接受其他函数作为实参，或者返回其他函数。接受一个或多个非函数实参并返回一个非函数类型的“标准”函数也称为一阶函数，或普通函数。接受一个一阶函数作为实参或者返回一个一阶函数的函数称为二阶函数。

我们可以继续往后推，称接受二阶函数作为实参或者返回二阶函数的函数为三阶函数，但是在实际运用中，我们只是简单地把所有接受或返回其他函数的函数称为高阶函数。

我们可以使用“函数类型”简化策略模式。如果一个变量是函数类型（命名函数类型），并在使用其他类型的值的地方能够使用函数，就可以简化一些常用结构的实现，并把常用算法抽象为库函数。

泛型编程

泛型编程支持强大的解耦合以及代码重用。
泛型数据结构把数据的布局与数据本身分隔开。迭代器支持遍历这些数据结构。泛型算法（例如，最经典的 sort 排序算法 ）是能够在不同数据类型上重用的算法。迭代器（Iterator）用作数据结构和算法之间的接口，并且能够根据迭代器的能力启用不同的算法。

例如， 一个泛型函数 ：

(value:T) => T

它的类型参数是T。当为T指定了实际类型时，就创建了具体函数。具体类图示例如下：

再例如，一个泛型二叉树。

泛型高阶函数 map() , filter() , reduce() 代码和示意图如下。

• map()

public inline fun  Iterable.map(transform: (T) -> R): List {    return mapTo(ArrayList(collectionSizeOrDefault(10)), transform)}

• filter()

public inline fun  Iterable.filter(predicate: (T) -> Boolean): List {    return filterTo(ArrayList(), predicate)}

• reduce()

public inline fun  Iterable.reduce(operation: (acc: S, T) -> S): S {    val iterator = this.iterator()    if (!iterator.hasNext()) throw UnsupportedOperationException("Empty collection can't be reduced.")    var accumulator: S = iterator.next()    while (iterator.hasNext()) {        accumulator = operation(accumulator, iterator.next())    }    return accumulator}

高阶类型

高阶类型与高阶函数类似，代表具有另外一个类型参数的类型参数。例如，T或Box>有一个类型参数T，后者又有一个类型参数U。

class Functor{    private value:T;    constructor(val:T){        this.value = val    }    public map(fn:(val:T)=>U){        let rst = fn(this.value)        return new Functor(rst)    }}

new Functor(3)    .map(d=>add(d))    .map(d=>double(d.value))    .map(d=>square(d.value)) // Functor { value: 256 }

恒等定律：fmap id = id组合定律：fmap (g . h) = (fmap g) . (fmap h)

class Functor {  // 构造函数，创建函子对象的时候接收任意类型的值，并把值赋给它的私有属性 _value  constructor(value) {     this._value = value  }   // 接收一个函数，处理值的变形并返回一个新的函子对象  map (fn) {    return new Functor(fn(this._value))  }}let num1 = new Functor(3).map(val => val + 2)// 输出：Functor { _value: 5 }console.log(num1)let num2 = new Functor(3).map(val => val + 2).map(val => val * 2)// 输出：Functor { _value: 10 }console.log(num2)// 改变了值类型let num3 = new Functor('webpack').map(val => `${val}-cli`).map(val => val.length)// 输出：Functor { _value: 11 }console.log(num3)

Maybe.of(3).map(n => Maybe.of(n + 2)) // Maybe { value: Maybe { value: 5 } }

class Monad exteds Functor{    static of(val:T){        return new Monad(val)    }    isNothing() {        return this.value === null || this.value === undefined    }    public map(fn:(val:T)=>U){        if (this.isNothing()) return Monad.of(null)        let rst = fn(this.value)        return Monad.of(rst)    }    public join(){        return this.value    }    public flatMap(fn:(val:T)=>U){        return this.map(fn).join()    }}Monad.of(3).flatMap(val => Monad.of(val + 2)) // Monad { value: 5 }

unit(x) : T -> M T

bind:  执行 fn: T  -> M

class Monad {  value = "";  // 构造函数  constructor(value) {    this.value = value;  }  // unit，把值装入 Monad 构造函数中  unit(value) {    this.value = value;  }  // bind，把值转换成一个新的 Monad  bind(fn) {    return fn(this.value);  }}// 满足 x-> M(x) 格式的函数function add1(x) {  return new Monad(x + 1);}// 满足 x-> M(x) 格式的函数function square(x) {  return new Monad(x * x);}// 接下来，我们就能进行链式调用了const a = new Monad(2)     .bind(square)     .bind(add1);     //...console.log(a.value === 5); // true

任何一个数 + 0 = 这个数本身。那么 0 就是单位元（加法单位元）任何一个数 * 1 = 这个数本身。那么 1 就是单位元（乘法单位元）