Skip to main content
    • Aa
    • Aa

Revised6 Report on the Algorithmic Language Scheme


Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary. Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major programming paradigms in use today.

Scheme was one of the first programming languages to incorporate first-class procedures as in the lambda calculus, thereby proving the usefulness of static scope rules and block structure in a dynamically typed language. Scheme was the first major dialect of Lisp to distinguish procedures from lambda expressions and symbols, to use a single lexical environment for all variables, and to evaluate the operator position of a procedure call in the same way as an operand position. By relying entirely on procedure calls to express iteration, Scheme emphasized the fact that tail-recursive procedure calls are essentially gotos that pass arguments. Scheme was the first widely used programming language to embrace first-class escape procedures, from which all previously known sequential control structures can be synthesized. A subsequent version of Scheme introduced the concept of exact and inexact number objects, an extension of Common Lisp's generic arithmetic. More recently, Scheme became the first programming language to support hygienic macros, which permit the syntax of a block-structured language to be extended in a consistent and reliable manner.

Hide All
Abelson Harold, Sussman Gerald Jay, & Sussman Julie. (1996). Structure and interpretation of computer programs. second edn. Cambridge, Mass.: MIT Press.
Backus J. W., Bauer F.L., Green J., Katz C., Naur J. McCarthy P., Perlis A. J., Rutishauser H., Samuelson K., Wegstein B. Vauquois J. H., van Wijngaarden A., & Woodger M. (1963). Revised report on the algorithmic language Algol 60. Communications of the ACM, 6 (1), 117.
Barendregt Henk P. (1984). Introduction to the lambda calculus. Nieuw archief voor wisenkunde, 4 (2), 337372.
Bawden Alan. 1999 (Jan.). Quasiquotation in Lisp. Pages 4–12 of: Danvy Olivier (ed), Proceedings acm sigplan workshop on partial evaluation and semantics-based program manipulation pepm '99. BRICS Notes Series NS-99-1.
Bawden Alan, & Rees Jonathan. (1988). Syntactic closures. Pages 86–95 of: ACM conference on Lisp and functional programming. Snowbird, Utah: ACM Press.
Bradner Scott. 1997 (Mar.). Key words for use in RFCs to indicate requirement levels. RFC 2119.
Burger Robert G., & Dybvig R. Kent. (1996). Printing floating-point numbers quickly and accurately. Pages 108–116 of: Proceedings of the ACM SIGPLAN '96 conference on programming language design and implementation. Philadelphia, PA, USA: ACM Press.
Clinger Will, Dybvig R. Kent, Sperber Michael, & van Straaten Anton. (2005). SRFI 76: R6RS records.
Clinger William. 1985 (1985). The revised revised report on Scheme, or an uncommon Lisp. Tech. rept. MIT Artificial Intelligence Memo 848. MIT. Also published as Computer Science Department Technical Report 174, Indiana University, June 1985.
Clinger William. (1998). Proper tail recursion and space efficiency. Pages 174–185 of: Cooper Keith (ed), Proceedings of the 1998 on programming language design and implementation. Montreal, Canada: ACM Press. Volume 33(5) of SIGPLAN Notices.
Clinger William, & Rees Jonathan. (1986). Revised3 report on the algorithmic language Scheme. SIGPLAN notices, 21 (12), 3779.
Clinger William, & Rees Jonathan. (1991a). Macros that work. Pages 155–162 of: Proceedings 1991 ACM sigplan symposium on principles of programming languages. Orlando, Florida: ACM Press.
Clinger William, & Rees Jonathan. (1991b). Revised4 report on the algorithmic language Scheme. Lisp pointers, IV (3), 155.
Clinger William D. (1990). How to read floating point numbers accurately. Pages 92–101 of: Proceedings on programming language design and implementation '90. White Plains, New York, USA: ACM.
Clinger William D, & Sperber Michael. (2005). SRFI 77: Preliminary proposal for R6RS arithmetic.
Cohen Danny. 1980 (Apr.). On holy wars and a plea for peace. Internet Engineering Note 137.
Davis Mark. (2006). Unicode Standard Annex #29: Text boundaries.
Dybvig R. Kent. (2003). The Scheme programming language. third edn. Cambridge: MIT Press.
Dybvig R. Kent. (2005). Chez Scheme version 7 user's guide. Cadence Research Systems.
Dybvig R. Kent. (2006). SRFI 93: R6RS syntax-case macros.
Dybvig R. Kent, Hieb Robert, & Bruggeman Carl. (1992). Syntactic abstraction in Scheme. Lisp and symbolic computation, 5 (4), 295326.
Felleisen Matthias, & Flatt Matthew. (2003). Programming languages and lambda calculi.
Fessenden Carol, Clinger William, Friedman Daniel P., & Haynes Christopher. (1983). Scheme 311 version 4 reference manual. Indiana University. Indiana University Computer Science Technical Report 137, Superseded by (Friedman et al., 1985).
Flatt Matthew. 2006 (July). PLT MzScheme: Language manual. Rice University, University of Utah.
Flatt Matthew, & Dybvig Kent. (2005). SRFI 83: R6RS library syntax.
Flatt Matthew, & Feeley Marc. (2005). SRFI 75: R6RS unicode data.
Friedman Daniel P., Haynes Christopher, Kohlbecker Eugene, & Wand Mitchell. 1985 (Jan.). Scheme 84 interim reference manual. Indiana University. Indiana University Computer Science Technical Report 153.
Gosling James, Joy Bill, Steele Guy, & Bracha Gilad. (2005). The Java™ language specification. Third edn. Addison-Wesley.
IEEE754. (1985). IEEE standard 754-1985. IEEE standard for binary floating-point arithmetic. Reprinted in SIGPLAN Notices, 22(2):9-25, 1987.
Kelsey Richard, Clinger William, & Rees Jonathan. (1998). Revised5 report on the algorithmic language Scheme. Higher-order and symbolic computation, 11 (1), 7105.
Kohlbecker Eugene E., Friedman Daniel P., Felleisen Matthias, & Duba Bruce. (1986). Hygienic macro expansion. Pages 151–161 of: Proceedings of the 1986 ACM conference on Lisp and functional programming.
Kohlbecker Eugene E. Jr. 1986 (Aug.). Syntactic extensions in the programming language lisp. Ph.D. thesis, Indiana University.
Leach P., Mealling M., & Salz R. 2005 (July). A Universally Unique IDentifier (UUID) URN namespace. RFC 4122.
Matthews Jacob, & Findler Robert Bruce. 2005 (Sept.). An operational semantics for R5RS Scheme. Pages 41–54 of: Ashley J. Michael, & Sperber Michael (eds), Proceedings of the sixth workshop on scheme and functional programming. Indiana University Technical Report TR619.
Matthews Jacob, & Findler Robert Bruce. (2007). An operational semantics for Scheme. Journal of functional programming. From
Matthews Jacob, Findler Robert Bruce, Flatt Matthew, & Felleisen Matthias. (2004). A visual environment for developing context-sensitive term rewriting systems. Proceedings 15th conference on rewriting techniques and applications. Aachen: Springer-Verlag.
MIT Department of Electrical Engineering and Computer Science. 1984 (Sept.). Scheme manual, seventh edition.
Rees Jonathan A., & IV Norman I. Adams. (1982). T: a dialect of lisp or lambda: The ultimate software tool. Pages 114–122 of: ACM conference on Lisp and functional programming. Pittsburgh, Pennsylvania: ACM Press.
Rees Jonathan A., IV Norman I. Adams, & Meehan James R. 1984 (Jan.). The T manual. fourth edn. Yale University Computer Science Department.
Scheme Charter. 2006 (Mar.). Scheme standardization charter.
Sperber Michael, Dybvig R. Kent, Flatt Matthew, van Straaten Anton, Kelsey Richard, Clinger William, & Rees Jonathan. (2007a). Revised6 report on the algorithmic language Scheme (Libraries).
Sperber Michael, Dybvig R. Kent, Flatt Matthew, & van Straaten Anton. (2007b). Revised6 report on the algorithmic language Scheme (Rationale).
Steele Guy Lewis Jr.. 1978 (May). Rabbit: a compiler for Scheme. Tech. rept. MIT Artificial Intelligence Laboratory Technical Report 474. MIT.
Steele Guy Lewis Jr.. (1990). Common Lisp: The language. second edn. Burlington, MA: Digital Press.
Steele Guy Lewis Jr., & Sussman Gerald Jay. 1978 (Jan.). The revised report on Scheme, a dialect of Lisp. Tech. rept. MIT Artificial Intelligence Memo 452. MIT.
Sussman Gerald Jay, & Steele Guy Lewis Jr.. 1975 (Dec.). Scheme: an interpreter for extended lambda calculus. Tech. rept. MIT Artificial Intelligence Memo 349. MIT.
Texas Instruments. 1985 (Nov.). TI Scheme language reference manual. Texas Instruments, Inc. Preliminary version 1.0.
Unicode Consortium, The. (2007). The Unicode standard, version 5.0.0. defined by: The Unicode Standard, Version 5.0 (Boston, MA, Addison-Wesley, 2007. ISBN 0-321-48091-0).
Waddell Oscar. 1999 (Aug.). Extending the scope of syntactic abstraction. Ph.D. thesis, Indiana University.
Waite William M., & Goos Gerhard. (1984). Compiler construction. Springer-Verlag.
Wright Andrew, & Felleisen Matthias. (1994). A syntactic approach to type soundness. Information and computation, 115 (1), 3894. First appeared as Technical Report TR160, Rice University, 1991.
Recommend this journal

Email your librarian or administrator to recommend adding this journal to your organisation's collection.

Journal of Functional Programming
  • ISSN: 0956-7968
  • EISSN: 1469-7653
  • URL: /core/journals/journal-of-functional-programming
Please enter your name
Please enter a valid email address
Who would you like to send this to? *


Full text views

Total number of HTML views: 0
Total number of PDF views: 22 *
Loading metrics...

Abstract views

Total abstract views: 337 *
Loading metrics...

* Views captured on Cambridge Core between September 2016 - 23rd October 2017. This data will be updated every 24 hours.