Hostname: page-component-8448b6f56d-42gr6 Total loading time: 0 Render date: 2024-04-18T12:10:47.429Z Has data issue: false hasContentIssue false
  • English
  • Français

Revised6 Report on the Algorithmic Language Scheme

Part of: JFP Research Articles

Published online by Cambridge University Press:  01 August 2009

MICHAEL SPERBER ,
R. KENT DYBVIG ,
MATTHEW FLATT ,
ANTON VAN STRAATEN ,
ROBBY FINDLER  and
JACOB MATTHEWS
MICHAEL SPERBER
Affiliation:
DeinProgramm (e-mail: sperber@deinprogramm.de)
R. KENT DYBVIG
Affiliation:
Indiana University (e-mail: dyb@cs.indiana.edu)
MATTHEW FLATT
Affiliation:
University of Utah (e-mail: mflatt@cs.utah.edu)
ANTON VAN STRAATEN
Affiliation:
AppSolutions (e-mail: anton@appsolutions.com)
ROBBY FINDLER
Affiliation:
Northwestern University (e-mail: robby@eecs.northwestern.edu)
JACOB MATTHEWS
Affiliation:
University of Chicago (e-mail: jacobm@cs.uchicago.edu)
Rights & Permissions [Opens in a new window]

Abstract

Core share and HTML view are not available for this content. However, as you have access to this content, a full PDF is available via the ‘Save PDF’ action button.

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.

Type
Articles
Information
Journal of Functional Programming , Volume 19 , Supplement S1 , August 2009 , pp. 1 - 301
Copyright
Copyright © Cambridge University Press 2009

References

Abelson, Harold, Sussman, Gerald Jay, & Sussman, Julie. (1996). Structure and interpretation of computer programs. second edn. Cambridge, Mass.: MIT Press.Google Scholar
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), 1–17.CrossRefGoogle Scholar
Barendregt, Henk P. (1984). Introduction to the lambda calculus. Nieuw archief voor wisenkunde, 4 (2), 337–372.Google Scholar
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.Google Scholar
Bawden, Alan, & Rees, Jonathan. (1988). Syntactic closures. Pages 86–95 of: ACM conference on Lisp and functional programming. Snowbird, Utah: ACM Press.Google Scholar
Bradner, Scott. 1997 (Mar.). Key words for use in RFCs to indicate requirement levels.http://www.ietf.org/rfc/rfc2119.txt. RFC 2119.Google Scholar
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.Google Scholar
Clinger, Will, Dybvig, R. Kent, Sperber, Michael, & van Straaten, Anton. (2005). SRFI 76: R6RS records. http://srfi.schemers.org/srfi-76/.Google Scholar
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.Google Scholar
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.Google Scholar
Clinger, William, & Rees, Jonathan. (1986). Revised3 report on the algorithmic language Scheme. SIGPLAN notices, 21 (12), 37–79.Google Scholar
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.Google Scholar
Clinger, William, & Rees, Jonathan. (1991b). Revised4 report on the algorithmic language Scheme. Lisp pointers, IV (3), 1–55.Google Scholar
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.Google Scholar
Clinger, William D, & Sperber, Michael. (2005). SRFI 77: Preliminary proposal for R6RS arithmetic. http://srfi.schemers.org/srfi-77/.Google Scholar
Cohen, Danny. 1980 (Apr.). On holy wars and a plea for peace. http://www.ietf.org/rfc/ien/ien137.txt. Internet Engineering Note 137.Google Scholar
Davis, Mark. (2006). Unicode Standard Annex #29: Text boundaries. http://www.unicode.org/reports/tr29/.Google Scholar
Dybvig, R. Kent. (2003). The Scheme programming language. third edn. Cambridge: MIT Press. http://www.scheme.com/tspl3/.Google Scholar
Dybvig, R. Kent. (2005). Chez Scheme version 7 user's guide. Cadence Research Systems. http://www.scheme.com/csug7/.Google Scholar
Dybvig, R. Kent. (2006). SRFI 93: R6RS syntax-case macros. http://srfi.schemers.org/srfi-93/.Google Scholar
Dybvig, R. Kent, Hieb, Robert, & Bruggeman, Carl. (1992). Syntactic abstraction in Scheme. Lisp and symbolic computation, 5 (4), 295–326.CrossRefGoogle Scholar
Felleisen, Matthias, & Flatt, Matthew. (2003). Programming languages and lambda calculi. http://www.cs.utah.edu/plt/publications/pllc.pdf.Google Scholar
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).Google Scholar
Flatt, Matthew. 2006 (July). PLT MzScheme: Language manual. Rice University, University of Utah. http://download.plt-scheme.org/doc/352/html/mzscheme/.Google Scholar
Flatt, Matthew, & Dybvig, Kent. (2005). SRFI 83: R6RS library syntax. http://srfi.schemers.org/srfi-83/.Google Scholar
Flatt, Matthew, & Feeley, Marc. (2005). SRFI 75: R6RS unicode data. http://srfi.schemers.org/srfi-75/.Google Scholar
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.Google Scholar
Gosling, James, Joy, Bill, Steele, Guy, & Bracha, Gilad. (2005). The Java™ language specification. Third edn. Addison-Wesley.Google Scholar
IEEE754. (1985). IEEE standard 754-1985. IEEE standard for binary floating-point arithmetic. Reprinted in SIGPLAN Notices, 22(2):9-25, 1987.Google Scholar
Kelsey, Richard, Clinger, William, & Rees, Jonathan. (1998). Revised5 report on the algorithmic language Scheme. Higher-order and symbolic computation, 11 (1), 7–105.Google Scholar
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.Google Scholar
Kohlbecker, Eugene E. Jr. 1986 (Aug.). Syntactic extensions in the programming language lisp. Ph.D. thesis, Indiana University.Google Scholar
Leach, P., Mealling, M., & Salz, R. 2005 (July). A Universally Unique IDentifier (UUID) URN namespace. http://www.ietf.org/rfc/rfc4122.txt. RFC 4122.CrossRefGoogle Scholar
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.Google Scholar
Matthews, Jacob, & Findler, Robert Bruce. (2007). An operational semantics for Scheme. Journal of functional programming. From http://www.cambridge.org/journals/JFP/.Google Scholar
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.Google Scholar
MIT Department of Electrical Engineering and Computer Science. 1984 (Sept.). Scheme manual, seventh edition.Google Scholar
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.Google Scholar
Rees, Jonathan A., IV, Norman I. Adams, & Meehan, James R. 1984 (Jan.). The T manual. fourth edn. Yale University Computer Science Department.Google Scholar
Scheme Charter. 2006 (Mar.). Scheme standardization charter. http://www.schemers.org/Documents/Standards/Charter/mar-2006.txt.Google Scholar
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). http://www.r6rs.org/.Google Scholar
Sperber, Michael, Dybvig, R. Kent, Flatt, Matthew, & van Straaten, Anton. (2007b). Revised6 report on the algorithmic language Scheme (Rationale). http://www.r6rs.org/.Google Scholar
Steele, Guy Lewis Jr.. 1978 (May). Rabbit: a compiler for Scheme. Tech. rept. MIT Artificial Intelligence Laboratory Technical Report 474. MIT.Google Scholar
Steele, Guy Lewis Jr.. (1990). Common Lisp: The language. second edn. Burlington, MA: Digital Press.Google Scholar
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.Google Scholar
Sussman, Gerald Jay, & Steele, Guy Lewis Jr.. 1975 (Dec.). Scheme: an interpreter for extended lambda calculus. Tech. rept. MIT Artificial Intelligence Memo 349. MIT.Google Scholar
Texas Instruments. 1985 (Nov.). TI Scheme language reference manual. Texas Instruments, Inc. Preliminary version 1.0.Google Scholar
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).Google Scholar
Waddell, Oscar. 1999 (Aug.). Extending the scope of syntactic abstraction. Ph.D. thesis, Indiana University. http://www.cs.indiana.edu/~owaddell/papers/thesis.ps.gz.Google Scholar
Waite, William M., & Goos, Gerhard. (1984). Compiler construction. Springer-Verlag.CrossRefGoogle Scholar
Wright, Andrew, & Felleisen, Matthias. (1994). A syntactic approach to type soundness. Information and computation, 115 (1), 38–94. First appeared as Technical Report TR160, Rice University, 1991.Google Scholar
Submit a response

Discussions

No Discussions have been published for this article.