|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
编程范型 |
| --- |
|  |
| 指令式 | 
* 过程式
* 块结构
* 例外处理
* 结构化
* 模块化

 |
|  |
| 函数式 | 
* 头等函数
* 纯函数式
* 隐式
* 模式匹配
* 推导式

 |
|  |
| 面向对象 | 
* 基于类
* 基于原型
* 契约式
* 面向方面
* 面向代理

 |
|  |
| 数据流程 | 
* 同步式
* 响应式
	+ 函数式响应式
* 串流处理
* 基于流程

 |
|  |
| 宣告式 | 
* 逻辑式
	+ 回答集
* 约束式
* 数据查询
* 框架本体

 |
|  |
|  | 
* 协程
* 演员模型
* 通信顺序进程
* future/promise
* 分叉会合
* 整体同步
* 映射归约

 |
|  |
| 其他 | 
* 递归
* 阵列式
* 多态
	+ 运算符重载
	+ 泛型
	+ 多分派
* 面向堆栈
* 非确定性
* 数据驱动
* 事件驱动
* 自动机
* 可微分
* 概率式

 |
|  |
| 按语言比较（英语：） |

 |

（first-class function；第一級函數）是指在程序设计语言中，函数被当作头等公民。这意味着，函数可以作为别的函数的参数、函数的返回值，赋值给变量或存储在数据结构中。  有人主张应包括支持匿名函数（函数字面量，function literals）。在这样的语言中，函数的名字没有特殊含义，它们被当作具有函数类型的普通的变量对待。1960年代中期，克里斯托弗·斯特雷奇在"functions as first-class citizens"中提出这一概念。

是函数式程序设计所必须的。通常要使用高阶函数。map函数就是一个高阶函数，其实参是一个函数及一个list，返回结果是把作为参数的函数作用于list的每个元素后的结果形成的list。 

把函数作为函数参数与函数返回值会遇到特别的困难。特别是存在非局部变量（英语：）与嵌套函数（英语：）、匿名函数。历史上，这被称作函数参数问题（英语：）。 早期的指令式编程语言，或者不支持函数作为结果类型（如ALGOL 60, Pascal），或者忽略嵌套函数与非局部变量（如C语言）。早期的函数式语言Lisp采取了动态作用域方法，把非局部变量绑定到函数执行点最近的变量定义。Scheme语言支持词法作用域的，把对函数的引用绑定到闭包（closure）而不是函数指针，这使得垃圾收集成为必须。

概念
--

在这一节，比较把函数视作头等公民的典型的函数式语言Haskell与把函数视作二等公民的指令式编程的C语言的有关概念。 

### 高阶函数：函数作为实参传递

更多：高阶函数
具有函数参数的函数，称为高阶函数。函数式语言如Haskell：

```
map :: (a -> b) -> [a] -> [b]
map f [] = []
map f (x:xs) = f x : map f xs

```

函数不是头等公民的程序设计语言可以使用函数指针或delegate，实现函数作为参数。C语言例子:

```
void map(int (\*f)(int), int x[], size\_t n) {
 for (int i = 0; i < n; i++)
 x[i] = f(x[i]);
}

```

### 匿名与嵌套函数

更多：匿名函数和嵌套函数
对于支持匿名函数的语言:

```
main = map (\x -> 3 \* x + 1) [1, 2, 3, 4, 5]

```

对于不支持匿名函数的语言，必须把函数绑定到一个名字上:

```
int f(int x) {
 return 3 \* x + 1;
}

int main() {
 int list[] = {1, 2, 3, 4, 5};
 map(f, list, 5);
}

```

### 非局部变量与闭包

更多：非局部变量和闭包 (计算机科学)
一旦有了匿名函数与嵌套函数，引用函数体之外的变量（非局部变量）就很自然了： 

```
main = let a = 3
 b = 1
 in map (\x -> a \* x + b) [1, 2, 3, 4, 5]

```

如果函数只能用函数指针表示，如何把函数体之外的值传递给函数就是个问题。可以手工建立一个闭包，但显然这不能算作头等函数：

```
typedef struct {
 int (\*f)(int, int, int);
 int \*a;
 int \*b;
} closure\_t;

void map(closure\_t \*closure, int x[], size\_t n) {
 for (int i = 0; i < n; ++i)
 x[i] = (\*closure->f)(\*closure->a, \*closure->b, x[i]);
}

int f(int a, int b, int x) {
 return a \* x + b;
}

void main() {
 int l[] = {1, 2, 3, 4, 5};
 int a = 3;
 int b = 1;
 closure\_t closure = {f, &a, &b};
 map(&closure, l, 5);
}

```

注意这里的`map`是特化为使用当前环境外的两个`int`。即使`f`是个嵌套函数，仍然要面对同样问题，这也是C语言不支持嵌套函数的理由。

### 高阶函数：返回函数作为结果

返回结果为函数时，实际上返回的是该函数的闭包。对于C语言，函数退出时其局部变量也退出了各自的作用域，这使得构建闭包变得困难。这被称为向上的函数参数问题（英语：）。

### 函数赋值给变量

把函数赋值给变量面临着把函数当作返回结果一样的困难：构建该函数的闭包： 

```
f :: [[Integer] -> [Integer]]
f = let a = 3
 b = 1
 in [map (\x -> a \* x + b), map (\x -> b \* x + a)]

```

### 函数的相等

判断两个函数是否相等，有不同的判据：

外延相等两个函数*f*与*g*如果是外延相等，当它们对同一输入有相等的输出。即(∀*x*. *f*(*x*) = *g*(*x*)). 决定外延相等通常是不可判定问题，甚至在函数的定义域是有限时也不可行。
以数学上的函数来举例：R→R的函数f(x)=√(x²)和g(x)=|x|是外延相等的。
内涵相等判断两个函数*f*与*g*是否相等，可以比较二者编译后的结果。
例：上面的f(x)和g(x)不是内涵相等的，因为其定义式以及运算过程不同。
引用相等（Reference equality）由于外延相等与内涵相等都不切实际，大多数语言支持用两个函数的引用是否同一来判断。函数或闭包绑定到独一的标识符（通常为其内存地址），根据其标识符确定相等。两个分开定义但具有同样内容的函数被判断为不等。
引用相等破坏了引用透明（英语：），因此纯函数式语言如Haskell不采用这个方法。而另一方面，非纯函数式的语言（如C++）也只能对函数/闭包对象与"空"判断是否相等、即对象是否有引用到某函数上，而不定义两个函数/闭包对象是否相等。

类型论
---

条目：函数类型
对于类型论，函数类型接受值类型*A*并返回值类型*B*可写为*A* → *B*或*B**A*。根据柯里-霍华德对应，函数类型可对应于逻辑蕴涵，lambda抽象对应于discharging hypothetical assumptions，函数调用对应于肯定前件推理规则。类型论还使用头等函数建模关联数组与类似的数据结构。 

对于范畴论，头等函数对应于closed category（英语：）设置。例如，简单类型λ演算 对应于笛卡儿闭范畴(CCC)的内部语言。

语言支持
----

函数式程序设计语言，如Scheme、ML、Haskell、F#、Scala，都具有完整的头等函数。Lisp作为最早的函数式语言在当初设计时对头等函数各方面还没有适当的理解，导致了采用动态作用域。后来的Common Lisp已经改为使用词法作用域的头等函数。 

许多脚本语言，如Perl、Python、PHP、Lua、Tcl/Tk、JavaScript、Io，有头等函数。

指令式程序设计语言，Algol及Pascal族系、C族系，与现代有垃圾收集的语言非常不同。Algol族系允许嵌套函数与高阶函数作为参数，但不允许函数作为返回值（除了Algol 68）。因为当时还不清楚如何处理内嵌函数作为返回值时的非局部变量问题（Algol 68对此会产生运行期错误）。 

C族系允许函数作为参数与函数作为返回值，但由于不支持嵌套函数而避开了相关问题。因为返回嵌套函数并捕获所使用的非局部变量被认为才是真正有用，因此C族系不被认为有头等函数。 

现代指令式编程语言由于有垃圾收集功能而使得头等函数成为可能。很多语言的后续版本开始支持头等函数，如C# 2.0，Apple公司的C、C++与Objective-C的Block扩展。C++11开始支持了匿名函数与闭包。 

| 语言 | 高阶函数 | 非局部变量 | 部份应用（英语：） | 注释 |
| --- | --- | --- | --- | --- |
| 实参 | 返回结果 | 嵌套函数 | 匿名函数 | 闭包 |
| Algol 家族 | ALGOL 60 | 是 | 否 | 是 | 否 | 否 | 否 | 有函数类型 |
| ALGOL 68 | 是 | 是 | 是 | 是 | 否 | 否 |
| Pascal | 是 | 否 | 是 | 否 | 否 | 否 |
| Oberon | 是 | Non-nested only | 是 | 否 | 否 | 否 |
| Delphi | 是 | 是 | 是 | 2009 | 2009 | 否 |
| C 家族 | C | 是 | 是 | 否 | 否 | 否 | 否 | 有函数指针 |
| C++ | 是 | 是 | C++11 closures | C++11 | C++11 | C++11 | 有函数指针、函数对象。使用`std::bind`可显式部份应用。 |
| C# | 是 | 是 | 7 | 2.0 / 3.0 | 2.0 | 3.0 | 有delegate(2.0)及lambda表达式(3.0) |
| Go | 是 | 是 | 是 | 是 | 是 | 否 |
| Objective-C | 是 | 是 | 否 | 2.0 + Blocks | 2.0 + Blocks | 否 | 有函数指针 |
| Java | 部份 | 部份 | 否 | Java 8 | Java 8 | 否 | 有匿名内部类. |
| Limbo | 是 | 是 | 是 | 是 | 是 | 否 |
| Newsqueak | 是 | 是 | 是 | 是 | 是 | 否 |
| Rust | 是 | 是 | 是 | 是 | 是 | 否 |
| 函数式语言 | Lisp | Syntax | Syntax | 是 | 是 | Common Lisp | 否 | (见下) |
| Scheme | 是 | 是 | 是 | 是 | 是 | SRFI 26 |  |
| Clojure | 是 | 是 | 是 | 是 | 是 | 是 |  |
| ML | 是 | 是 | 是 | 是 | 是 | 是 |  |
| Haskell | 是 | 是 | 是 | 是 | 是 | 是 |  |
| Scala | 是 | 是 | 是 | 是 | 是 | 是 |  |
| 脚本语言 | JavaScript | 是 | 是 | 是 | 是 | 是 | ECMAScript 5 | 用户代码在ES3上有部份应用  |
| PHP | 是 | 是 | 5.3 closures | 5.3 closures | 5.3 closures | 否 | 用户代码可有部份应用 |
| Perl | 是 | 是 | anonymous, 6 | 是 | 是 | 6 | (见下) |
| Python | 是 | 是 | 是 | 部份 | 是 | 2.5 | (见下) |
| Ruby | Syntax | Syntax | Unscoped | 是 | 是 | 1.9 | (见下) |
| 其他语言 | Io | 是 | 是 | 是 | 是 | 是 | 否 |
| Maple | 是 | 是 | 是 | 是 | 是 | 否 |  |
| Mathematica | 是 | 是 | 是 | 是 | 是 | 否 |  |
| MATLAB | 是 | 是 | 是 | 是 | 是 | 是 | 新的函数可自动产生部份应用 |
| Smalltalk | 是 | 是 | 是 | 是 | 是 | 部份 | 通过库可有部份应用 |
| Fortran | 是 | 是 | 是 | 否 | 否 | 否 |  |
| Swift | 是 | 是 | 是 | 是 | 是 | 是 |  |
| Ada | 是 | 是 | 是 | 否 | Downward Closure | 否 |  |

C++C++11闭包可捕获非局部变量通过传引用（不扩展非局部变量的生存期）或者传值的方式。
JavaJava 8闭包仅能捕获immutable ("effectively final")局部变量。Java没有函数类型。Java 8的匿名函数从上下文推导其类型，且必须是"functional interface" （只有一个方法的接口）。
Lisp
词法作用域Lisp的变种支持闭包。动态作用域的变种不支持闭包，需要特别构造闭包。
Common Lisp，函数名字空间的函数的标识符不能用于头等函数的值的引用。必须要特殊运算符`function`来获取函数的值，如：`(function foo)`得到一个函数对象。`#'foo`是一个快捷表示。若想应用这样的函数对象，必须用`funcall` 函数：`(funcall #'foo bar baz)`.
Perl
Perl 5只允许匿名函数被嵌套。
Python
Python的匿名函数只允许表达式作为函数体。
从2.5版，使用`functools.partial`来显式部分应用，或从2.8版的`operator.methodcaller`
Ruby
普通函数的标识符不能用作值或传递。必须通过`Method`或`Proc`对象来获取头等数据。调用这种函数对象的语法不同于调用普通函数的语法。
嵌套方法定义并不实际嵌套作用域。
用`curry`显式currying操作

参考文献
----

* Leonidas Fegaras（英语：）. "Functional Languages and Higher-Order Functions". CSE5317/CSE4305: Design and Construction of Compilers. University of Texas at Arlington.

参閲
--

* Defunctionalization（英语：）
* eval
* First-class message（英语：）
* Kappa演算（英语：） – 排除了头等函数后的形式化
* 编译器递归测试

外部链接
----

* First-class functions（页面存档备份，存于） on Rosetta Code.
* Higher order functions（页面存档备份，存于） at IBM developerWorks（英语：）


|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
数据类型 |
| --- |
|  |
| 无解释的 | 
* 位元
* 字节
* 三进制位
* 三进制字节
* 字

 |
|  |
| 数值 | 
* 整数
	+ 符号性
	+ 有符号数
	+ 无符号数
* 定点数
* 浮点数
	+ 双精度
	+ 扩展精度（英语：）
	+ 半精度
	+ 迷你浮点数（英语：）
	+ 八倍精度（英语：）
	+ 四倍精度（英语：）
	+ 单精度
* 有理数（英语：）
* 复数（英语：）
* 任意精度算术
* 区间（英语：）

 |
|  |
| 文本 | 
* 字符
* 字符串

 |
|  |
| 指针 | 
* 記憶體位址
	+ 物理地址
	+ 虚拟地址
* 參照

 |
|  |
| 组合 | 
* 代数数据类型
	+ 广义（英语：）
* 数组
* 关联数组
* 类
* 串列
* 对象
	+ 元对象
* 可选类型
* 积类型（英语：）
* 记录
* 集合
* 联合体
	+ 标签

 |
|  |
| 其他 | 
* 布尔型
* 底层类别（英语：）
* 容器
* 枚举类型
* 异常
* 头等函数
* 不透明数据类型（英语：）
* 递归数据类型
* 信号标
* 字串流
* 顶类型（英语：）
* 类型类
* 類型系統
* 单位类型（英语：）
* Void
* 不定型別

 |
|  |
| 相关议题 | 
* 抽象資料型別
* 数据结构
* 介面
* 种类（英语：）
* 元类
* 对象类型（英语：）
* 原始型別与複合型別
* 协议
* 子类型
* C++模板
* 型別構造器
* 参数多态

 |

 |