论文信息 - Revised4 report on the algorithmic language scheme - 字舞流文

Revised4 report on the algorithmic language scheme

The report gives a defining description of the programming language Scheme. Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy Lewis Steele Jr. and Gerald Jay Sussman. It was designed to have an exceptionally clear and simple semantics and few different ways to form expressions. A wide variety of programming paradigms, including imperative, functional, and message passing styles, find convenient expression in Scheme.

D. H. Bartley | G. Brooks | R. K. Dybvig | C. Hanson | E. Kohlbecker | D. Oxley | K. M. Pitman | John D. Ramsdell | William Clinger | G. J. Sussman | G. L. Steele | H. Abelson | C. T. Haynes | G. J. Rozas | N. I. Adams | D. P. Friedman | R. Halstead | M. Wand | Jonathan Rees | Henry M. Wu | J. Shapiro | G. Steele | G. Sussman | O. Danvy | D. Friedman | J. Philbin | R. Kelsey | P. Hudak | G. Rozas | E. Kohlbecker | R. Halstead | D. Oxley | G. Brooks | C. Hanson | K. Pitman | M. Wand | D. Weise | Robert Hieb | M. Katz | Pavel Curtis | Jeffrey Dalton | Ozan Yigit | J. Sussman | Jim Miller | P. Wagle | Michael R. Blair | H. Abelson | IV N.I.Adams | M. Meyer | G. Carrette | Andy Cromarty | K. Dickey | Andy Freeman | Richard Gabriel | Yekta Gfirsel | Ken Haase | Chris Lindblad | Mark Meyer | Mike Shaft | Perry Wagle

[1] Jonathan Rees,et al. Macros that work , 1991, POPL '91.

[2] Matthias Felleisen,et al. Reasoning with Continuations , 1986, LICS.

[3] John C. Reynolds,et al. Definitional Interpreters for Higher-Order Programming Languages , 1972, ACM '72.

[4] Peter Henderson. Functional geometry , 1982, LFP '82.

[5] Matthias Felleisen,et al. Control delimiters and their hierarchies , 1990, LISP Symb. Comput..

[6] Gerald J. Sussman,et al. Design of a LISP-based microprocessor , 1980, CACM.

[7] Daniel P. Friedman,et al. Embedding continuations in procedural objects , 1987, TOPL.

[8] Olin Shivers,et al. Control flow analysis in scheme , 1988, PLDI '88.

[9] Mitchell Wand. Finding the source of type errors , 1986, POPL '86.

[10] Drew McDermott,et al. An efficient environment allocation scheme in an interpreter for a lexically-scoped LISP , 1980, LISP Conference.

[11] Pavel Curtis,et al. A module system for scheme , 1990, LISP and Functional Programming.

[12] Mitchell Wand,et al. Continuation-Based Multiprocessing , 1980, High. Order Symb. Comput..

[13] Robert Hieb,et al. Representing control in the presence of first-class continuations , 1990, PLDI '90.

[14] Gerald Jay Sussman,et al. Lambda: The Ultimate Imperative , 1976 .

[15] David H. Bartley,et al. The implementation of PC Scheme , 1986, LFP '86.

[16] Marc Feeley,et al. A parallel virtual machine for efficient scheme compilation , 1990, LISP and Functional Programming.

[17] Jr. Guy L. Steele,et al. Rabbit: A Compiler for Scheme , 1978 .

[18] Kent M. Pitman,et al. Special forms in Lisp , 1980, LISP Conference.

[19] Paul Hudak,et al. ORBIT: an optimizing compiler for scheme , 1986, SIGPLAN '86.

[20] Daniel P. Friedman,et al. Scheme and the art of programming , 1983 .

[21] Matthias Felleisen,et al. A calculus for assignments in higher-order languages , 1987, POPL '87.

[22] Uwe F. Pleban,et al. The runtime environment for Scheme, a Scheme implementation on the 88000 , 1989, ASPLOS III.

[23] Robert Hieb,et al. A variable-arity procedural interface , 1988, LFP '88.

[24] B. J. Mailloux,et al. Report on the Algorithmic Language , 1971 .

[25] Gerald Jay Sussman,et al. An Interpreter for Extended Lambda Calculus: SCHEME, , 1975 .

[26] Guy L. Steele,et al. An overview of COMMON LISP , 1982, LFP '82.

[27] Gerald Jay Sussman,et al. The Revised Report on SCHEME: A Dialect of LISP. , 1978 .

[28] Uwe F. Pleban,et al. A semantic comparison of LISP and SCHEME , 1980, LISP Conference.

[29] Richard M. Stallman. Phantom Stacks: If You Look Too Hard, They Aren't There , 1980 .

[30] Guy L. Steele. Macaroni is better than spaghetti , 1977, SIGART Newsl..

[31] Matthias Felleisen,et al. A Syntactic Theory of Sequential Control , 1987, Theor. Comput. Sci..

[32] Daniel P. Friedman,et al. Towards a Facility for Lexically Scoped, Dynamic Mutual Recursion in Scheme , 1990, Comput. Lang..

[33] Daniel P. Friedman,et al. Programming with Continuations , 1984 .

[34] Mitchell Wand,et al. Reification: Reflection without metaphysics , 1984, LFP '84.

[35] Friedrich L. Bauer,et al. Report on the algorithmic language ALGOL 60 , 1960, Commun. ACM.

[36] Norman I. Adams,et al. The Revised Revised Report on Scheme or An Uncommon Lisp , 1985 .

[37] Mitchell Wand,et al. Compiling Lambda-Expressions Using Continuations and Factorizations , 1978, Comput. Lang..

[38] Guy L. Steele,et al. LAMBDA: The Ultimate Declarative , 1976 .

[39] William D. Clinger,et al. Implementation strategies for continuations , 1988, LFP '88.

[40] G. Steele. Macaroni is better than spaghetti , 1977, Artificial Intelligence and Programming Languages.

[41] Matthias Felleisen,et al. Hygienic macro expansion , 1986, LFP '86.

[42] Matthias Felleisen. Reflections on Landins's J-Operator: A Partly Historical Note , 1987, Comput. Lang..

[43] Guy L. Steele. Debunking the “expensive procedure call” myth or, procedure call implementations considered harmful or, LAMBDA: The Ultimate GOTO , 1977, ACM '77.

[44] Gerald Jay Sussman,et al. The Art of the Interpreter or, The Modularity Complex (Parts Zero, One, and Two) , 1978 .

[45] Jonathan Rees,et al. T: a dialect of Lisp or LAMBDA: The ultimate software tool , 1982, LFP '82.

[46] Christopher T. Haynes,et al. Logic Continuations , 1986, J. Log. Program..

[47] Jonathan Rees,et al. Object-oriented programming in scheme , 1988, LFP '88.

[48] Mitchell Wand,et al. Obtaining Coroutines with Continuations , 1986, Comput. Lang..

[49] P. J. Landin,et al. Correspondence between ALGOL 60 and Church's Lambda-notation , 1965, Commun. ACM.

[50] Jonathan Rees,et al. Syntactic closures , 1988, LISP and Functional Programming.

[51] Matthias Felleisen,et al. A Reduction Semantics for Imperative Higher-Order Languages , 1987, PARLE.

[52] Microcomputer Standards Subcommittee. IEEE standard for the Scheme programming language , 1991 .

[53] Daniel P. Friedman,et al. Abstracting Timed Preemption with Engines , 1987, Comput. Lang..

[54] Daniel P. Friedman,et al. The little LISPer , 1974 .

[55] John McCarthy,et al. Recursive functions of symbolic expressions and their computation by machine, Part I , 1959, Commun. ACM.

[56] E E Kohlbecker,et al. Syntactic extensions in the programming language LISP , 1986 .

[57] Marc Feeley,et al. Using Closures for Code Generation , 1987, Comput. Lang..

[58] Matthias Felleisen,et al. Abstract continuations: a mathematical semantics for handling full jumps , 1988, LISP and Functional Programming.

[59] Robert Hieb,et al. Engines From Continuations , 1989, Comput. Lang..

[60] E. Lohse,et al. A Correspondence Between ALGOL 60 and Church's Lambda- Notation: Part I* , 1965 .

[61] Mitchell Wand,et al. A scheme for a higher-level semantic algebra , 1986 .

[62] Gerald J. Sussman,et al. The dream of a lifetime: A lazy variable extent mechanism , 1980, LISP Conference.

[63] William D. Clinger. The scheme 311 compiler an exercise in denotational semantics , 1984, LFP '84.

[64] Guy L. Steele,et al. Common Lisp the Language , 1984 .

[65] Mitchell Wand,et al. The mystery of the tower revealed: a non-reflective description of the reflective tower , 1986, LFP '86.

[66] Daniel P. Friedman,et al. Engines build process abstractions , 1984, LFP '84.

[67] Daniel P. Friedman,et al. Constraining control , 1985, POPL.

[68] Kent M. Pitman. Exceptional Situations in Lisp , 1985 .

[69] Michael Eisenberg,et al. Programming in MacScheme , 1990 .

[70] Joseph E. Stoy,et al. Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory , 1981 .

[71] Matthias Felleisen,et al. A Closer Look at Export and Import Statements , 1986, Comput. Lang..

[72] R. Kent Dybvig,et al. Expansion-passing style: A general macro mechanism , 1988, LISP Symb. Comput..

[73] Harold Abelson,et al. LISP: a language for stratified design , 1987 .

[74] Mitchell Wand,et al. Continuation-Based Program Transformation Strategies , 1980, JACM.

[75] Gerald Jay Sussman,et al. Scheme-79 - Lisp on a Chip , 1981, Computer.

[76] William D. Clinger. How to Read Floating-Point Numbers Accurately , 1990, PLDI.

[77] Mitchell Wand,et al. The mystery of the tower revealed: A nonreflective description of the reflective tower , 1988, LISP Symb. Comput..

[78] Friedrich L. Bauer,et al. Revised report on the algorithm language ALGOL 60 , 1963, CACM.

[79] Robert Hieb,et al. Continuations and concurrency , 1990, PPOPP '90.

[80] Amitabh Srivastava,et al. An(other) Integration of Logic and Functional Programming , 1985, SLP.

[81] Harold Abelson,et al. Structure and interpretation of computer programs / Harold Abelson, Gerald Jay Sussman, Julie Sussman , 1985 .

[82] Ansi Ieee,et al. IEEE Standard for Binary Floating Point Arithmetic , 1985 .

[83] Uwe F. Pleban,et al. The Run-Time Environment for Screme, A Scheme Implementation on the 88000 , 1989, ASPLOS.

[84] William D. Clinger,et al. Semantics of Scheme , 1988 .

[85] Paul Penfield,et al. Principal values and branch cuts in complex APL , 1981, APL '81.

[86] Gerald J. Sussman,et al. Structure and interpretation of computer programs , 1985, Proceedings of the IEEE.