Scheme
註釋

↑  https://small.r7rs.org/.
↑  .   [2024-12-09]. （原始内容存档于2025-01-19）.
↑  Alex Shinn. .   [2022-11-13]. （原始内容存档于2022-12-23）.
↑  .   [2022-11-13]. （原始内容存档于2022-09-27）.
↑  .   [2022-11-13]. （原始内容存档于2022-11-13）.
↑  .   [2024-12-14]. （原始内容存档于2025-01-14）.
↑  .   [2024-12-09]. （原始内容存档于2025-01-01）.
↑  .   [2021-11-09]. （原始内容存档于2022-04-23）.
↑  .   [2022-11-13]. （原始内容存档于2022-12-06）.
↑  .   [2022-11-13]. （原始内容存档于2022-12-06）.
↑  .   [2022-11-13]. （原始内容存档于2022-12-06）.
↑  .   [2022-11-13]. （原始内容存档于2022-11-28）.
↑  .   [2022-11-13]. （原始内容存档于2022-12-24）.
↑  .   [2023-12-17]. （原始内容存档于2023-12-17）.
↑  .   [2024-12-14]. （原始内容存档于2024-12-26）.
↑  .   [2024-12-13]. （原始内容存档于2025-01-24）.
↑  .   [2022-11-14]. （原始内容存档于2022-12-22）.
↑  .   [2022-11-13]. （原始内容存档于2022-12-09）.
↑  . MIT.   [2022-05-04]. （原始内容存档于2022-04-12）.
↑  Harold Abelson and Gerald Jay Sussman with Julie Sussman. . Cambridge, MA: MIT Press. 1996  [2011]. ISBN 0-262-01153-0. （原始内容存档于2018-03-09） （英语）.
1 2  . Community Scheme Wiki.   [2021-11-09]. （原始内容存档于2010-02-18）.
1 2  Will Clinger, Marc Feeley, Chris Hanson, Jonathan Rees and Olin Shivers. . Scheme Steering Committee. 2009-08-20  [2011-12-19]. （原始内容存档于2009-08-26）. Scheme has the unhappy distinction of being the world's most unportable programming language. It is almost misleading to call Scheme a "programming language;" it would be more accurate to characterise Scheme as a family of dialects, all loosely related by the common features of lexical scope, dynamic typing, list structure, higher-order functions, proper tail-recursion, garbage collection, macros, and (some form of) s-expression based lexical syntax.
↑  John McCarthy.  (PDF). Artificial Intelligence Laboratory, Stanford University. 12 February 1979  [2022-11-17]. （原始内容存档 (PDF)于2020-11-07）. To use functions as arguments, one needs a notation for functions, and it seemed natural to use the λ-notation of Church (1941). I didn’t understand the rest of his book, so I wasn’t tempted to try to implement his more general mechanism for defining functions. Church used higher order functionals instead of using conditional expressions. Conditional expressions are much more readily implemented on computers. 
David Turner（英语：）.  (PDF).   [2021-11-10]. （原始内容 (PDF)存档于2020-04-15）. LISP was not based on the lambda calculus, despite using the word “LAMBDA” to denote functions. At the time he invented LISP, McCarthy was aware of (Church 1941) but had not studied it. The theoretical model behind LISP was Kleene’s theory of first order recursive functions. (McCarthy made these statements, or very similar ones, in a contribution from the floor at the 1982 ACM symposium on LISP and functional programming in Pittsburgh. No written version of this exists, as far as know.)
↑  .   [2022-11-14]. （原始内容存档于2022-11-14）.
↑  Gerald J. Sussman, Guy L. Steele Jr. . 1998  [2021-11-07]. （原始内容存档于2022-04-06）. At about this time, Carl Hewitt was developing his theory of actors as a model of computation. This model was object-oriented and strongly influenced by Smalltalk. Every object was a computationally active entity capable of receiving and reacting to messages. The objects were called actors, and the messages themselves were also actors. Every computational entity was an actor and message-passing was the only means of interaction. An actor could have arbitrarily many acquaintances; that is, it could “know about” other actors and send them messages or send acquaintances as (parts of) messages. Hewitt then went on to model many traditional control structures as patterns of message-passing among actors. Functional interactions were modeled with the use of continuations; one might send the actor named “factorial” a message containing two other actors: the number 5 and another actor to which to send the eventually computed value (presumably 120). While Conniver made control points into first-class data, the actors model went to the logical extreme by making everything be first-class data.
↑  
Carl Hewitt, Peter Bishop, Irene Greif, Brian Smith, Todd Matson, Richard Steiger. . 1973  [2022-11-15]. （原始内容存档于2022-11-15）.  “For some years we have been constructing a series of languages to express our evolving understanding of the above semantic issues. The latest of these
is called PLANNER-73. ……

We shall assume that the reader is familiar with advanced pattern matching languages such as SNOBOL4, CONVERT, PLANNER-71, QA4, and POPLER.

We shall use (%A M%) to indicate sending the message M to the actor A. We shall use [s1 s2 … sn] to denote the finite squence s1, s2, … sn. ……

Identifiers can be created by the prefix operator =. ……

An expression (=> pattern body) is an abbreviation for (receive(message pattern) body) where receive is a more general actor that is capable of bindinq elements of the action in addition to the message.

Evaluating 

  (%(=> pattern body) the-message%), i.e. sending

  (=> pattern body) the-message,

will attempt to match the-message against pattern, If the-message is not of the form specified by pattern, then the actor is NOT-APPLICABLE to the-message. If the-message matches pattern, the body is evaluated.
……

Conceptually at least a new actor is created every time a message is sent. Consider sending to a target T a message M and a continuation C.

(send T
    (message M
        [#continuation C]))

The transmission (%T M%) is an abbreviation for the above where C is defaulted to be the caller. If target T is the following:
(receive
    (message the-body
        [#continuation =the-continuation])
    the-body)

then the the-body is evaluated in an environment where the-message is bound to M and the-continuation is bound to C.
……

Many actors who are executing in parallel can share the same continuation. They can all send a message [“return”] to the same continuation. ”

Irene Greif, Carl Hewitt. . 1975  [2022-11-15]. （原始内容存档于2022-11-15）.
↑  
Gerald J. Sussman, Guy L. Steele Jr. . 1998  [2021-11-07]. （原始内容存档于2022-04-06）. Hewitt and his students developed and implemented in Lisp a new language to make concrete the actor model of computation. This language was first called Planner-73 but the name was later changed to PLASMA (PLAnner-like System Modeled on Actors).
It was at this point that we (Sussman and Steele) put our heads together. (Steele had just become a graduate student at MIT, but he had been following this progression of language designs because he had had a part-time job at MIT Project MAC as one of the maintainers of MacLisp.) We wanted to better understand Hewitt’s actors model but were having trouble relating the actors model and its unusual terminology to familiar programming notions. We decided to construct a toy implementation of an actor language so that we could play with it. Using MacLisp as a working environment, we wrote a tiny Lisp interpreter and then added mechanisms for creating actors and sending messages. We wanted to better understand Hewitt’s actors model but were having trouble relating the actors model and its unusual terminology to familiar programming notions. We decided to construct a toy implementation of an actor language so that we could play with it. Using MacLisp as a working environment, we wrote a tiny Lisp interpreter and then added mechanisms for creating actors and sending messages.
↑  彼得·兰丁.  (PDF). 1964  [2022-11-17]. （原始内容存档 (PDF)于2022-11-16）. Also we represent the value of a λ-expression by a bundle of information called a "closure," comprising the λ-expression and the environment relative to which it was evaluated. We must therefore arrange that such a bundle is correctly interpreted whenever it has to be applied to some argument. More precisely:
  a closure has
    an environment part which is a list whose two items are:
      ⑴ an environment
      ⑵ an identifier or list of identifiers,
    and a control part which consists of a list whose sole item is an AE.
The value relative to E of a λ-expression X is represented by the closure denoted by
  constructclosure((E, bvX), unitlist(bodyX))
↑  
Joel Moses（英语：）.  (pdf). June 1970  [2009-10-27]. AI Memo 199. （原始内容存档于2010-05-23）. The use of free variables is a very powerful computational idea. In many situations it is possible to avoid using free variables by supplying a function with additional arguments. This can be quite cumbersome. ……
When a function uses free variables or when it calls functions which use them, then the value of this function is not completely determined by its arguments, since the value might depend on the values of the free variables. Thus in order to completely specify a computation, one has to specify a function and its arguments in addition to an environment in which the values of the free variables can be determined. ……
An important point which must be realized about functional arguments (abbreviated FUNARGs) is that two different environments are involved in such cases. The first environment is the one which is in effect when then FUNARG is bound as an argument. We shall call this the binding environment. The second environment is the one that is in effect when the FUNARG is activated as a function. We shall call this the activation environment. ……
Consider now what it would require for the system to restore the binding environment for functional arguments. It would require knowing where in the stack or "alist" the binding environment exists through some pointer to it. Supplying such pointer is a function FUNCTION in LISP. That is when one transmits a functional argument f which is to be evaluated in its binding environment, then one uses FUNCTION(f). FUNCTION will prevent its argument f from being evaluated, just as QUOTE would. The result of FUNCTION will be a structure which not only contains a reference to the function f, but also contains a pointer to the binding environment. Thus at the FUNARG's activation time we will be able to use the current place in the stack up to the point where the binding environment exists, thus skipping over any values in the activation environment which differ from those in the binding environment. ……
The points we have made so far are:
1) Free variables in function definitions require that one must have an environment in order to be able to evaluate a function.
2) When one uses functional arguments, the the question arises as to which environment one chooses in order to evaluate the function, the binding environment or the activation environment.
3) When one returns functions (which require the values of free variables for their evaluation) then one must, in general, save the binding environment and thus create a stack which is, in fact, a tree. ……
LISP allows the user to choose between the binding environment and the activation environment by allowing a function to be bound with FUNCTION or with QUOTE. QUOTE will force the activation environment to be used in evaluating the function. A useful metaphor for the difference between FUNCTION and QUOTE in LISP is to think of QUOTE as a porous or an open covering of the function since free variables escape to the current environment. FUNCTION acts as a closed or nonporous covering (hence the term "closure" used by Landin). Thus we talk of "open" Lambda expressions (functions in LISP are usually Lambda expressions) and "closed" Lambda expressions. ……
My interest in the environment problem began while Landin, who had a deep understanding of the problem, visited MIT during 1966-67. I then realized the correspondence between the FUNARG lists which are the results of the evaluation of "closed" Lambda expressions in LISP and ISWIM's Lambda Closures.
↑  
Gerald J. Sussman, Guy L. Steele Jr. . 1998  [2021-11-07]. （原始内容存档于2022-04-06）. Sussman had just been studying Algol. He suggested starting with a lexically scoped dialect of Lisp, because that seemed necessary to model the way names could refer to acquaintances in PLASMA. Lexical scoping would allow actors and functions to be created by almost identical mechanisms. Evaluating a form beginning with the word lambda would capture the current variable-lookup environment and create a closure; evaluating a form beginning with the word alpha would also capture the current environment but create an actor. Message passing could be expressed syntactically in the same way as function invocation. The difference between an actor and a function would be detected in the part of the interpreter traditionally known as apply. A function would return a value, but an actor would never return; instead, it would typically invoke a continuation, another actor that it knew about. Our interpreter also provided the necessary primitives for implementing the internal behavior of primitive actors, such as an addition operator that could accept two numbers and a continuation actor.
1 2  Gerald J. Sussman, Guy L. Steele Jr. . 1998  [2021-11-07]. （原始内容存档于2022-04-06）. This led us to three important ideas:
• First, we realized that all the patterns of control structure that Hewitt had described in terms of actors could equally well be described by the λ-calculus. ……
• Second, we realized that the λ-calculus — a small, simple formalism — could serve as the core of a powerful and expressive programming language. (Lisp had adopted the λ-notation for functions but had failed to support the appropriate behavior for free variables. The original theoretical core of Lisp was recursion equations, not the λ-calculus.) ……
• Third, we realized that in our quest for the “ultimate AI language” we had come full circle. As the MIT school had struggled to find more and more powerful ways to express and manipulate control structure to support heuristic search, we had progressed from Lisp to CONVERT to Planner to Conniver to PLASMA to a simple variation of Lisp!
↑  Gerald J. Sussman, Guy L. Steele Jr..  . 维基文库. 1975 （英文）. Inspired by ACTORS [Greif and Hewitt][Smith and Hewitt], we have implemented an interpreter for a LISP-like language, SCHEME, based on the lambda calculus [Church], but extended for side effects, multiprocessing, and process synchronization. The purpose of this implementation is tutorial. We wish to:
⑴ alleviate the confusion caused by Micro-PLANNER（英语：）, CONNIVER, etc. by clarifying the embedding of non-recursive control structures in a recursive host language like LISP.
⑵ explain how to use these control structures, independent of such issues as pattern matching and data base manipulation.
⑶ have a simple concrete experimental domain for certain issues of programming semantics and style. 
.   [2022-11-14]. （原始内容存档于2022-11-14）.
↑  Gerald J. Sussman, Guy L. Steele Jr. . 1998  [2021-11-07]. （原始内容存档于2022-04-06）. We were very pleased with this toy actor implementation and named it “Schemer” because we thought it might become another AI language in the tradition of Planner and Conniver. However, the ITS operating system had a 6-character limitation on file names and so the name was truncated to simply SCHEME and that name stuck.
↑  Gerald J. Sussman, Guy L. Steele Jr. . 1998  [2021-11-07]. （原始内容存档于2022-04-06）. We concluded that actors and closures were effectively the same concept. (Hewitt later agreed with this, but noted that two types of primitive actors in his theory, namely cells (which have modifiable state) and synchronizers (which enforce exclusive access), cannot be expressed as closures in a lexically scoped pure Lisp without adding equivalent primitive extensions.) 
Carl Hewitt（英语：）. . 2009  [2022-12-23]. （原始内容存档于2022-12-23）. In summary, Sussman and Steele [1975] mistakenly concluded “we discovered that the 'Actors' and the lambda expressions were identical in implementation.” The actual situation is that the λ-calculus is capable of expressing some kinds of sequential and parallel control structures but, in general, not the concurrency expressed in the Actor model. On the other hand, the Actor model is capable of expressing everything in the λ-calculus and more [Hewitt 2008f].
↑  Guy L. Steele Jr., Gerald J. Sussman.  (PDF). 1978  [2022-11-18]. （原始内容存档 (PDF)于2022-12-12）. SCHEME is a dialect of LISP. It is an expression-oriented, applicative order, interpreter-based language which allows one to manipulate programs as data. It differs from most current dialects of LISP in that it closes all lambda-expressions in the environment of their definition or declaration, rather than in the execution environment. This has the consequence that variables are normally lexically scoped, as in ALGOL. However, in contrast with ALGOL, SCHEME treats procedures as a first-class data type. They can be the values of variables, the returned values of procedures, and components of data structures. Another difference from LISP is that SCHEME is implemented in such a way that tail-recursions execute without net growth of the interpreter stack. The effect of this is that a procedure call behaves like a GOTO and thus procedure calls can be used to implement iterations, as in PLASMA.
↑  
Gerald J. Sussman, Guy L. Steele Jr. . 1998  [2021-11-07]. （原始内容存档于2022-04-06）. We were actually trying to build something complicated and discovered, serendipitously, that we had accidentally designed something that met all our goals but was much simpler than we had intended. 
We thought that Scheme would turn out to be the next in a long series of programming languages that had been designed at MIT over the course of 17 years. ……
In this process we learned some great lessons. The λ-calculus can be seen as a universal glue by which compound constructs can be built inductively from simpler ones and a set of primitives. …… The essence of the matter is that the λ-calculus provides a way of abstracting entities of any particular type and then combining such abstractions with other entities to make new entities of that same type, which are instances of the abstractions. …… Given the right primitives, the λ-calculus can serve as a foundation for the abstraction and instantiation of virtually any kind of complex conceptual structure.
We also were struck by the great importance of names as a means of reference. …… Naming seems to correspond to some important cognitive mechanism that is, if not innate, then at least extremely well-developed in our culture. The λ-calculus embodies a provably coherent theory of naming.
↑  .   [2021-11-07]. （原始内容存档于2022-01-12）.
↑  Gerald J. Sussman, Guy L. Steele Jr..  . 维基文库. 1975 （英文）.
↑  Gerald J. Sussman, Guy L. Steele Jr. . 1976  [2021-11-11]. （原始内容存档于2022-04-10）.
↑  Guy L. Steele Jr. . 1976  [2021-11-10]. （原始内容存档于2022-04-09）.
↑  Guy L. Steele Jr. . 1977  [2021-11-07]. （原始内容存档于2022-05-09）.
↑  Gerald J. Sussman, Guy L. Steele Jr. . 1978  [2021-11-07]. （原始内容存档于2021-11-07）.
↑  Guy L. Steele Jr. . 1978  [2021-11-07]. （原始内容存档于2021-11-08）. 
.   [2022-11-15]. （原始内容存档于2021-12-03）.
↑  Gerald J. Sussman, Guy L. Steele Jr. . 1979  [2021-11-07]. （原始内容存档于2021-11-07）.
↑  Guy L. Steele Jr. . Patrick Henry Winston, Richard H. Brown  (编). . 1979: 399–432  [2022-12-07]. （原始内容存档于2022-12-07）.
↑  Gerald J. Sussman, Guy L. Steele Jr. . 1980  [2021-11-07]. （原始内容存档于2021-11-08）.
↑  J.W. Backus; F.L. Bauer; J.Green; C. Katz; J. McCarthy P. Naur;  et al. . Numerische Mathematik, Communications of the ACM, and Journal of the British Computer Society. January–April 1960  [2012-08-09]. （原始内容存档于2007-06-25）.
1 2  .   [2022-01-14]. （原始内容存档于2021-03-04）.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17  Richard Kelsey, William Clinger（英语：）, Jonathan Rees;  et al. . Higher-Order and Symbolic Computation. August 1998, 11 (1): 7–105  [2007-01-04]. doi:10.1023/A:1010051815785. （原始内容存档于2007-01-05） （英语）. Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy Lewis Steele Jr. and Gerald Jay Sussman. It was designed to have an exceptionally clear and simple semantics and few different ways to form expressions. A wide variety of programming paradigms, including imperative, functional, and message passing styles, find convenient expression in Scheme.  引文格式1维护：显式使用等标签 (link)
1 2 3  Michael Sperber, R. Kent Dybvig, Matthew Flatt（英语：）, Anton Van Straaten;  et al. . Scheme Steering Committee. August 2007  [2009-10-20]. （原始内容存档于2013-06-25）. This report is accompanied by a report describing standard libraries; references to this document are identified by designations such as “library section” or “library chapter”. It is also accompanied by a report containing non-normative appendices. A fourth report gives some historical background and rationales for many aspects of the language and its libraries.  引文格式1维护：显式使用等标签 (link)
↑  . Scheme Steering Committee. 2007-09-26  [2011-12-19]. （原始内容存档于2010-04-09）.
↑  . Scheme Steering Committee. 2007  [2009-10-20]. （原始内容存档于2008-12-04）.
↑  Marc Feeley (compilation). . Scheme Steering Committee, r6rs-discuss mailing list. 2007-10-26  [2009-10-20]. （原始内容存档于2008-08-20）.
↑  .   [2022-11-13]. （原始内容存档于2022-12-17）.
↑  Alex Shinn, John Cowan（英语：）, Arthur A. Gleckler;  et al.  (PDF). 2022-09-06  [2022-11-13]. （原始内容存档 (PDF)于2022-11-13）.  引文格式1维护：显式使用等标签 (link)
.   [2021-11-10]. （原始内容存档于2023-01-01）.
↑  .   [2022-11-13]. （原始内容存档于2022-11-13）.
↑  .   [2022-11-13]. （原始内容存档于2022-12-17）.
↑  . 2020-03-17  [2022-11-13]. （原始内容存档于2022-11-13）. The Revised7 Report on the Algorithmic Language Scheme (“R7RS”) intentionally describes a small language, suitable for implementing on reduced hardware, or for experiments in programming language design and implementation.
However, Scheme is used for practical programming, and there a minimal language is not a help. Additional data structures and programming idioms make the programmer’s job easier (if they are well-designed!). Therefore, as part of the R7RS design process, it was agreed that a subsequent report would appear on “R7RS-Large”, a collection of Scheme libraries that are useful across a wide variety of problems.
The decision of what was to appear in R7RS-Large was left to the community, and a strategy was adopted: proposals were published as SRFIs (Scheme Requests For Implementation, http://srfi.schemers.org), and the community would then vote on which would be adopted.
As a result, R7RS-Large will be developed in several stages, depending upon the support from the community for each proposal. At each stage, several SRFIs are frozen, and implementers and users may then rely upon those libraries being in the final product. (In a few cases, a library might be revisited, with a subsequent stage adopting a completely backward-compatible new version of that library; this has already happened with generators.)
When this process has completed, the resulting interim reports will be collated and reorganized into a final document.
1 2 3 4  William Clinger（英语：）.  (PDF). 1985  [2022-11-17]. （原始内容存档 (PDF)于2022-10-17）. Data and procedures and the values they amass, Higher-order functions to combine and mix and match, Objects with their local state, the message they pass, A property, a package, the control of point for a catch － In the Lambda Order they are all first-class. One thing to name them all, one things to define them, one thing to place them in environments and bind them, in the Lambda Order they are all first-class. ……
Scheme shares with Common Lisp the goal of a core language common to several implementations. Scheme differs from Common Lisp in its emphasis upon simplicity and function over compatibility with older dialects of Lisp.
↑  Gerald J. Sussman, Guy L. Steele Jr. . 1978. System-Provided Extensions － Some standard syntactic extension are provided by convenience in ordinary programming. They are distinguished from other magic words in that they are semantically defined in terms of others rather then being primitive {Note FEXPR（英语：）s Are Okay by Us}. For expository purposes they are described here pattern-matching/production-rules kind of language. takes advantage of the definition of list notation: (A B C) = (A . (B . (C . NIL))). Thus the pattern (x . r) matches (A B C), with x = A and r = (B C). the ordering of the "productions" is significant; the first one which matches is to be used.
↑  Kent M. Pitman（英语：）. . 1983, 2007  [2022-12-16]. （原始内容存档于2022-12-16）. In the interpreter “variables” are implemented as atomic symbols which possess “shallow-bound” value cells. The continual manipulation of value cells would decrease the efficiency of compiled code, so the compiler defines two types of variables: “special variables” and “local variables.” Special variables are identical to variables in the interpreter.
Local variables are more like the variables in commonly-used algebraic programming languages such as Algol or PL/I. A local variable no longer has an associated atomic symbol; thus it can only be referred to from the text of the same function that bound it. The compiler creates local variables for PROG variables, DO variables, and LAMBDA variables, unless directed otherwise. The compiled code stores local variables in machine registers or in locations within a stack.
The principal difference between local variables and special variables is in the way a binding of a variable is compiled. (A binding has to be compiled when a PROG, DO, or LAMBDA expression is compiled, and for the entry to a function which has LAMBDA variables to be bound to its arguments.) If the variable to be bound has been declared to be special, the binding is compiled as code to imitate the way the interpreter binds variables: the value of the atomic symbol is saved and a new value is stored into its value cell. If the variable to be bound has not been declared special, the binding is compiled as the declaration of a new local variable. Code is generated to store the value to which the variable is to be bound into the register or stack-location assigned to the new local variable. This runs considerably faster than a special binding.
Although a special variable is associated with an atomic symbol which has the name of the variable, the name of a local variable appears only in the input file － in compiled code there is no connection between local variables and atomic symbols. Because this is so, a local variable in one function may not be used as a “free variable” in another function since there is no way for the location of the variable to be communicated between the two functions.
When the usage of a variable in a program to be compiled does not conform to these rules, i.e. it is somewhere used as a “free variable,” the variable must be declared special. There are two common cases in which this occurs. One is where a “global” variable is being used, i.e. a variable which is SETQ'ed by many functions but is never bound. The other is where two functions cooperate, one binding a variable and then calling the other one which uses that variable as a free variable.  请检查|date=中的日期值 (帮助)
1 2  
Gerald J. Sussman, Guy L. Steele Jr..  . 维基文库. 1975 （英文）. There are several important consequences of closing every lambda expression in the environment from which it is passed (i.e., in its "lexical" or "static" environment). 
First, the axioms of lambda calculus are automatically preserved. Thus, referential transparency（英语：） is enforced. This in turn implies that there are no "fluid" variable bindings (as there are in standard stack implementations of LISP such as MacLISP). 
Second, the upward funarg problem（英语：） [Moses] requires that the environment structure be potentially tree-like. 
Finally, the environment at any point in a computation can never be deeper than the lexical depth of the expression being evaluated at that time; i.e., the environment contains bindings only for variables bound in lambdas lexically surrounding the expression being evaluated. This is true even if recursive functions are involved. ……Furthermore, it is not even necessary to scan the environment for the variable, since its value must be in a known position relative to the top of the environment structure; this position can be computed by a compiler at compile time on the basis of lexical scope.