Scheme编程语言第四版精华概览

需积分: 10 170 浏览量更新于2024-07-21 收藏 2.77MB PDF 举报

"The Scheme Programming Language 4th Edition" 是一本由R. Kent Dybvig编写的关于Scheme编程语言的经典教材。本书旨在介绍Scheme语言的基本语法、特性以及高级概念，帮助读者深入理解函数式编程思想。在第一章"Introduction"中，作者首先介绍了Scheme的语法基础，包括其简洁的语法规则和命名约定。接着，书中详细阐述了用于表示程序结构的排版和符号约定，这是理解和编写Scheme代码的基础。第二章"Getting Started"引导读者进入Scheme的世界。这一章涵盖了与Scheme交互的基本方式，如解释器的使用，简单的表达式，以及Scheme表达式的求值规则。此外，还讲解了变量、let表达式、lambda表达式、顶级定义、条件表达式、简单递归和赋值操作等核心概念。第三章"Going Further"则深入探讨了Scheme的更多高级特性，如语法扩展、更复杂的递归形式、延续（continuations）和延续传递风格（Continuation-Passing Style），以及内部定义和库的使用，这些是Scheme语言灵活性和强大功能的体现。第四章"Procedures and Variable Bindings"聚焦于过程和变量绑定。本章详细讨论了变量引用、lambda表达式的新变种case-lambda，局部绑定机制，多值返回，变量定义以及赋值操作，这些都是 Scheme 中控制程序流程的关键元素。第五章"Control Operations"涉及控制结构的操作，包括过程调用的细节和控制流的管理，这些内容对于理解和编写复杂的Scheme程序至关重要。本书通过逐步引导的方式，让读者能够从基础到高级逐步掌握Scheme编程语言。对于那些对函数式编程感兴趣，特别是希望深入理解Scheme的程序员来说，这是一本不可多得的参考书。在线版本可在作者的官方网站上找到，方便读者随时查阅和学习。

(quote hello) hello

The symbol hello must be quoted in order to prevent Scheme from treating hello as a variable. Symbols

and variables in Scheme are similar to symbols and variables in mathematical expressions and equations.

When we evaluate the mathematical expression 1 - x for some value of x, we think of x as a variable. On the

other hand, when we consider the algebraic equation x

- 1 = (x - 1)(x + 1), we think of x as a symbol (in fact,

we think of the whole equation symbolically). Just as quoting a list tells Scheme to treat a parenthesized form

as a list rather than as a procedure application, quoting an identifier tells Scheme to treat the identifier as a

symbol rather than as a variable. While symbols are commonly used to represent variables in symbolic

representations of equations or programs, symbols may also be used, for example, as words in the

representation of natural language sentences.

You might wonder why applications and variables share notations with lists and symbols. The shared notation

allows Scheme programs to be represented as Scheme data, simplifying the writing of interpreters, compilers,

editors, and other tools in Scheme. This is demonstrated by the Scheme interpreter given in Section 12.7, which

is itself written in Scheme. Many people believe this to be one of the most important features of Scheme.

Numbers and strings may be quoted, too.

'2 2

'2/3 2/3

(quote "Hi Mom!") "Hi Mom!"

Numbers and strings are treated as constants in any case, however, so quoting them is unnecessary.

Now let's discuss some Scheme procedures for manipulating lists. There are two basic procedures for taking

lists apart: car and cdr (pronounced could-er). car returns the first element of a list, and cdr returns the

remainder of the list. (The names "car" and "cdr" are derived from operations supported by the first computer

on which a Lisp language was implemented, the IBM 704.) Each requires a nonempty list as its argument.

(car '(a b c)) a

(cdr '(a b c)) (b c)

(cdr '(a)) ()

(car (cdr '(a b c))) b

(cdr (cdr '(a b c))) (c)

(car '((a b) (c d))) (a b)

(cdr '((a b) (c d))) ((c d))

The first element of a list is often called the "car" of the list, and the rest of the list is often called the "cdr" of

the list. The cdr of a list with one element is (), the empty list.

The procedure cons constructs lists. It takes two arguments. The second argument is usually a list, and in that

case cons returns a list.

(cons 'a '()) (a)

(cons 'a '(b c)) (a b c)

(cons 'a (cons 'b (cons 'c '()))) (a b c)

(cons '(a b) '(c d)) ((a b) c d)

(car (cons 'a '(b c))) a

(cdr (cons 'a '(b c))) (b c)

(cons (car '(a b c))

(cdr '(d e f))) (a e f)

(cons (car '(a b c))

(cdr '(a b c))) (a b c)

Just as "car" and "cdr" are often used as nouns, "cons" is often used as a verb. Creating a new list by adding an

element to the beginning of a list is referred to as consing the element onto the list.

Notice the word "usually" in the description of cons's second argument. The procedure cons actually builds

pairs, and there is no reason that the cdr of a pair must be a list. A list is a sequence of pairs; each pair's cdr is

the next pair in the sequence.

The cdr of the last pair in a proper list is the empty list. Otherwise, the sequence of pairs forms an improper

list. More formally, the empty list is a proper list, and any pair whose cdr is a proper list is a proper list.

An improper list is printed in dotted-pair notation, with a period, or dot, preceding the final element of the

list.

(cons 'a 'b) (a . b)

(cdr '(a . b)) b

(cons 'a '(b . c)) (a b . c)

Because of its printed notation, a pair whose cdr is not a list is often called a dotted pair. Even pairs whose

cdrs are lists can be written in dotted-pair notation, however, although the printer always chooses to write

proper lists without dots.

'(a . (b . (c . ()))) (a b c)

The procedure list is similar to cons, except that it takes an arbitrary number of arguments and always

builds a proper list.

(list 'a 'b 'c) (a b c)

(list 'a) (a)

(list) ()

Section 6.3 provides more information on lists and the Scheme procedures for manipulating them. This might be

a good time to turn to that section and familiarize yourself with the other procedures given there.

Exercise 2.2.1

Convert the following arithmetic expressions into Scheme expressions and evaluate them.

a. 1.2 × (2 - 1/3) + -8.7

b. (2/3 + 4/9) ÷ (5/11 - 4/3)

c. 1 + 1 ÷ (2 + 1 ÷ (1 + 1/2))

d. 1 × -2 × 3 × -4 × 5 × -6 × 7

Exercise 2.2.2

Experiment with the procedures +, -, *, and / to determine Scheme's rules for the type of value returned by

each when given different types of numeric arguments.

Exercise 2.2.3

Determine the values of the following expressions. Use your Scheme system to verify your answers.

a. (cons 'car 'cdr)

b. (list 'this '(is silly))

c. (cons 'is '(this silly?))

d. (quote (+ 2 3))

Find the value of arg

Apply the value of procedure to the values of arg

... arg

For example, consider the simple procedure application (+ 3 4). The value of + is the addition procedure,

the value of 3 is the number 3, and the value of 4 is the number 4. Applying the addition procedure to 3 and 4

yields 7, so our value is the object 7.

By applying this process at each level, we can find the value of the nested expression (* (+ 3 4) 2). The

value of * is the multiplication procedure, the value of (+ 3 4) we can determine to be the number 7, and the

value of 2 is the number 2. Multiplying 7 by 2 we get 14, so our answer is 14.

This rule works for procedure applications but not for quote expressions because the subexpressions of a

procedure application are evaluated, whereas the subexpression of a quote expression is not. The evaluation

of a quote expression is more similar to the evaluation of constant objects. The value of a quote expression

of the form (quote object) is simply object.

Constant objects, procedure applications, and quote expressions are only three of the many syntactic forms

provided by Scheme. Fortunately, only a few of the other syntactic forms need to be understood directly by a

Scheme programmer; these are referred to as core syntactic forms. The remaining syntactic forms are syntactic

extensions defined, ultimately, in terms of the core syntactic forms. We will discuss the remaining core

syntactic forms and a few syntactic extensions in the remaining sections of this chapter. Section 3.1 summarizes

the core syntactic forms and introduces the syntactic extension mechanism.

Before we go on to more syntactic forms and procedures, two points related to the evaluation of procedure

applications are worthy of note. First, the process given above is overspecified, in that it requires the

subexpressions to be evaluated from left to right. That is, procedure is evaluated before arg

, arg

evaluated before arg

, and so on. This need not be the case. A Scheme evaluator is free to evaluate the

expressions in any order---left to right, right to left, or any other sequential order. In fact, the subexpressions

may be evaluated in different orders for different applications, even in the same implementation.

The second point is that procedure is evaluated in the same way as arg

... arg

. While

procedure is often a variable that names a particular procedure, this need not be the case. Exercise 2.2.3

had you determine the value of the expression ((car (list + - * /)) 2 3). Here, procedure is

(car (list + - * /)). The value of (car (list + - * /)) is the addition procedure, just as if

procedure were simply the variable +.

Exercise 2.3.1

Write down the steps necessary to evaluate the expression below.

((car (cdr (list + - * /))) 17 5)

Section 2.4. Variables and Let Expressions

Suppose expr is a Scheme expression that contains a variable var. Suppose, additionally, that we would like

var to have the value val when we evaluate expr. For example, we might like x to have the value 2 when

we evaluate (+ x 3). Or, we might want y to have the value 3 when we evaluate (+ 2 y). The following

examples demonstrate how to do this using Scheme's let syntactic form.

(let ((x 2))

(+ x 3)) 5

剩余361页未读，继续阅读

wangwangzwei

粉丝: 1
资源: 1

Scheme编程语言第四版精华概览

The Scheme Programming Language - R. Kent Dybvig.azw3

scheme 教材 by R. Kent Dybvig

The Scheme Programming Language, 4th Edition - R. Kent Dybvig

按照你的方法报的错误为2.html:1 Failed to launch 'sinaweibo://splash' because the scheme does not have a registered handler.，怎么解决

Write viterbi demodulator on c programming language

java.lang.IllegalArgumentException: Expected URL scheme 'http' or 'https' but no scheme was found for smartl...

Could not find a file system implementation for scheme 'hdfs'. The scheme is not directly supported by Flink and no Hadoop file system to support this scheme could be loaded

Error: scheme prefix missing from remote (e.g. "oci://")

下列选项中，()的主要组成部分是scheme、authority和path。 A.Uri B.ContentProvider C.ContentResolver D.ContentObserver

最新资源