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

5星 · 超过95%的资源需积分: 47 88 浏览量更新于2024-07-21 收藏 3.42MB PDF 举报

"The Scheme of Programming Language.pdf 是一本由R. Kent Dybvig编著的关于Scheme编程语言的第四版教材，包含高清插图。读者可以通过提供的链接访问word版。本书旨在介绍和教授Scheme语言的基本概念、语法和高级特性。" 在《Scheme编程语言》第四版中，R. Kent Dybvig深入浅出地介绍了这个简洁而强大的Lisp方言。书中不仅包含了Scheme的基础知识，还涉及了高级编程技巧和概念。以下是书中的主要章节和知识点概述： 1. 引言（Introduction） - Section 1.1 Scheme语法：讲解了Scheme语言的基本语法结构，包括S-表达式、引号、注释等。 - Section 1.2 Scheme命名约定：讨论了变量命名的规则和最佳实践。 - Section 1.3 格式约定与符号约定：介绍了书中的排版和符号约定，帮助读者更好地理解示例。 2. 开始编程（Getting Started） - Section 2.1 与Scheme交互：介绍了如何启动Scheme解释器并进行交互式编程。 - Section 2.2 简单表达式：涵盖基本的算术和逻辑运算，以及常量和空列表。 - Section 2.3 评估Scheme表达式：解释了Scheme中的求值规则。 - Section 2.4 变量与let表达式：讲解了变量的作用域和let表达式的使用。 - Section 2.5 lambda表达式：介绍了函数定义，是Scheme中的核心概念。 - Section 2.6 顶级定义：讨论了在全局范围定义变量和函数的方法。 - Section 2.7 条件表达式：涵盖了if、cond和case等条件判断结构。 - Section 2.8 简单递归：介绍如何实现递归函数。 - Section 2.9 赋值：讲解了Scheme中的动态赋值和变量可变性。 3. 进阶（Going Further） - Section 3.1 语法扩展：介绍了如何通过宏系统来扩展Scheme的语法。 - Section 3.2 更多递归：深入讨论递归技术，如尾递归优化。 - Section 3.3 继续（Continuations）：解释了继续的概念，这是Scheme的一个强大特性，允许程序控制执行流程。 - Section 3.4 继续传递风格（Continuation Passing Style, CPS）：展示如何将程序转换为CPS形式，以利用继续的力量。 - Section 3.5 内部定义：讲解在函数内部定义变量和函数的机制。这本书对于初学者和有经验的程序员来说都是宝贵的资源，它不仅提供了全面的教程，也探讨了Scheme语言的深度和灵活性。通过学习这本书，读者可以掌握Scheme语言的核心概念，进一步探索函数式编程的世界。

 The names of procedures that convert an object of one type into an

object of another type are written as

type

, e.g., vector->list.

 The names of procedures and syntactic forms that cause side effects

end with an exclamation point ( ! ). These include set! and vector-

set!. Procedures that perform input or output technically cause side

effects, but their names are exceptions to this rule.

Programmers should employ these same conventions in their own code

whenever possible.

Section 1.3. Typographical and Notational Conventions

A standard procedure or syntactic form whose sole purpose is to perform

some side effect is said to return unspecified. This means that an

implementation is free to return any number of values, each of which can be

any Scheme object, as the value of the procedure or syntactic form. Do not

count on these values being the same across implementations, the same

across versions of the same implementation, or even the same across two

uses of the procedure or syntactic form. Some Scheme systems routinely use

a special object to represent unspecified values. Printing of this object is

often suppressed by interactive Scheme systems, so that the values of

expressions returning unspecified values are not printed.

While most standard procedures return a single value, the language supports

procedures that return zero, one, more than one, or even a variable number

of values via the mechanisms described in Section 5.8. Some standard

expressions can evaluate to multiple values if one of their subexpressions

evaluates to multiple values, e.g., by calling a procedure that returns

multiple values. When this situation can occur, an expression is said to

return "the values" rather than simply "the value" of its subexpression.

Similarly, a standard procedure that returns the values resulting from a call

to a procedure argument is said to return the values returned by the

procedure argument.

This book uses the words "must" and "should" to describe program

requirements, such as the requirement to provide an index that is less than

the length of the vector in a call to vector-ref. If the word "must" is used, it

means that the requirement is enforced by the implementation, i.e., an

exception is raised, usually with condition type &assertion. If the word

"should" is used, an exception may or may not be raised, and if not, the

behavior of the program is undefined.

The phrase "syntax violation" is used to describe a situation in which a

program is malformed. Syntax violations are detected prior to program

execution. When a syntax violation is detected, an exception of

type &syntax is raised and the program is not executed.

The typographical conventions used in this book are straightforward. All

Scheme objects are printed in a typewriter typeface, just as they are to be

typed at the keyboard. This includes syntactic keywords, variables, constant

objects, Scheme expressions, and example programs. An italic typeface is

used to set off syntax variables in the descriptions of syntactic forms and

arguments in the descriptions of procedures. Italics are also used to set off

technical terms the first time they appear. In general, names of syntactic

forms and procedures are never capitalized, even at the beginning of a

sentence. The same is true for syntax variables written in italics.

In the description of a syntactic form or procedure, one or more prototype

patterns show the syntactic form or forms or the correct number or numbers

of arguments for an application of the procedure. The keyword or procedure

name is given in typewriter font, as are parentheses. The remaining pieces of

the syntax or arguments are shown in italics, using a name that implies the

type of expression or argument expected by the syntactic form or procedure.

Ellipses are used to specify zero or more occurrences of a subexpression or

argument. For example, (or

expr

...) describes the or syntactic form,

which has zero or more subexpressions, and (member

obj

list

) describes

the member procedure, which expects two arguments, an object and a list.

A syntax violation occurs if the structure of a syntactic form does not match

its prototype. Similarly, an exception with condition type &assertion is

raised if the number of arguments passed to a standard procedure does not

match what it is specified to receive. An exception with condition

type &assertion is also raised if a standard procedure receives an argument

whose type is not the type implied by its name or does not meet other

criteria given in the description of the procedure. For example, the prototype

for vector-set! Is (vector-set!

vector

obj

)

Chapter 2. Getting Started

This chapter is an introduction to Scheme for programmers who are new to

the language. You will get more from this chapter if you are sitting in front

of an interactive Scheme system, trying out the examples as you go.

After reading this chapter and working the exercises, you should be able to

start using Scheme. You will have learned the syntax of Scheme programs

and how they are executed, along with how to use simple data structures and

control mechanisms.

Section 2.1. Interacting with Scheme

Most Scheme systems provide an interactive programming environment that

simplifies program development and experimentation. The simplest

interaction with Scheme follows a "read-evaluate-print" cycle. A program

(often called a read-evaluate-print loop, or REPL) reads each expression

you type at the keyboard, evaluates it, and prints its value.

With an interactive Scheme system, you can type an expression at the

keyboard and see its value immediately. You can define a procedure and

apply it to arguments to see how it works. You can even type in an entire

program consisting of a set of procedure definitions and test it without

leaving the system. When your program starts getting longer, it will be more

convenient to type it into a file (using a text editor), load the file and test it

interactively. In most Scheme systems, a file may be loaded with the

nonstandard procedure load, which takes a string argument naming the file.

Preparing your program in a file has several advantages: you have a chance

to compose your program more carefully, you can correct errors without

retyping the program, and you can retain a copy for later use. Most Scheme

implementations treat expressions loaded from a file the same as

expressions typed at the keyboard.

While Scheme provides various input and output procedures, the REPL

takes care of reading expressions and printing their values. This frees you to

concentrate on writing your program without worrying about how its results

will be displayed.

The examples in this chapter and in the rest of the book follow a regular

format. An expression you might type from your keyboard is given first,

possibly spanning several lines. The value of the expression is given after

剩余633页未读，继续阅读

Mushishi-银古

粉丝: 0
资源: 1

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

scheme语言学习资料集合

Programming Language Pragmatics Fourth Edition 英文原版 非扫描版

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

Write viterbi demodulator on c programming language

<render conf={scheme} {...{ on: listeners }} />

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

uri.append("scheme=").append(scheme).append(';') 这条语句在什么情况下会被使用

Intelligent Reflecting Surface-Aided Spectrum Sensing for Cognitive Radio

最新资源

Programming Language Pragmatics Fourth Edition 英文原版非扫描版