【Scheme】Scheme 编程学习 (二) —— 基础

文接前一节内容 :
【Scheme】Scheme 编程学习(一) —— 概述

本文章可以跟视频课程一起看，做了一些补充说明

原视频地址：

Bilibili https://www.bilibili.com/video/BV1Kt411R7Wf/?p=2&spm_id_from=pageDriver

文章目录

【Scheme】Scheme 编程学习 (二) —— 基础
- I - 概述
- II - 数据结构
- - 2.1 - 点对 Pairs
  - 2.2 - 表 Lists
  - - 2.2.1 - 单元素表和空表
    - 2.2.2 - 复合操作
    - 2.2.3 - list 过程
- III - Loops
- IV - 两种特殊的过程
- - 4.1 - Map
  - 4.2 - Fold
- V - 注意事项

I - 概述

本节主要介绍 Scheme 的基础，包含以下四个部分：

两种数据结构点对 (Pairs) 和表 (Lists)，以及如何创建
Loops
两种特殊的过程 (Procedures) Map 与 Fold
注意

Scheme 是一种函数式编程语言，什么意思呢？就是说它的参数可以为函数，返回值为函数，而且必须有返回值，若没有返回值，则接连的函数式无法继续执行下去。前一个函数的结果为后一个函数的参数。

而且 Scheme 是一种脚本语言，也就是类似 Python 需要解释器。不同于编译语言和伪编译语言。

II - 数据结构

2.1 - 点对 Pairs

(cons 1 2)

上述代码是调用过程 (Procedure) 的方式，( + 过程名称 + 参数 + ) ，过程与函数类似，调用过程可以理解为调用函数，这里过程名为 cons 用于创建点对，此调用结果为：

(1 . 2)

也可以使用嵌套的过程

(cons (cons 1 2) 3)
; ((1 . 2) . 3)

定义符号 (Symbol)，使用 define 过程，定义符号 foo 为点对 (1 . 2)

(define foo (cons 1 2))
foo
; 检查 foo 输出 (1 . 2)

点对包含两个域 car 和 cdr

有两个同名的过程：
car 获取数据对象中的第一个元素
cdr 获取数据对象中的第二个元素

(car foo)
; 1
(cdr foo)
; 2

符号 foo 中第一个元素为 1 ，foo 中第二个元素为 2，car / cdr 过程不一定获取的是数据对象中的单个元素，也可以是复合的结构。

2.2 - 表 Lists

2.2.1 - 单元素表和空表

我们使用前一小节点对中的 cons 过程，构建一个特殊的点对，它的两个域，一个为 1 ，另一个为 null 也就是空，得到只有一个元素的点对，也是只包含一个元素的表。

(cons 1 null)
; (1)

定义 bar 符号为只有一个元素的点对，对其进行 car, cdr 操作

(define bar (cons 1 null))
bar
; 检测 bar 得到结果 (1)(car bar)
; 1
(cdr bar)
; ()

空的括号 () 是另一种表示 null 的形式，也是一个不包含任何元素的表。也就是说任何一个表最后一个元素都为 null 。

当我们对解释器输入这个特殊的符号 null 时，我们同样得到空表

null
; ()

2.2.2 - 复合操作

(cons 1 (cons 2 null))
; (1 2)

创建一个包含 2 和 null 的点对，接着创建一个点对元素为 1 和刚刚创建的点对。获得一个点对 (1 2)，但解释器表示为包含元素为 1 和 2 的表，也就是说表结构为很多点对的集合。

(cons 1 (cons 2 (cons 3 null)))
; (1 2 3)

使用 (cons 2 (cons 3 null)) 可以获得一个包含 2 和 3 的表，使用结果作为右域与元素 1 创建点对，得到一个包含元素为 1 2 3 的表。

定义一个符号 mylist 为包含元素 1 2 3 的表

(define mylist (cons 1 (cons 2 (cons 3 null))))mylist
;(1 2 3)(car mylist)
;1(cdr mylist)
;(2 3)

对 mylist 应用 car 得到此表的第一个元素
对 mylist 应用 cdr 则得到所有剩下的元素

(cadr mylist)
; 2

cadr 表示首先进行 cdr ，然后进行 car
即

(car (cdr mylist))

cdr mylist 得到子表 (sublist) ：(2 3)
接着对此子表应用 car，也就是获取此子表的第一个元素，即 2

同样的

(caddr mylist)
; 结果为 3

cdr mylist 为 (2 3) ，对结果再次 cdr 为 3，car 此结果即为 3

速记：复合的左右域操作，顺序为从右向左。

2.2.3 - list 过程

我们也可以使用前一篇文章中见到的 list 过程来创建表。

(equal? (list 1 2 3) mylist)

过程 list 用于构建表，equal? 用于比较两个元素内容是否相等，比较使用 list 过程构建的表和使用 cons 构建的表是否相同，得到结果

#t

在 Scheme 中布尔值有两个 #t 和 #f , #t 表示 true, #f 表示 false

注意跟 C 语言或其他编程语言不一样的是
if (0) 与 if (#f) 不等价 if (0) 会进入 if 分支，if (#f) 则不会，

(list-ref lst n)

list-ref 是一个用于获取表中第 n 个元素的过程

(list-ref (list "a" "b" "c") 1)
; "b"
(list-ref (list "a" "b" "c") 2)
; "c"

list-ref 过程有两个参数，第一个参数为表，第二个参数为表中的第 n 个元素，与 C 语言相同，计数从 0 开始，当计数为 1 时，获取表中第二个元素，即 "b" ，当计数为 2 时，则获取表中第三个元素，也就是 "c" 。

III - Loops

如何简略地实现 list-ref 过程？

(define (my-list-ref lst n)(if (zero? n) ; 如果 n 为 0 (car lst) ; 返回 lst 的第一个元素(my-list-ref (cdr lst) (- n 1)))); 否则进行递归操作，获取 lst 除第一个意外子表的第 n-1 个元素 (my-list-ref (list "a" "b" "c") 1)
; "b"
(my-list-ref (list "a" "b" "c") 2)
; "c"

调用实现方式比较粗糙的 my-list-ref 过程，在参数相同时，得到相同的运行结果

此种实现方式被称为 “Loops” ，在其他的编程语言中称为 loop（循环）或 recursion（递归）

IV - 两种特殊的过程

4.1 - Map

(map procedure lst)
map 过程对参数表 lst 中的每一个元素应用过程 procedure 。

; 定义一个符号 baz 内容为包含 1 2 3 三个元素的表
(define baz (list 1 2 3))
; 定义一个过程 double ，结果为入参乘以 2
(define (double x) (* x 2))(map double baz)
; (2 4 6)

对表 (1 2 3) 中的每一个元素应用 double 过程得到结果 (2 4 6)

; 定义一个过程 double-all
(define (double-all x) (map double x))(double-all baz)
; (2 4 6)

这次只需要调用一个过程就可以得到相同的结果。

那么我们如何简略地实现 map 过程呢？

(define (my-map fn lst)(if (null? lst)null(cons (fn (car lst)) (my-map fn (cdr lst)))))(my-map double baz)
; (2 4 6)

my-map 的实现也是通过构建递归，首先如果为空则返回空，

if (null? lst)null

判断是否为空返回 null ，这里这里不仅是特殊情况处理，也是递归结束条件，如果处理到最后一个元素 (根据本文前面的内容，list 的最后一个元素为 null)，则返回 null 结束

不为空就会创建一个点对，此处应用到了 2.2 节中可以使用 cons 过程创建 list (表) 的内容

(cons (fn (car lst)) (my-map fn (cdr lst)))

生成表第一个元素为对表的第一个元素应用 fn ，(cdr lst) 获取除了第一个元素外，lst 中剩余的所有元素因此，生成表的第二个元素也会获取原表第二个元素，并对此元素应用 fn ，依次类推。即对表中的所有元素都应用了 fn 。

4.2 - Fold

(define qux (list 1 2 3 4))
; 定义符号 qux 内容为 (1 2 3 4) 的表(foldr + 0 qux)
; 结果为 10

调用 foldr 过程有三个入参， + 0 qux，0 为起始元素，然后将 0 与 qux 中的元素从后向前依次累加，即：

0 + 4
4 + 3
7 + 2
9 + 1

结果为 10

foldr 表示 fold up 堆叠，从最后一个元素开始一个一个叠起来。
有一些类似 C++ 标准库的 std::accumulate 函数，累加需要指定初始值，因此

; 指定初始值为 2000
(foldr + 2000 qux)
; 结果为 2010

foldr 不仅可以指定累加还可以指定其他过程，如

(foldr * 1 qux)
; 结果为 24

计算过程为：

1 * 4
4 * 3
12 * 2
24 * 1

结果为 24

同理

(foldr * 0 qux)
; 0

对于 map 同样的操作，我们如何实现 foldr

(define (my-foldr fn start lst)(if (null? lst)start(fn (car lst) (my-foldr fn start (cdr lst)))))(my-foldr + 0 qux)
; 10
(my-foldr * 1 qux)
; 24

首先判断是否为 null 与 my-map 一样，既是特殊情况处理，又是结束条件，返回 start

(fn (car lst) (my-foldr fn start (cdr lst)))

其他情况返回计算 fn (第一个元素，剩余元素与 start 元素fn 的结果) 。剩余元素仍然是 lst 则返回第二个元素与剩余元素加 start 元素 fn 的结果…

以此类推，递归到最后一个元素时，则计算最后一个元素与 start 元素 fn 的结果。并返回上层调用，计算倒数第二个元素与这个结果的 fn 的值，然后返回更上一层调用…

举例如果 lst 表中有两个元素 (1 2) ， fn 为 +

则递归过程展开

(+ 1 (my-foldr + start (cdr lst)))
; 再展开
(+ 1 (+ 2 start))
; 即 start + 2 + 1

V - 注意事项

mzscheme 称空为 null ，其实是 nil

(define nil null)