Scheme is a
dialect
The term dialect (from Latin , , from the Ancient Greek word , 'discourse', from , 'through' and , 'I speak') can refer to either of two distinctly different types of Linguistics, linguistic phenomena:
One usage refers to a variety (linguisti ...
of the
Lisp
A lisp is a speech impairment in which a person misarticulates sibilants (, , , , , , , ). These misarticulations often result in unclear speech.
Types
* A frontal lisp occurs when the tongue is placed anterior to the target. Interdental lisping ...
family of
programming language
A programming language is a system of notation for writing computer programs. Most programming languages are text-based formal languages, but they may also be graphical. They are a kind of computer language.
The description of a programming ...
s. Scheme was created during the 1970s at the
MIT AI Lab
Computer Science and Artificial Intelligence Laboratory (CSAIL) is a research institute at the Massachusetts Institute of Technology (MIT) formed by the 2003 merger of the Laboratory for Computer Science (LCS) and the Artificial Intelligence La ...
and released by its developers,
Guy L. Steele
Guy Lewis Steele Jr. (; born October 2, 1954) is an American computer scientist who has played an important role in designing and documenting several computer programming languages and technical standards.
Biography
Steele was born in Missouri ...
and
Gerald Jay Sussman, via a series of memos now known as the
Lambda Papers The history of the programming language Scheme begins with the development of earlier members of the Lisp family of languages during the second half of the twentieth century. During the design and development period of Scheme, language designers ...
. It was the first dialect of Lisp to choose
lexical scope and the first to require implementations to perform
tail-call optimization
In computer science, a tail call is a subroutine call performed as the final action of a procedure. If the target of a tail is the same subroutine, the subroutine is said to be tail recursive, which is a special case of direct recursion. Tail recur ...
, giving stronger support for functional programming and associated techniques such as recursive algorithms. It was also one of the first programming languages to support
first-class continuations. It had a significant influence on the effort that led to the development of
Common Lisp
Common Lisp (CL) is a dialect of the Lisp programming language, published in ANSI standard document ''ANSI INCITS 226-1994 (S20018)'' (formerly ''X3.226-1994 (R1999)''). The Common Lisp HyperSpec, a hyperlinked HTML version, has been derived fro ...
.
[Common LISP: The Language, 2nd Ed., Guy L. Steele Jr. Digital Press; 1981. . "Common Lisp is a new dialect of Lisp, a successor to MacLisp, influenced strongly by ZetaLisp and to some extent by Scheme and InterLisp."]
The Scheme language is standardized in the official
IEEE
The Institute of Electrical and Electronics Engineers (IEEE) is a 501(c)(3) professional association for electronic engineering and electrical engineering (and associated disciplines) with its corporate office in New York City and its operation ...
standard
[1178-1990 (Reaff 2008) IEEE Standard for the Scheme Programming Language. IEEE part number STDPD14209]
unanimously reaffirmed
at a meeting of the IEEE-SA Standards Board Standards Review Committee (RevCom), March 26, 2008 (item 6.3 on minutes), reaffirmation minutes accessed October 2009. NOTE: this document is only available for purchase from IEEE and is not available online at the time of writing (2009). and a ''de facto'' standard called the ''Revised Report on the Algorithmic Language Scheme'' (R''n''RS). A widely implemented standard is R5RS (1998).
The most recently ratified standard of Scheme is "R7RS-small" (2013).
The more expansive and modular R6RS was ratified in 2007.
Both trace their descent from R5RS; the timeline below reflects the chronological order of ratification.
History
Origins
Scheme started in the 1970s as an attempt to understand
Carl Hewitt's
Actor model
The actor model in computer science is a mathematical model of concurrent computation that treats ''actor'' as the universal primitive of concurrent computation. In response to a message it receives, an actor can: make local decisions, create more ...
, for which purpose Steele and Sussman wrote a "tiny Lisp interpreter" using
Maclisp and then "added mechanisms for creating actors and sending messages".
Scheme was originally called "Schemer", in the tradition of other
Lisp
A lisp is a speech impairment in which a person misarticulates sibilants (, , , , , , , ). These misarticulations often result in unclear speech.
Types
* A frontal lisp occurs when the tongue is placed anterior to the target. Interdental lisping ...
-derived languages such as
Planner
Planner may refer to:
* A personal organizer (book) for planning
* Microsoft Planner
* Planner programming language
* Planner (PIM for Emacs)
* Urban planner
* Route planner
* Meeting and convention planner
* Japanese term for video game de ...
or ''Conniver''. The current name resulted from the authors' use of the
ITS operating system, which limited filenames to two components of at most six characters each. Currently, "Schemer" is commonly used to refer to a Scheme programmer.
R6RS
A new language standardization process began at the 2003 Scheme workshop, with the goal of producing an R6RS standard in 2006. This process broke with the earlier R''n''RS approach of unanimity.
R6RS features a standard module system, allowing a split between the core language and libraries. A number of drafts of the R6RS specification were released, the final version being R5.97RS. A successful vote resulted in the ratification of the new standard, announced on August 28, 2007.
[
Currently the newest releases of various Scheme implementations] support the R6RS standard. There is a portable reference implementation of the proposed implicitly phased libraries for R6RS, called psyntax, which loads and bootstraps itself properly on various older Scheme implementations.
A feature of R6RS is the record-type descriptor (RTD). When an RTD is created and used, the record type representation can show the memory layout. It also calculated object field bit mask and mutable Scheme object field bit masks, and helped the garbage collector know what to do with the fields without traversing the whole fields list that are saved in the RTD. RTD allows users to expand the basic RTD to create a new record system.
R6RS introduces numerous significant changes to the language. The source code is now specified in Unicode
Unicode, formally The Unicode Standard,The formal version reference is is an information technology Technical standard, standard for the consistent character encoding, encoding, representation, and handling of Character (computing), text expre ...
, and a large subset of Unicode characters may now appear in Scheme symbols and identifier
An identifier is a name that identifies (that is, labels the identity of) either a unique object or a unique ''class'' of objects, where the "object" or class may be an idea, physical countable object (or class thereof), or physical noncountable ...
s, and there are other minor changes to the lexical rules. Character data is also now specified in Unicode. Many standard procedures have been moved to the new standard libraries, which themselves form a large expansion of the standard, containing procedures and syntactic forms that were formerly not part of the standard. A new module system has been introduced, and systems for exception handling are now standardized. Syntax-rules has been replaced with a more expressive syntactic abstraction facility (syntax-case) which allows the use of all of Scheme at macro expansion time. Compliant implementations are now ''required'' to support Scheme's full numeric tower, and the semantics of numbers have been expanded, mainly in the direction of support for the IEEE 754
The IEEE Standard for Floating-Point Arithmetic (IEEE 754) is a technical standard for floating-point arithmetic established in 1985 by the Institute of Electrical and Electronics Engineers (IEEE). The standard addressed many problems found i ...
standard for floating point numerical representation.
R7RS
The R6RS standard has caused controversy because some see it as a departure from the minimalist philosophy. In August 2009, the Scheme Steering Committee, which oversees the standardization process, announced its intention to recommend splitting Scheme into two languages: a large modern programming language for programmers; and a small version, a subset of the large version retaining the minimalism praised by educators and casual implementors. Two working groups were created to work on these two new versions of Scheme. The Scheme Reports Process site has links to the working groups' charters, public discussions and issue tracking system.
The ninth draft of R7RS (small language) was made available on April 15, 2013. A vote ratifying this draft closed on May 20, 2013, and the final report has been available since August 6, 2013, describing "the 'small' language of that effort: therefore it cannot be considered in isolation as the successor to R6RS".[
]
Distinguishing features
Scheme is primarily a functional programming
In computer science, functional programming is a programming paradigm where programs are constructed by Function application, applying and Function composition (computer science), composing Function (computer science), functions. It is a declar ...
language. It shares many characteristics with other members of the Lisp programming language family. Scheme's very simple syntax is based on s-expressions, parenthesized lists in which a prefix operator is followed by its arguments. Scheme programs thus consist of sequences of nested lists. Lists are also the main data structure in Scheme, leading to a close equivalence between source code and data formats (homoiconicity
In computer programming, homoiconicity (from the Greek words ''homo-'' meaning "the same" and ''icon'' meaning "representation") is a property of some programming languages. A language is homoiconic if a program written in it can be manipulated as ...
). Scheme programs can easily create and evaluate pieces of Scheme code dynamically.
The reliance on lists as data structures is shared by all Lisp dialects. Scheme inherits a rich set of list-processing primitives such as cons
, car
and cdr
from its Lisp progenitors. Scheme uses strictly but dynamically typed variables and supports first class procedures. Thus, procedures can be assigned as values to variables or passed as arguments to procedures.
This section concentrates mainly on innovative features of the language, including those features that distinguish Scheme from other Lisps. Unless stated otherwise, descriptions of features relate to the R5RS standard. In examples provided in this section, the notation "> result" is used to indicate the result of evaluating the expression on the immediately preceding line. This is the same convention used in R5RS.
Minimalism
Scheme is a very simple language, much easier to implement than many other languages of comparable expressive power.[The ]Scheme 48
Scheme 48 is a programming language, a dialect of the language Scheme, an implementation using an interpreter which emits bytecode. It has a foreign function interface for calling functions from the language C and comes with a library for reg ...
implementation is so-named because the interpreter was written by Richard Kelsey and Jonathan Rees in 48 hours (August 6th7th, 1986. See This ease is attributable to the use of lambda calculus
Lambda calculus (also written as ''λ''-calculus) is a formal system in mathematical logic for expressing computation based on function abstraction and application using variable binding and substitution. It is a universal model of computation ...
to derive much of the syntax of the language from more primitive forms. For instance of the 23 s-expression-based syntactic constructs defined in the R5RS Scheme standard, 14 are classed as derived or library forms, which can be written as macros involving more fundamental forms, principally lambda. As R5RS (§3.1) says: "The most fundamental of the variable binding constructs is the lambda expression, because all other variable binding constructs can be explained in terms of lambda expressions."[
: Fundamental forms: define, lambda, quote, if, define-syntax, let-syntax, letrec-syntax, syntax-rules, set!
: Derived forms: do, let, let*, letrec, cond, case, and, or, begin, named let, delay, unquote, unquote-splicing, quasiquote
Example: a macro to implement ]let
as an expression using lambda
to perform the variable bindings.
(define-syntax let
(syntax-rules ()
((let ((var expr) ...) body ...)
((lambda (var ...) body ...) expr ...))))
Thus using let
as defined above a Scheme implementation would rewrite "(let ((a 1)(b 2)) (+ b a))
" as "((lambda (a b) (+ b a)) 1 2)
", which reduces implementation's task to that of coding procedure instantiations.
In 1998, Sussman and Steele remarked that the minimalism of Scheme was not a conscious design goal, but rather the unintended outcome of the design process. "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 realized that the lambda calculus—a small, simple formalism—could serve as the core of a powerful and expressive programming language."[
]
Lexical scope
Like most modern programming languages and unlike earlier Lisps such as Maclisp, Scheme is lexically scoped: all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called. This contrasts with dynamic scoping which was characteristic of early Lisp dialects, because of the processing costs associated with the primitive textual substitution methods used to implement lexical scoping algorithms in compilers and interpreters of the day. In those Lisps, it was perfectly possible for a reference to a free variable inside a procedure to refer to quite distinct bindings external to the procedure, depending on the context of the call.
The impetus to incorporate lexical scoping, which was an unusual scoping model in the early 1970s, into their new version of Lisp, came from Sussman's studies of ALGOL. He suggested that ALGOL-like lexical scoping mechanisms would help to realize their initial goal of implementing Hewitt's Actor model in Lisp.[
The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus",] where they adopted the concept of the lexical closure
In programming languages, a closure, also lexical closure or function closure, is a technique for implementing lexically scoped name binding in a language with first-class functions. Operationally, a closure is a record storing a function toge ...
(on page 21), which had been described in an AI Memo
AI is artificial intelligence, intellectual ability in machines and robots.
Ai, AI or A.I. may also refer to:
Animals
* Ai (chimpanzee), an individual experimental subject in Japan
* Ai (sloth) or the pale-throated sloth, northern Amazonian ma ...
in 1970 by Joel Moses
Joel Moses (24 November 1941 – 29 May 2022) was an Israeli-American mathematician, computer scientist, and Institute Professor at the Massachusetts Institute of Technology (MIT).
Biography
Joel Moses was born in Mandatory Palestine on 24 Novem ...
, who attributed the idea to Peter J. Landin
Peter John Landin (5 June 1930 – 3 June 2009) was a British computer scientist. He was one of the first to realise that the lambda calculus could be used to model a programming language, an insight that is essential to the development of bo ...
.
Lambda calculus
Alonzo Church's mathematical notation, the lambda calculus, has inspired Lisp's use of "lambda" as a keyword for introducing a procedure, as well as influencing the development of functional programming
In computer science, functional programming is a programming paradigm where programs are constructed by Function application, applying and Function composition (computer science), composing Function (computer science), functions. It is a declar ...
techniques involving the use of higher-order function
In mathematics and computer science, a higher-order function (HOF) is a function that does at least one of the following:
* takes one or more functions as arguments (i.e. a procedural parameter, which is a parameter of a procedure that is itself ...
s in Lisp. But early Lisps were not suitable expressions of the lambda calculus because of their treatment of free variables.[
A formal lambda system has axioms and a complete calculation rule. It is helpful for the analysis using mathematical logic and tools. In this system, calculation can be seen as a directional deduction. The syntax of lambda calculus follows the recursive expressions from x, y, z, ...,parentheses, spaces, the period and the symbol λ. The function of lambda calculation includes: First, serve as a starting point of powerful mathematical logic. Second, it can reduce the requirement of programmers to consider the implementation details, because it can be used to imitate machine evaluation. Finally, the lambda calculation created a substantial meta-theory.
The introduction of lexical scope resolved the problem by making an equivalence between some forms of lambda notation and their practical expression in a working programming language. Sussman and Steele showed that the new language could be used to elegantly derive all the imperative and declarative semantics of other programming languages including ALGOL and Fortran, and the dynamic scope of other Lisps, by using lambda expressions not as simple procedure instantiations but as "control structures and environment modifiers".] They introduced continuation-passing style In functional programming, continuation-passing style (CPS) is a style of programming in which control is passed explicitly in the form of a continuation. This is contrasted with direct style, which is the usual style of programming. Gerald Jay Suss ...
along with their first description of Scheme in the first of the Lambda Papers, and in subsequent papers, they proceeded to demonstrate the raw power of this practical use of lambda calculus.
Block structure
Scheme inherits its block structure from earlier block structured languages, particularly ALGOL. In Scheme, blocks are implemented by three ''binding constructs'': let
, let*
and letrec
. For instance, the following construct creates a block in which a symbol called var
is bound to the number 10:
(define var "goose")
;; Any reference to var here will be bound to "goose"
(let ((var 10))
;; statements go here. Any reference to var here will be bound to 10.
)
;; Any reference to var here will be bound to "goose"
Blocks can be nested
''Nested'' is the seventh studio album by Bronx-born singer, songwriter and pianist Laura Nyro, released in 1978 on Columbia Records.
Following on from her extensive tour to promote 1976's ''Smile'', which resulted in the 1977 live album ''Season ...
to create arbitrarily complex block structures according to the need of the programmer. The use of block structuring to create local bindings alleviates the risk of namespace collision that can otherwise occur.
One variant of let
, let*
, permits bindings to refer to variables defined earlier in the same construct, thus:
(let* ((var1 10)
(var2 (+ var1 12)))
;; But the definition of var1 could not refer to var2
)
The other variant, letrec
, is designed to enable mutually recursive
In mathematics and computer science, mutual recursion is a form of recursion where two mathematical or computational objects, such as functions or datatypes, are defined in terms of each other. Mutual recursion is very common in functional progr ...
procedures to be bound to one another.
;; Calculation of Hofstadter's male and female sequences as a list of pairs
(define (hofstadter-male-female n)
(letrec ((female (lambda (n)
(if (= n 0)
1
(- n (male (female (- n 1)))))))
(male (lambda (n)
(if (= n 0)
0
(- n (female (male (- n 1))))))))
(let loop ((i 0))
(if (> i n)
'()
(cons (cons (female i)
(male i))
(loop (+ i 1)))))))
(hofstadter-male-female 8)
> ((1 . 0) (1 . 0) (2 . 1) (2 . 2) (3 . 2) (3 . 3) (4 . 4) (5 . 4) (5 . 5))
(See Hofstadter's male and female sequences for the definitions used in this example.)
All procedures bound in a single letrec
may refer to one another by name, as well as to values of variables defined earlier in the same letrec
, but they may not refer to ''values'' defined later in the same letrec
.
A variant of let
, the "named let" form, has an identifier after the let
keyword. This binds the let variables to the argument of a procedure whose name is the given identifier and whose body is the body of the let form. The body may be repeated as desired by calling the procedure. The named let is widely used to implement iteration.
Example: a simple counter
(let loop ((n 1))
(if (> n 10)
'()
(cons n
(loop (+ n 1)))))
> (1 2 3 4 5 6 7 8 9 10)
Like any procedure in Scheme, the procedure created in the named let is a first-class object.
Proper tail recursion
Scheme has an iteration construct, do
, but it is more idiomatic in Scheme to use tail recursion to express iteration. Standard-conforming Scheme implementations are required to optimize tail calls so as to support an unbounded number of active tail calls (R5RS sec. 3.5)[—a property the Scheme report describes as ''proper tail recursion''—making it safe for Scheme programmers to write iterative algorithms using recursive structures, which are sometimes more intuitive. Tail recursive procedures and the ''named ]let
'' form provide support for iteration using tail recursion.
;; Building a list of squares from 0 to 9:
;; Note: loop is simply an arbitrary symbol used as a label. Any symbol will do.
(define (list-of-squares n)
(let loop ((i n) (res '()))
(if (< i 0)
res
(loop (- i 1) (cons (* i i) res)))))
(list-of-squares 9)
> (0 1 4 9 16 25 36 49 64 81)
First-class continuations
Continuations in Scheme are first-class object
In programming language design, a first-class citizen (also type, object, entity, or value) in a given programming language is an entity which supports all the operations generally available to other entities. These operations typically include ...
s. Scheme provides the procedure call-with-current-continuation
In the Scheme computer programming language, the procedure call-with-current-continuation, abbreviated call/cc, is used as a control flow operator. It has been adopted by several other programming languages.
Taking a function f as its only argum ...
(also known as call/cc
) to capture the current continuation by packing it up as an escape procedure bound to a formal argument in a procedure provided by the programmer. (R5RS sec. 6.4)[ First-class continuations enable the programmer to create non-local control constructs such as iterators, coroutines, and backtracking.
Continuations can be used to emulate the behavior of return statements in imperative programming languages. The following function ]find-first
, given function func
and list lst
, returns the first element x
in lst
such that (func x)
returns true.
(define (find-first func lst)
(call-with-current-continuation
(lambda (return-immediately)
(for-each (lambda (x)
(if (func x)
(return-immediately x)))
lst)
#f)))
(find-first integer? '(1/2 3/4 5.6 7 8/9 10 11))
> 7
(find-first zero? '(1 2 3 4))
> #f
The following example, a traditional programmer's puzzle, shows that Scheme can handle continuations as first-class objects, binding them to variables and passing them as arguments to procedures.
(let* ((yin
((lambda (cc) (display "@") cc) (call-with-current-continuation (lambda (c) c))))
(yang
((lambda (cc) (display "*") cc) (call-with-current-continuation (lambda (c) c)))))
(yin yang))
When executed this code displays a counting sequence: @*@**@***@****@*****@******@*******@********...
Shared namespace for procedures and variables
In contrast to Common Lisp, all data and procedures in Scheme share a common namespace, whereas in Common Lisp functions and data have separate namespaces making it possible for a function and a variable to have the same name, and requiring special notation for referring to a function as a value. This is sometimes known as the " Lisp-1 vs. Lisp-2" distinction, referring to the unified namespace of Scheme and the separate namespaces of Common Lisp.
In Scheme, the same primitives that are used to manipulate and bind data can be used to bind procedures. There is no equivalent of Common Lisp's defun
and #'
primitives.
;; Variable bound to a number:
(define f 10)
f
> 10
;; Mutation (altering the bound value)
(set! f (+ f f 6))
f
> 26
;; Assigning a procedure to the same variable:
(set! f (lambda (n) (+ n 12)))
(f 6)
> 18
;; Assigning the result of an expression to the same variable:
(set! f (f 1))
f
> 13
;; functional programming:
(apply + '(1 2 3 4 5 6))
> 21
(set! f (lambda (n) (+ n 100)))
(map f '(1 2 3))
> (101 102 103)
Implementation standards
This subsection documents design decisions that have been taken over the years which have given Scheme a particular character, but are not the direct outcomes of the original design.
Numerical tower
Scheme specifies a comparatively full set of numerical datatypes including complex and rational types, which is known in Scheme as the numerical tower (R5RS sec. 6.2[). The standard treats these as abstractions, and does not commit the implementor to any particular internal representations.
Numbers may have the quality of exactness. An exact number can only be produced by a sequence of exact operations involving other exact numbers—inexactness is thus contagious. The standard specifies that any two implementations must produce equivalent results for all operations resulting in exact numbers.
The R5RS standard specifies procedures ]exact->inexact
and inexact->exact
which can be used to change the exactness of a number. inexact->exact
produces "the exact number that is numerically closest to the argument". exact->inexact
produces "the inexact number that is numerically closest to the argument". The R6RS standard omits these procedures from the main report, but specifies them as R5RS compatibility procedures in the standard library (rnrs r5rs (6)).
In the R5RS standard, Scheme implementations are not required to implement the whole numerical tower, but they must implement "a coherent subset consistent with both the purposes of the implementation and the spirit of the Scheme language" (R5RS sec. 6.2.3).[ The new R6RS standard does require implementation of the whole tower, and "exact integer objects and exact rational number objects of practically unlimited size and precision, and to implement certain procedures...so they always return exact results when given exact arguments" (R6RS sec. 3.4, sec. 11.7.1).][
Example 1: exact arithmetic in an implementation that supports exact
rational complex numbers.
;; Sum of three rational real numbers and two rational complex numbers
(define x (+ 1/3 1/4 -1/5 -1/3i 405/50+2/3i))
x]
> 509/60+1/3i
;; Check for exactness.
(exact? x)
> #t
Example 2: Same arithmetic in an implementation that supports neither exact
rational numbers nor complex numbers but does accept real numbers in rational notation.
;; Sum of four rational real numbers
(define xr (+ 1/3 1/4 -1/5 405/50))
;; Sum of two rational real numbers
(define xi (+ -1/3 2/3))
xr
> 8.48333333333333
xi
> 0.333333333333333
;; Check for exactness.
(exact? xr)
> #f
(exact? xi)
> #f
Both implementations conform to the R5RS standard but the second does not conform to R6RS because it does not implement the full numerical tower.
Delayed evaluation
Scheme supports delayed evaluation through the delay
form and the procedure force
.
(define a 10)
(define eval-aplus2 (delay (+ a 2)))
(set! a 20)
(force eval-aplus2)
> 22
(define eval-aplus50 (delay (+ a 50)))
(let ((a 8))
(force eval-aplus50))
> 70
(set! a 100)
(force eval-aplus2)
> 22
The lexical context of the original definition of the promise is preserved, and its value is also preserved after the first use of force
. The promise is only ever evaluated once.
These primitives, which produce or handle values known as
promises
A promise is a transaction whereby a person makes a vow or the suggestion of a guarantee.
Promise(s) may also refer to:
Places
* Promise, Oregon
*Promise, South Dakota
*Promise City, Iowa
*Promise Land, Tennessee or Promise
Film and TV
* ''Pro ...
, can be used to implement advanced lazy evaluation constructs such as stream
A stream is a continuous body of water, body of surface water Current (stream), flowing within the stream bed, bed and bank (geography), banks of a channel (geography), channel. Depending on its location or certain characteristics, a stream ...
s.
In the R6RS standard, these are no longer primitives, but instead, are provided as part of the R5RS compatibility library (rnrs r5rs (6)).
In R5RS, a suggested implementation of delay
and force
is given, implementing the promise as a procedure with no arguments (a thunk
In computer programming, a thunk is a subroutine used to inject a calculation into another subroutine. Thunks are primarily used to delay a calculation until its result is needed, or to insert operations at the beginning or end of the other subro ...
) and using memoization
In computing, memoization or memoisation is an optimization technique used primarily to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again. Memoization ...
to ensure that it is only ever evaluated once, irrespective of the number of times force
is called (R5RS sec. 6.4).[
SRFI 41 enables the expression of both finite and infinite sequences with extraordinary economy. For example, this is a definition of the fibonacci sequence using the functions defined in SRFI 41:][
;; Define the Fibonacci sequence:
(define fibs
(stream-cons 0
(stream-cons 1
(stream-map +
fibs
(stream-cdr fibs)))))
;; Compute the hundredth number in the sequence:
(stream-ref fibs 99)]
> 218922995834555169026
Order of evaluation of procedure arguments
Most Lisps specify an order of evaluation for procedure arguments. Scheme does not. Order of evaluation—including the order in which the expression in the operator position is evaluated—may be chosen by an implementation on a call-by-call basis, and the only constraint is that "the effect of any concurrent evaluation of the operator and operand expressions is constrained to be consistent with some sequential order of evaluation." (R5RS sec. 4.1.3)[
(let ((ev (lambda(n) (display "Evaluating ")
(display (if (procedure? n) "procedure" n))
(newline) n)))
((ev +) (ev 1) (ev 2)))]
> 3
ev is a procedure that describes the argument passed to it, then returns the value of the argument. In contrast with other Lisps, the appearance of an expression in the operator position (the first item) of a Scheme expression is quite legal, as long as the result of the expression in the operator position is a procedure.
In calling the procedure "+" to add 1 and 2, the expressions (ev +), (ev 1) and (ev 2) may be evaluated in any order, as long as the effect is not as if they were evaluated in parallel. Thus the following three lines may be displayed in any order by standard Scheme when the above example code is executed, although the text of one line may not be interleaved with another because that would violate the sequential evaluation constraint.
: Evaluating 1
: Evaluating 2
: Evaluating procedure
Hygienic macros
In the R5RS standard and also in later reports, the syntax of Scheme can easily be extended via the macro system. The R5RS standard introduced a powerful hygienic macro system that allows the programmer to add new syntactic constructs to the language using a simple pattern matching sublanguage (R5RS sec 4.3).[ Prior to this, the hygienic macro system had been relegated to an appendix of the R4RS standard, as a "high level" system alongside a "low level" macro system, both of which were treated as extensions to Scheme rather than an essential part of the language.]
Implementations of the hygienic macro system, also called syntax-rules
, are required to respect the lexical scoping of the rest of the language. This is assured by special naming and scoping rules for macro expansion and avoids common programming errors that can occur in the macro systems of other programming languages. R6RS specifies a more sophisticated transformation system, syntax-case
, which has been available as a language extension to R5RS Scheme for some time.
;; Define a macro to implement a variant of "if" with a multi-expression
;; true branch and no false branch.
(define-syntax when
(syntax-rules ()
((when pred exp exps ...)
(if pred (begin exp exps ...)))))
Invocations of macros and procedures bear a close resemblance—both are s-expressions—but they are treated differently. When the compiler encounters an s-expression in the program, it first checks to see if the symbol is defined as a syntactic keyword within the current lexical scope. If so, it then attempts to expand the macro, treating the items in the tail of the s-expression as arguments without compiling code to evaluate them, and this process is repeated recursively until no macro invocations remain. If it is not a syntactic keyword, the compiler compiles code to evaluate the arguments in the tail of the s-expression and then to evaluate the variable represented by the symbol at the head of the s-expression and call it as a procedure with the evaluated tail expressions passed as actual arguments to it.
Most Scheme implementations also provide additional macro systems. Among popular ones are syntactic closures, explicit renaming macros and define-macro
, a non-hygienic macro system similar to defmacro
system provided in Common Lisp
Common Lisp (CL) is a dialect of the Lisp programming language, published in ANSI standard document ''ANSI INCITS 226-1994 (S20018)'' (formerly ''X3.226-1994 (R1999)''). The Common Lisp HyperSpec, a hyperlinked HTML version, has been derived fro ...
.
The inability to specify whether or not a macro is hygienic is one of the shortcomings of the macro system. Alternative models for expansion such as scope sets provide a potential solution.
Environments and eval
Prior to R5RS, Scheme had no standard equivalent of the eval
procedure which is ubiquitous in other Lisps, although the first Lambda Paper had described evaluate
as "similar to the LISP function EVAL"[ and the first Revised Report in 1978 replaced this with ]enclose
, which took two arguments. The second, third and fourth revised reports omitted any equivalent of eval
.
The reason for this confusion is that in Scheme with its lexical scoping the result of evaluating an expression depends on where it is evaluated. For instance, it is not clear whether the result of evaluating the following expression should be 5 or 6:[Jonathan Rees]
The Scheme of Things The June 1992 Meeting
(postscript), in Lisp Pointers, V(4), October–December 1992.
Retrieved 2012-08-09
(let ((name '+))
(let ((+ *))
(evaluate (list name 2 3))))
If it is evaluated in the outer environment, where name
is defined, the result is the sum of the operands. If it is evaluated in the inner environment, where the symbol "+" has been bound to the value of the procedure "*", the result is the product of the two operands.
R5RS resolves this confusion by specifying three procedures that return environments and providing a procedure eval
that takes an s-expression and an environment and evaluates the expression in the environment provided. (R5RS sec. 6.5)[ R6RS extends this by providing a procedure called ]environment
by which the programmer can specify exactly which objects to import into the evaluation environment.
With modern scheme (usually compatible with R5RS) to evaluate this expression, one needs to define a function evaluate
which can look like this:
(define (evaluate expr)
(eval expr (interaction-environment)))
interaction-environment
is the interpreter's global environment.
Treatment of non-boolean values in boolean expressions
In most dialects of Lisp including Common Lisp, by convention the value NIL
evaluates to the value false in a boolean expression. In Scheme, since the IEEE standard in 1991,[ all values except ]#f
, including NIL
's equivalent in Scheme which is written as '()
, evaluate to the value true in a boolean expression. (R5RS sec. 6.3.1)[
Where the constant representing the boolean value of true is ]T
in most Lisps, in Scheme it is #t
.
Disjointness of primitive datatypes
In Scheme the primitive datatypes are disjoint. Only one of the following predicates can be true of any Scheme object: boolean?
, pair?
, symbol?
, number?
, char?
, string?
, vector?
, port?
, procedure?
. (R5RS sec 3.2)[
Within the numerical datatype, by contrast, the numerical values overlap. For example, an integer value satisfies all of the ]integer?
, rational?
, real?
, complex?
and number?
predicates at the same time. (R5RS sec 6.2)[
]
Equivalence predicates
Scheme has three different types of equivalence between arbitrary objects denoted by three different ''equivalence predicates'', relational operators for testing equality, eq?
, eqv?
and equal?
:
* eq?
evaluates to #f
unless its parameters represent the same data object in memory;
* eqv?
is generally the same as eq?
but treats primitive objects (e.g. characters and numbers) specially so that numbers that represent the same value are eqv?
even if they do not refer to the same object;
* equal?
compares data structures such as lists, vectors and strings to determine if they have congruent structure and eqv?
contents.(R5RS sec. 6.1)[
Type dependent equivalence operations also exist in Scheme: ]string=?
and string-ci=?
compare two strings (the latter performs a case-independent comparison); char=?
and char-ci=?
compare characters; =
compares numbers.[
]
Comments
Up to the R5RS standard, the standard comment in Scheme was a semicolon, which makes the rest of the line invisible to Scheme. Numerous implementations have supported alternative conventions permitting comments to extend for more than a single line, and the R6RS standard permits two of them: an entire s-expression may be turned into a comment (or "commented out") by preceding it with #;
(introduced in SRFI 62) and a multiline comment or "block comment" may be produced by surrounding text with #,
and , #
.
Input/output
Scheme's input and output is based on the ''port'' datatype. (R5RS sec 6.6)[ R5RS defines two default ports, accessible with the procedures ]current-input-port
and current-output-port
, which correspond to the Unix notions of standard input and standard output. Most implementations also provide current-error-port
. Redirection of input and standard output is supported in the standard, by standard procedures such as with-input-from-file
and with-output-to-file
. Most implementations provide string ports with similar redirection capabilities, enabling many normal input-output operations to be performed on string buffers instead of files, using procedures described in SRFI 6. The R6RS standard specifies much more sophisticated and capable port procedures and many new types of port.
The following examples are written in strict R5RS Scheme.
Example 1: With output defaulting to (current-output-port):
(let ((hello0 (lambda() (display "Hello world") (newline))))
(hello0))
Example 2: As 1, but using optional port argument to output procedures
(let ((hello1 (lambda (p) (display "Hello world" p) (newline p))))
(hello1 (current-output-port)))
Example 3: As 1, but output is redirected to a newly created file
;; NB: with-output-to-file is an optional procedure in R5RS
(let ((hello0 (lambda () (display "Hello world") (newline))))
(with-output-to-file "helloworldoutputfile" hello0))
Example 4: As 2, but with explicit file open and port close to send output to file
(let ((hello1 (lambda (p) (display "Hello world" p) (newline p)))
(output-port (open-output-file "helloworldoutputfile")))
(hello1 output-port)
(close-output-port output-port))
Example 5: As 2, but with using call-with-output-file to send output to a file.
(let ((hello1 (lambda (p) (display "Hello world" p) (newline p))))
(call-with-output-file "helloworldoutputfile" hello1))
Similar procedures are provided for input. R5RS Scheme provides the predicates input-port?
and output-port?
. For character input and output, write-char
, read-char
, peek-char
and char-ready?
are provided. For writing and reading Scheme expressions, Scheme provides read
and write
. On a read operation, the result returned is the end-of-file object if the input port has reached the end of the file, and this can be tested using the predicate eof-object?
.
In addition to the standard, SRFI 28 defines a basic formatting procedure resembling Common Lisp's format
function, after which it is named.
Redefinition of standard procedures
In Scheme, procedures are bound to variables. At R5RS the language standard formally mandated that programs may change the variable bindings of built-in procedures, effectively redefining them. (R5RS "Language changes")[ For example, one may extend ]+
to accept strings as well as numbers by redefining it:
(set! +
(let ((original+ +))
(lambda args
(apply (if (or (null? args) (string? (car args)))
string-append
original+)
args))))
(+ 1 2 3)
> 6
(+ "1" "2" "3")
> "123"
In R6RS every binding, including the standard ones, belongs to some library, and all exported bindings are immutable. (R6RS sec 7.1)[ Because of this, redefinition of standard procedures by mutation is forbidden. Instead, it is possible to import a different procedure under the name of a standard one, which in effect is similar to redefinition.
]
Nomenclature and naming conventions
In Standard Scheme, procedures that convert from one datatype to another contain the character string "->" in their name, predicates end with a "?", and procedures that change the value of already-allocated data end with a "!". These conventions are often followed by Scheme programmers.
In formal contexts such as Scheme standards, the word "procedure" is used in preference to "function" to refer to a lambda expression or primitive procedure. In normal usage, the words "procedure" and "function" are used interchangeably. Procedure application is sometimes referred to formally as ''combination''.
As in other Lisps, the term "thunk
In computer programming, a thunk is a subroutine used to inject a calculation into another subroutine. Thunks are primarily used to delay a calculation until its result is needed, or to insert operations at the beginning or end of the other subro ...
" is used in Scheme to refer to a procedure with no arguments. The term "proper tail recursion" refers to the property of all Scheme implementations, that they perform tail-call optimization so as to support an indefinite number of active tail calls.
The form of the titles of the standards documents since R3RS, "Revisedn Report on the Algorithmic Language Scheme", is a reference to the title of the ALGOL 60
ALGOL 60 (short for ''Algorithmic Language 1960'') is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them, representing a k ...
standard document, "Revised Report on the Algorithmic Language Algol 60," The Summary page of R3RS is closely modeled on the Summary page of the ALGOL 60 Report.
Review of standard forms and procedures
The language is formally defined in the standards R5RS (1998) and R6RS (2007). They describe standard "forms": keywords and accompanying syntax, which provide the control structure of the language, and standard procedures which perform common tasks.
Standard forms
This table describes the standard forms in Scheme. Some forms appear in more than one row because they cannot easily be classified into a single function in the language.
Forms marked "L" in this table are classed as derived "library" forms in the standard and are often implemented as macros using more fundamental forms in practice, making the task of implementation much easier than in other languages.
Note that begin
is defined as a library syntax in R5RS, but the expander needs to know about it to achieve the splicing functionality. In R6RS it is no longer a library syntax.
Standard procedures
The following two tables describe the standard procedures in R5RS Scheme. R6RS is far more extensive and a summary of this type would not be practical.
Some procedures appear in more than one row because they cannot easily be classified into a single function in the language.
String and character procedures that contain "-ci" in their names perform case-independent comparisons between their arguments: upper case and lower case versions of the same character are taken to be equal.
Implementations of - and / that take more than two arguments are defined but left optional at R5RS.
Scheme Requests for Implementation
Because of Scheme's minimalism, many common procedures and syntactic forms are not defined by the standard. In order to keep the core language small but facilitate standardization of extensions, the Scheme community has a "Scheme Request for Implementation" (SRFI) process by which extension libraries are defined through careful discussion of extension proposals. This promotes code portability. Many of the SRFIs are supported by all or most Scheme implementations.
SRFIs with fairly wide support in different implementations include:
* 0: feature-based conditional expansion construct
* 1: list library
* 4: homogeneous numeric vector datatypes
* 6: basic string ports
* 8: receive, binding to multiple values
* 9: defining record types
* 13: string library
* 14: character-set library
* 16: syntax for procedures of variable arity
Arity () is the number of arguments or operands taken by a function, operation or relation in logic, mathematics, and computer science. In mathematics, arity may also be named ''rank'', but this word can have many other meanings in mathematics. In ...
* 17: generalized set!
* 18: Multithreading support
* 19: time data types and procedures
* 25: multi-dimensional array primitives
* 26: notation for specializing parameters without currying
In mathematics and computer science, currying is the technique of translating the evaluation of a function that takes multiple arguments into evaluating a sequence of functions, each with a single argument. For example, currying a function f that ...
* 27: sources of random bits
* 28: basic format strings
* 29: localization
Localization or localisation may refer to:
Biology
* Localization of function, locating psychological functions in the brain or nervous system; see Linguistic intelligence
* Localization of sensation, ability to tell what part of the body is a ...
* 30: nested multi-line comments
* 31: a special form for recursive evaluation
* 37: args-fold: a program argument processor
* 39: parameter objects
* 41: stream
A stream is a continuous body of water, body of surface water Current (stream), flowing within the stream bed, bed and bank (geography), banks of a channel (geography), channel. Depending on its location or certain characteristics, a stream ...
s
* 42: eager comprehensions
* 43: vector library
* 45: primitives for expressing iterative lazy algorithms
* 60: integers as bits
* 61: a more general cond clause
* 66: octet vectors
* 67: compare procedures
Implementations
The elegant, minimalist design has made Scheme a popular target for language designers, hobbyists, and educators, and because of its small size, that of a typical interpreter, it is also a popular choice for embedded system
An embedded system is a computer system—a combination of a computer processor, computer memory, and input/output peripheral devices—that has a dedicated function within a larger mechanical or electronic system. It is ''embedded'' as ...
s and scripting
Script may refer to:
Writing systems
* Script, a distinctive writing system, based on a repertoire of specific elements or symbols, or that repertoire
* Script (styles of handwriting)
** Script typeface, a typeface with characteristics of handw ...
. This has resulted in scores of implementations,[75 known implementations of Scheme are listed by ] most of which differ from each other so much that porting programs from one implementation to another is quite difficult, and the small size of the standard language means that writing a useful program of any great complexity in standard, portable Scheme is almost impossible.[ The R6RS standard specifies a much broader language, in an attempt to broaden its appeal to programmers.
Almost all implementations provide a traditional Lisp-style read–eval–print loop for development and debugging. Many also ]compile
In computing, a compiler is a computer program that translates computer code written in one programming language (the ''source'' language) into another language (the ''target'' language). The name "compiler" is primarily used for programs that ...
Scheme programs to executable binary. Support for embedding Scheme code in programs written in other languages is also common, as the relative simplicity of Scheme implementations makes it a popular choice for adding scripting capabilities to larger systems developed in languages such as C. The Gambit, Chicken
The chicken (''Gallus gallus domesticus'') is a domesticated junglefowl species, with attributes of wild species such as the grey and the Ceylon junglefowl that are originally from Southeastern Asia. Rooster or cock is a term for an adult m ...
, and Bigloo Scheme interpreters compile Scheme to C, which makes embedding particularly easy. In addition, Bigloo's compiler can be configured to generate JVM
A Java virtual machine (JVM) is a virtual machine that enables a computer to run Java programs as well as programs written in other languages that are also compiled to Java bytecode. The JVM is detailed by a specification that formally describes ...
bytecode
Bytecode (also called portable code or p-code) is a form of instruction set designed for efficient execution by a software interpreter. Unlike human-readable source code, bytecodes are compact numeric codes, constants, and references (norma ...
, and it also features an experimental bytecode generator for .NET.
Some implementations support additional features. For example, Kawa and JScheme
JScheme is an implementation of the Scheme programming language, created by Kenneth R. Anderson, Timothy J. Hickey and Peter Norvig, which is almost compliant with the R4RS Scheme standard and which has an interface to Java.
Distributed under ...
provide integration with Java classes, and the Scheme to C compilers often make it easy to use external libraries written in C, up to allowing the embedding of actual C code in the Scheme source. Another example is Pvts
Pilo Visual Tools for Scheme (Pvts) is a basic interpreter implementation with visualization tools of the Scheme programming language developed at Rollins College. It is written in Java. PVTS contains an interpreter (also known as a read-eval ...
, which offers a set of visual tools for supporting the learning of Scheme.
Usage
Scheme is widely used by a number of schools; in particular, a number of introductory Computer Science
Computer science is the study of computation, automation, and information. Computer science spans theoretical disciplines (such as algorithms, theory of computation, information theory, and automation) to Applied science, practical discipli ...
courses use Scheme in conjunction with the textbook ''Structure and Interpretation of Computer Programs
''Structure and Interpretation of Computer Programs'' (''SICP'') is a computer science textbook by Massachusetts Institute of Technology professors Harold Abelson and Gerald Jay Sussman with Julie Sussman. It is known as the "Wizard Book" in hac ...
'' (SICP). For the past 12 years, PLT has run the ProgramByDesign
The ProgramByDesign (formerly TeachScheme!) project is an outreach effort of the PLT research group. The goal is to train college faculty, high school teachers, and possibly even middle school teachers, in programming and computing.
History
Matt ...
(formerly TeachScheme!) project, which has exposed close to 600 high school teachers and thousands of high school students to rudimentary Scheme programming. MIT's old introductory programming class 6.001 was taught in Scheme, Although 6.001 has been replaced by more modern courses, SICP continues to be taught at MIT. Likewise, the introductory class at UC Berkeley
The University of California, Berkeley (UC Berkeley, Berkeley, Cal, or California) is a public university, public land-grant university, land-grant research university in Berkeley, California. Established in 1868 as the University of Californi ...
, CS 61A, was until 2011 taught entirely in Scheme, save minor diversions into Logo to demonstrate dynamic scope. Today, like MIT, Berkeley has replaced the syllabus with a more modern version that is primarily taught in Python 3, but the current syllabus is still based on the old curriculum, and parts of the class are still taught in Scheme.
The textbook ''How to Design Programs
''How to Design Programs'' (''HtDP'') is a textbook by Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, and Shriram Krishnamurthi on the systematic design of computer programs. MIT Press published the first edition in 2001, and the secon ...
'' by Matthias Felleisen, currently at Northeastern University, is used by some institutes of higher education for their introductory computer science courses. Both Northeastern University
Northeastern University (NU) is a private university, private research university with its main campus in Boston. Established in 1898, the university offers undergraduate and graduate programs on its main campus as well as satellite campuses in ...
and Worcester Polytechnic Institute use Scheme exclusively for their introductory courses Fundamentals of Computer Science (CS2500) and Introduction to Program Design (CS1101), respectively.[CS 2500: Fundamentals of Computer Science I](_blank)
Northeastern University
Northeastern University (NU) is a private university, private research university with its main campus in Boston. Established in 1898, the university offers undergraduate and graduate programs on its main campus as well as satellite campuses in ...
[CS 1101: Introduction to Program Design (A05): course software](_blank)
Worcester Polytechnic Institute Rose-Hulman uses Scheme in its more advanced Programming Language Concepts course. Brandeis University
, mottoeng = "Truth even unto its innermost parts"
, established =
, type = Private research university
, accreditation = NECHE
, president = Ronald D. Liebowitz
, pro ...
's core course, Structure and Interpretations of Computer Programs (COSI121b), is also taught exclusively in Scheme by theoretical computer scientist Harry Mairson
Harry George Mairson is a theoretical computer scientist and Professor of Computer Science in thVolen National Center for Complex Systemsat Brandeis University in Waltham, Massachusetts. His research is in the fields of logic in computer science, ...
. Indiana University
Indiana University (IU) is a system of public universities in the U.S. state of Indiana.
Campuses
Indiana University has two core campuses, five regional campuses, and two regional centers under the administration of IUPUI.
*Indiana Universit ...
's introductory class, C211, is taught entirely in Scheme. A self-paced version of the course, CS 61AS, continues to use Scheme. The introductory computer science courses at Yale
Yale University is a private research university in New Haven, Connecticut. Established in 1701 as the Collegiate School, it is the third-oldest institution of higher education in the United States and among the most prestigious in the wor ...
and Grinnell College are also taught in Scheme. Programming Design Paradigms, a mandatory course for the Computer science Graduate Students at Northeastern University
Northeastern University (NU) is a private university, private research university with its main campus in Boston. Established in 1898, the university offers undergraduate and graduate programs on its main campus as well as satellite campuses in ...
, also extensively uses Scheme.
The former introductory Computer Science course at the University of Minnesota - Twin Cities, CSCI 1901, also used Scheme as its primary language, followed by a course that introduced students to the Java programming language;[Structure of Computer Programming I](_blank)
, Computer Science Department, University of Minnesota, Spring 2010 (accessed 2010-01-30). however, following the example of MIT, the department replaced 1901 with the Python-based CSCI 1133,[CSci Required Class Course Descriptions and Other Information](_blank)
, Computer Science Department, University of Minnesota (accessed 2019-10-25) while functional programming is covered in detail in the third-semester course CSCI 2041.
CSE Curriculum Committee, University of Minnesota (accessed 2019-10-25) In the software industry, Tata Consultancy Services, Asia's largest software consultancy firm, uses Scheme in their month-long training program for fresh college graduates.
Scheme is/was also used for the following:
* The Document Style Semantics and Specification Language
The Document Style Semantics and Specification Language (DSSSL) is an international standard developed to provide stylesheets for SGML documents.
DSSSL consists of two parts: a tree transformation process that can be used to manipulate the tree ...
(DSSSL), which provides a method of specifying SGML
The Standard Generalized Markup Language (SGML; ISO 8879:1986) is a standard for defining generalized markup languages for documents. ISO 8879 Annex A.1 states that generalized markup is "based on two postulates":
* Declarative: Markup should des ...
stylesheets, uses a Scheme subset.
* The well-known open source
Open source is source code that is made freely available for possible modification and redistribution. Products include permission to use the source code, design documents, or content of the product. The open-source model is a decentralized sof ...
raster graphics editor
A raster graphics editor is a computer program that allows users to create and edit images interactively on the computer screen and save them in one of many raster graphics file formats (also known as bitmap images) such as JPEG, PNG, and GI ...
GIMP
GIMP ( ; GNU Image Manipulation Program) is a free and open-source raster graphics editor used for image manipulation (retouching) and image editing, free-form drawing, transcoding between different image file formats, and more specialized task ...
uses TinyScheme
TinyScheme is a free software implementation of the Scheme programming language with a lightweight Scheme interpreter of a subset of the R5RS standard. It is meant to be used as an embedded scripting interpreter for other programs. Much of the fu ...
as a scripting language
A scripting language or script language is a programming language that is used to manipulate, customize, and automate the facilities of an existing system. Scripting languages are usually interpreted at runtime rather than compiled.
A scripting ...
.["''The major scripting language for the GIMP that has been attached to it today is Scheme.''" From ]
* Guile has been adopted by GNU project as its official scripting language, and that implementation of Scheme is embedded in such applications as GNU LilyPond
LilyPond is a computer program and file format for music engraving. One of LilyPond's major goals is to produce scores that are engraved with traditional layout rules, reflecting the era when scores were engraved by hand.
LilyPond is cross-pla ...
and GnuCash as a scripting language for extensions. Likewise, Guile used to be the scripting language for the desktop environment
In computing, a desktop environment (DE) is an implementation of the desktop metaphor made of a bundle of programs running on top of a computer operating system that share a common graphical user interface (GUI), sometimes described as a graphica ...
GNOME
A gnome is a mythological creature and diminutive spirit in Renaissance magic and alchemy, first introduced by Paracelsus in the 16th century and later adopted by more recent authors including those of modern fantasy literature. Its characte ...
, and GNOME still has a project that provides Guile bindings to its library stack. There is a project to incorporate Guile into GNU Emacs
GNU Emacs is a free software text editor. It was created by GNU Project founder Richard Stallman, based on the Emacs editor developed for Unix operating systems. GNU Emacs has been a central component of the GNU project and a flagship project of ...
, GNU's flagship program, replacing the current Emacs Lisp interpreter.
* Elk Scheme is used by Synopsys as a scripting language for its technology CAD (TCAD) tools.
* Shiro Kawai, senior programmer on the movie '' Final Fantasy: The Spirits Within'', used Scheme as a scripting language for managing the real-time rendering engine.
* Google App Inventor
MIT App Inventor is a web application integrated development environment originally provided by Google, and now maintained by the Massachusetts Institute of Technology (MIT). It allows newcomers to computer programming to create application softw ...
for Android
Android may refer to:
Science and technology
* Android (robot), a humanoid robot or synthetic organism designed to imitate a human
* Android (operating system), Google's mobile operating system
** Bugdroid, a Google mascot sometimes referred to ...
uses Scheme, where Kawa is used to compile the Scheme code down to byte-codes for the Java Virtual Machine
A Java virtual machine (JVM) is a virtual machine that enables a computer to run Java programs as well as programs written in other languages that are also compiled to Java bytecode. The JVM is detailed by a specification that formally describes ...
running on Android devices.
See also
*''Essentials of Programming Languages
''Essentials of Programming Languages'' (''EOPL'') is a textbook on programming languages by Daniel P. Friedman, Mitchell Wand, and Christopher T. Haynes.
EOPL surveys the principles of programming languages from an operational perspective. It sta ...
'', textbook using Scheme as foundation
References
Further reading
* tp://ftp.cs.utexas.edu/pub/garbage/cs345/schintro-v14/schintro_toc.html An Introduction to Scheme and its Implementationbr>a mirror
*
*
*
External links
*
schemers.org
provides links to a number of Scheme resources including the specifications
*
*
*
Scheme Weekly
Bookmarklet that add Interactive Scheme REPL to any website
{{DEFAULTSORT:Scheme (Programming Language)
Academic programming languages
Articles with example Scheme (programming language) code
Dynamically typed programming languages
Extensible syntax programming languages
Lisp programming language family
Multi-paradigm programming languages
Programming languages created in 1975