Skip to main content

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? *


Altmetric attention score

Full text views

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

Abstract views

Total abstract views: 407 *
Loading metrics...

* Views captured on Cambridge Core between September 2016 - 19th March 2018. This data will be updated every 24 hours.