|
1 | 1 | # 3.2 函数式编程 |
2 | 2 |
|
3 | 3 | ::: details INFO |
4 | | -译者： |
| 4 | +译者：[Mancuoj](https://github.com/mancuoj) |
5 | 5 |
|
6 | 6 | 来源：[3.2 Functional Programming](https://www.composingprograms.com/pages/32-functional-programming.html) |
7 | 7 |
|
8 | 8 | 对应：Disc 10、Lab 10 |
9 | 9 | ::: |
| 10 | + |
| 11 | +现代计算机上运行的软件是由各种编程语言编写的。其中，有些是物理级别的语言，例如专为特定计算机设计的机器语言。这种语言主要关注如何将数据和指令转化为计算机可以识别的二进制位。使用机器语言的程序员主要考虑如何最大限度地发挥硬件的性能，以高效执行计算任务。而高级语言则基于机器语言之上，它屏蔽了数据和程序的底层表示方式。这些高级语言提供了更多的组合和抽象手段，例如函数定义，使得大型软件系统的构建更为方便和直观。 |
| 12 | + |
| 13 | +在这个章节中，我们要介绍一种偏向函数式编程的高级语言。这种语言，实际上是 Scheme 语言的一个子集，其计算模型与 Python 很相似，但它特点是只使用表达式而不使用语句，特别适合符号计算，并且它处理的数据都是不可变的（immutable）。 |
| 14 | + |
| 15 | +Scheme 是 [Lisp](<http://en.wikipedia.org/wiki/Lisp_(programming_language)>) 的一个变种，而 Lisp 是继 [Fortran](http://en.wikipedia.org/wiki/Fortran) 之后仍然广受欢迎的第二古老的编程语言。Lisp 程序员社区几十年来持续蓬勃发展，[Clojure](http://en.wikipedia.org/wiki/Clojure) 等 Lisp 的新方言拥有现代编程语言中增长最快的开发人员社区。如果你想亲手试试本文中的例子，可以下载一个 [Scheme 的解释器](http://inst.eecs.berkeley.edu/~scheme/) 来操作。 |
| 16 | + |
| 17 | +## 3.2.1 表达式 |
| 18 | + |
| 19 | +Scheme 程序主要是由各种表达式构成的，这些表达式可以是函数调用或一些特殊的结构。一个函数调用通常由一个操作符和其后面跟随的零个或多个操作数组成，这点和 Python 是相似的。不过在 Scheme 中，这些操作符和操作数都被放在一对括号里： |
| 20 | + |
| 21 | +```scheme |
| 22 | +(quotient 10 2) |
| 23 | +``` |
| 24 | + |
| 25 | +Scheme 的语法一直采用前缀形式。也就是说，操作符像 `+` 和 `*` 都放在前面。函数调用可以互相嵌套，并且可能会写在多行上： |
| 26 | + |
| 27 | +```scheme |
| 28 | +(+ (* 3 5) (- 10 6)) |
| 29 | +``` |
| 30 | + |
| 31 | +```scheme |
| 32 | +(+ (* 3 |
| 33 | + (+ (* 2 4) |
| 34 | + (+ 3 5))) |
| 35 | + (+ (- 10 7) |
| 36 | + 6)) |
| 37 | +``` |
| 38 | + |
| 39 | +在 Scheme 中，表达式可以是基础类型，如数字，或是复合类型，如函数调用。数字字面量是基础类型，而函数调用则是可以包含任意子表达式一种复合形式。当求值一个函数调用时，Scheme 的处理方式和 Python 相似：首先对操作符和操作数进行求值，然后用操作符的结果（即函数）去处理操作数的结果（即参数）。 |
| 40 | + |
| 41 | +在 Scheme 里，`if` 表达式是一种特殊结构。尽管从语法上看，它似乎和常规的函数调用相似，但其求值方式却与众不同。一般来说，`if` 表达式的结构如下： |
| 42 | + |
| 43 | +```scheme |
| 44 | +(if <predicate> <consequent> <alternative>) |
| 45 | +``` |
| 46 | + |
| 47 | +要理解 if 表达式是如何工作的，首先需要看它的 `<predicate>` 部分，即条件判断。如果这个条件成立（即为真），解释器就会执行并返回 `<consequent>` 的值；如果条件不成立，就会执行并返回 `<alternative>` 的值。 |
| 48 | + |
| 49 | +我们可以用常见的比较操作符来比较数字，但在 Scheme 中，这些操作符仍然采用前缀的形式： |
| 50 | + |
| 51 | +```scheme |
| 52 | +(>= 2 1) |
| 53 | +``` |
| 54 | + |
| 55 | +Scheme 中的布尔值有 `#t` 或者 `true` 代表真和 `#f` 或 `false` 代表假。你可以使用一些特定的布尔操作来组合它们，这些操作的执行逻辑和 Python 里的很相似。 |
| 56 | + |
| 57 | +> - `(and <e1> ... <en>)` 解释器会从左到右依次检查 `<e>` 表达式。一旦有一个 `<e>` 的结果是假，整个 `and` 表达式就直接返回假，并且剩下的 `<e>` 表达式不再检查。只有当所有 `<e>` 都是真时，`and` 表达式的返回值才是最后一个表达式的结果。 |
| 58 | +> - `(or <e1> ... <en>)` 解释器会从左到右依次检查 `<e>` 表达式。一旦有一个 `<e>` 的结果是真，`or` 表达式就直接返回那个真值，并且剩下的 `<e>` 表达式不再检查。只有当所有 `<e>` 都是假时，`or` 表达式才返回假。 |
| 59 | +> - `(not <e>)` 当 `<e>` 表达式的结果是假时，`not` 表达式就返回真，否则返回假。 |
| 60 | +
|
| 61 | +## 3.2.2 定义 |
| 62 | + |
| 63 | +你可以通过使用 `define` 这一特殊结构为某个值赋予一个名字： |
| 64 | + |
| 65 | +```scheme |
| 66 | +(define pi 3.14) |
| 67 | +(* pi 2) |
| 68 | +``` |
| 69 | + |
| 70 | +你可以用 `define` 的另一个版本来定义新的函数（在 Scheme 中，我们称之为“过程”）。例如，如果我们想定义一个求平方的函数，可以这样写： |
| 71 | + |
| 72 | +```scheme |
| 73 | +(define (square x) (* x x)) |
| 74 | +``` |
| 75 | + |
| 76 | +定义一个过程（procedure）的标准格式如下： |
| 77 | + |
| 78 | +```scheme |
| 79 | +(define (<name> <formal parameters>) <body>) |
| 80 | +``` |
| 81 | + |
| 82 | +`<name>` 是一个符号，用于表示与环境中的过程定义相关的内容。而 `<formal parameters>` 是在过程主体内部用于指代过程对应参数的名称。在形式参数被替换为实际应用到过程的参数时，`<body>` 将生成过程应用的值。 `<name>` 和 `<formal parameters>` 被括在括号内，就像实际调用所定义的过程一样。 |
| 83 | + |
| 84 | +一旦我们定义了 `square`，就可以在调用表达式中使用它了： |
| 85 | + |
| 86 | +```scheme |
| 87 | +(square 21) |
| 88 | +
|
| 89 | +(square (+ 2 5)) |
| 90 | +
|
| 91 | +(square (square 3)) |
| 92 | +``` |
| 93 | + |
| 94 | +用户自定义的函数可以接受多个参数，并且还可以包含特殊形式： |
| 95 | + |
| 96 | +```scheme |
| 97 | +(define (average x y) |
| 98 | + (/ (+ x y) 2)) |
| 99 | +
|
| 100 | +(average 1 3) |
| 101 | +``` |
| 102 | + |
| 103 | +```scheme |
| 104 | +(define (abs x) |
| 105 | + (if (< x 0) |
| 106 | + (- x) |
| 107 | + x)) |
| 108 | +``` |
| 109 | + |
| 110 | +Scheme 支持与 Python 相同的词法作用域规则，允许进行局部定义。下面，我们使用嵌套定义和递归定义了一个用于计算平方根的迭代过程： |
| 111 | + |
| 112 | +```scheme |
| 113 | +(define (sqrt x) |
| 114 | + (define (good-enough? guess) |
| 115 | + (< (abs (- (square guess) x)) 0.001)) |
| 116 | + (define (improve guess) |
| 117 | + (average guess (/ x guess))) |
| 118 | + (define (sqrt-iter guess) |
| 119 | + (if (good-enough? guess) |
| 120 | + guess |
| 121 | + (sqrt-iter (improve guess)))) |
| 122 | + (sqrt-iter 1.0)) |
| 123 | +(sqrt 9) |
| 124 | +``` |
| 125 | + |
| 126 | +匿名函数是通过 `lambda` 特殊形式创建的。`Lambda` 用于创建过程，与 `define` 相似，但不需要为过程指定名称： |
| 127 | + |
| 128 | +```scheme |
| 129 | +(lambda (<formal-parameters>) <body>) |
| 130 | +``` |
| 131 | + |
| 132 | +生成的过程与使用 `define` 创建的过程一样，唯一的区别是它没有在环境中关联任何名称。实际上，以下表达式是等效的： |
| 133 | + |
| 134 | +```scheme |
| 135 | +(define (plus4 x) (+ x 4)) |
| 136 | +(define plus4 (lambda (x) (+ x 4))) |
| 137 | +``` |
| 138 | + |
| 139 | +和任何返回过程的表达式一样，lambda 表达式可以在调用表达式中用作运算符： |
| 140 | + |
| 141 | +```scheme |
| 142 | +((lambda (x y z) (+ x y (square z))) 1 2 3) |
| 143 | +``` |
| 144 | + |
| 145 | +## 3.2.3 复合类型 |
| 146 | + |
| 147 | +在 Scheme 语言中，`pair` 是内置的数据结构。出于历史原因，`pair` 是通过内置函数 `cons` 创建的，而元素则可以通过 `car` 和 `cdr` 进行访问： |
| 148 | + |
| 149 | +```scheme |
| 150 | +(define x (cons 1 2)) |
| 151 | +
|
| 152 | +x |
| 153 | +
|
| 154 | +(car x) |
| 155 | +
|
| 156 | +(cdr x) |
| 157 | +``` |
| 158 | + |
| 159 | +Scheme 语言中也内置了递归列表，它们使用 `pair` 来构建。特殊的值 `nil` 或 `'()` 表示空列表。递归列表的值是通过将其元素放在括号内，用空格分隔开来表示的： |
| 160 | + |
| 161 | +```scheme |
| 162 | +(cons 1 |
| 163 | + (cons 2 |
| 164 | + (cons 3 |
| 165 | + (cons 4 nil)))) |
| 166 | +
|
| 167 | +(list 1 2 3 4) |
| 168 | +
|
| 169 | +(define one-through-four (list 1 2 3 4)) |
| 170 | +
|
| 171 | +(car one-through-four) |
| 172 | +
|
| 173 | +(cdr one-through-four) |
| 174 | +
|
| 175 | +(car (cdr one-through-four)) |
| 176 | +
|
| 177 | +(cons 10 one-through-four) |
| 178 | +
|
| 179 | +(cons 5 one-through-four) |
| 180 | +``` |
| 181 | + |
| 182 | +要确定一个列表是否为空，可以使用内置的 `null?` 谓词。借助它，我们可以定义用于计算长度和选择元素的标准序列操作： |
| 183 | + |
| 184 | +```scheme |
| 185 | +(define (length items) |
| 186 | + (if (null? items) |
| 187 | + 0 |
| 188 | + (+ 1 (length (cdr items))))) |
| 189 | +(define (getitem items n) |
| 190 | + (if (= n 0) |
| 191 | + (car items) |
| 192 | + (getitem (cdr items) (- n 1)))) |
| 193 | +(define squares (list 1 4 9 16 25)) |
| 194 | +
|
| 195 | +(length squares) |
| 196 | +
|
| 197 | +(getitem squares 3) |
| 198 | +``` |
| 199 | + |
| 200 | +## 3.2.4 符号数据 |
| 201 | + |
| 202 | +迄今为止，我们使用的所有复合数据对象最终都是由数字构建的。Scheme 的一个强大之处在于能够处理任意符号作为数据。 |
| 203 | + |
| 204 | +为了操作符号，我们需要语言中的一个新元素：引用数据对象的能力。假设我们想构建列表 `(a b)`。我们不能通过 `(list a b)` 来实现这一目标，因为这个表达式构建的是 `a` 和 `b` 的值，而不是它们自身的符号。在 Scheme 中，我们通过在它们前面加上一个单引号来引用符号 `a` 和 `b` 而不是它们的值： |
| 205 | + |
| 206 | +```scheme |
| 207 | +(define a 1) |
| 208 | +(define b 2) |
| 209 | +
|
| 210 | +(list a b) |
| 211 | +
|
| 212 | +(list 'a 'b) |
| 213 | +
|
| 214 | +(list 'a b) |
| 215 | +``` |
| 216 | + |
| 217 | +在 Scheme 中，任何不被求值的表达式都被称为被引用。这种引用的概念源自一个经典的哲学区分，即一种事物（比如一只狗）会四处奔跑和吠叫，而“狗”这个词是一种语言构造，用来指代这种事物。当我们在引号中使用“狗”时，我们并不是指代某只特定的狗，而是指代一个词语。在语言中，引号允许我们讨论语言本身，而在 Scheme 中也是如此： |
| 218 | + |
| 219 | +```scheme |
| 220 | +(list 'define 'list) |
| 221 | +``` |
| 222 | + |
| 223 | +引用还使我们能够输入复合对象，使用传统的打印表示方式来表示列表： |
| 224 | + |
| 225 | +```scheme |
| 226 | +(car '(a b c)) |
| 227 | +
|
| 228 | +(cdr '(a b c)) |
| 229 | +``` |
| 230 | + |
| 231 | +完整的 Scheme 语言包括更多功能，如变异操作（mutation operations）、向量（vectors）和映射（maps）。然而，到目前为止，我们介绍的这个子集已经提供了一个强大的函数式编程语言，可以实现我们在本文中讨论过的许多概念。 |
| 232 | + |
| 233 | +## 3.2.5 海龟图形 |
| 234 | + |
| 235 | +在这篇文章的 Scheme 版本中，加入了一个称为 Turtle 的图形功能（通常叫海龟），它源自 Logo 语言（Lisp 的另一种方言）中的一部分。这个“海龟”从一个画布的中心出发，根据特定的程序命令来移动和转向，并在它移动的过程中留下轨迹。尽管海龟图形最初是设计来吸引孩子学习编程的，但实际上，它对于高级程序员来说也是一个非常有趣的图形化编程工具。 |
| 236 | + |
| 237 | +当 Scheme 程序运行时，这只“海龟”会在画布上有一个特定的位置和方向。例如，使用 `forward` 和 `right` 这样的命令，可以改变“海龟”的位置和方向。为了方便，一些常用的程序命令有缩写形式，比如 `forward` 可以简写为 `fd`。在 Scheme 中，`begin` 这个特殊结构允许我们在一个表达式中串联多个子命令，这在执行多个操作时非常有用： |
| 238 | + |
| 239 | +```scheme |
| 240 | +> (define (repeat k fn) (if (> k 0) |
| 241 | + (begin (fn) (repeat (- k 1) fn)) |
| 242 | + nil)) |
| 243 | +> (repeat 5 |
| 244 | + (lambda () (fd 100) |
| 245 | + (repeat 5 |
| 246 | + (lambda () (fd 20) (rt 144))) |
| 247 | + (rt 144))) |
| 248 | +nil |
| 249 | +``` |
| 250 | + |
| 251 | + |
| 252 | + |
| 253 | +Python 也内置了完整的 Turtle 功能，作为一个 [turtle 库模块](http://docs.python.org/py3k/library/turtle.html)。 |
| 254 | + |
| 255 | +再举一个例子，Scheme 可以用其 Turtle 图形功能以非常简洁的方式来展现递归的图形。谢尔宾斯基三角形是一种分形结构，它将大的三角形分解成三个小的三角形，小三角形的顶点位于大三角形边的中点。我们可以用下面的 Scheme 程序来实现这个到一定递归深度的绘制： |
| 256 | + |
| 257 | +``` |
| 258 | +> (define (repeat k fn) |
| 259 | + (if (> k 0) |
| 260 | + (begin (fn) (repeat (- k 1) fn)) |
| 261 | + nil)) |
| 262 | +
|
| 263 | +> (define (tri fn) |
| 264 | + (repeat 3 (lambda () (fn) (lt 120)))) |
| 265 | +
|
| 266 | +> (define (sier d k) |
| 267 | + (tri (lambda () |
| 268 | + (if (= k 1) (fd d) (leg d k))))) |
| 269 | +
|
| 270 | +> (define (leg d k) |
| 271 | + (sier (/ d 2) (- k 1)) |
| 272 | + (penup) |
| 273 | + (fd d) |
| 274 | + (pendown)) |
| 275 | +``` |
| 276 | + |
| 277 | +`triangle` 函数是一个通用方法，它可以将某个绘图操作重复三次，每次操作后，都会让乌龟左转。`sier` 函数接受两个参数：一是长度 `d`，另一个是递归的深度 `k`。如果深度为 1，它就画一个简单的三角形；否则，它会调用 `leg` 函数来构建一个由三个小三角形组成的大三角形。`leg` 函数的功能是画一个谢尔宾斯基三角形的边，它首先递归调用 `sier` 函数来画出边的上半部分，然后移动乌龟到下一个顶点。而 `penup` 和 `pendown` 函数的作用是控制乌龟的画笔，使其在移动时可以选择是否画线。通过 `sier` 和 `leg` 的相互递归调用，我们可以得到以下效果： |
| 278 | + |
| 279 | +```scheme |
| 280 | +> (sier 400 6) |
| 281 | +``` |
| 282 | + |
| 283 | + |
0 commit comments