脱関数化を実用する 8 - shiatsumat/fp-papers GitHub Wiki

##参照

[1] Andrew W. Appel and Trevor Jim. Continuation-passing, closure-passing style. In Michael J. O'Donnell and Stuart Feldman, editors, Proceedings of the Sixteenth Annual ACM Symposium on Principles of Programming Languages, pages 293-302, Austin, Texas, January 1989. ACM Press.

[2] Anindya Banerjee, Nevin Heintze, and Jon G. Riecke. Semantics-based design and correctness of control-flow analysis-based program transformations. Unpublished, March 2001.

[3] Henk Barendregt. The Lambda Calculus: Its Syntax and Semantics, volume 103 of Studies in Logic and the Foundation of Mathematics. North-Holland, 1984. Revised edition.

[4] Jeffrey M. Bell, Françoise Bellegarde, and James Hook. Type-driven defunctionalization. In Mads Tofte, editor, Proceedings of the 1997 ACM SIG-PLAN International Conference on Functional Programming, pages 25-37, Amsterdam, The Netherlands, June 1997. ACM Press.

[5] Anders Bondorf. Self-Applicable Partial Evaluation. PhD thesis, DIKU, Computer Science Department, University of Copenhagen, Copenhagen, Denmark, 1990. DIKU Rapport 90/17.

[6] Urban Boquist. Code Optimization Techniques for Lazy Functional Languages. PhD thesis, Department of Computing Science, Chalmers University of Technology, Göteborg University, Göteborg, Sweden, April 1999.

[7] Henry Cejtin, Suresh Jagannathan, and Stephen Weeks. Flow-directed closure conversion for typed languages. In Smolka [[47](脱関数化を実用する 8#reference47)], pages 56-71.

[8] Weidong Chen, Michael Kifer, and David S. Warren. Hilog: A foundation for higher-order logic programming. The Journal of Logic Programming, 15(3):187-230, February 1993.

[9] Alonzo Church. The Calculi of Lambda-Conversion. Princeton University Press, 1941.

[10] Olivier Danvy. Back to direct style. Science of Computer Programming, 22(3):183-195, 1994.

[11] Olivier Danvy. Formalizing implementation strategies for first-class continuations. In Smolka [[47](脱関数化を実用する 8#reference47)], pages 88-103.

[12] Olivier Danvy and Andrzej Filinski. Representing control, a study of the CPS transformation. Mathematical Structures in Computer Science, 2(4):361-391, 1992.

[13] Olivier Danvy, Bernd Grobauer, and Morten Rhiger. A unifying approach to goal-directed evaluation. New Generation Computing, 20(1), 2001. To appear. A preliminary version is available in the proceedings of SAIG 2001.

[14] Olivier Danvy and Julia L. Lawall. Back to direct style II: First-class continuations. In William Clinger, editor, Proceedings of the 1992 ACM Conference on Lisp and Functional Programming, LISP Pointers, Vol. V, No. 1, pages 299-310, San Francisco, California, June 1992. ACM Press.

[15] Olivier Danvy and Frank Pfenning. The occurrence of continuation parameters in CPS terms. Technical report CMU-CS-95-121, School of Computer Science, Carnegie Mellon University, Pittsburgh, Pennsylvania, February 1995.

[16] Edsger W. Dijkstra. Recursive programming. In Saul Rosen, editor, Programming Systems and Languages, chapter 3C, pages 221-227. McGraw-Hill, New York, 1960.

[17] R. Kent Dybvig. Three Implementation Models for Scheme. PhD thesis, Department of Computer Science, University of North Carolina at Chapel Hill, Chapel Hill, North Carolina, April 1987. Technical Report #87-011.

[18] Leonidas Fegaras. lambda-DB. Available online at http://lambda.uta.edu/lambda-DB/manual/, 1999-2001.

[19] Matthias Felleisen. The Calculi of λ-v-CS Conversion: A Syntactic Theory of Control and State in Imperative Higher-Order Programming Languages. PhD thesis, Department of Computer Science, Indiana University, Bloomington, Indiana, August 1987.

[20] Daniel P. Friedman, Mitchell Wand, and Christopher T. Haynes. Essentials of Programming Languages, second edition. The MIT Press, 2001.

[21] Jean-Yves Girard. Locus solum. Mathematical Structures in Computer Science, 11(3), 2001. To appear.

[22] Joseph A. Goguen, James W. Thatcher, and Eric G. Wagner. An initial algebra approach to the specification, correctness and implementation of abstract data types. In Current Trends in Programming Methodology, volume IV, pages 80-149. Prentice-Hall, 1978.

[23] Adele Goldberg and David Robson. Smalltalk-80: The Language and its Implementation. Addison-Wesley, 1983.

[24] Mayer Goldberg. Recursive Application Survival in the λ-Calculus. PhD thesis, Computer Science Department, Indiana University, Bloomington, Indiana, May 1996.

[25] Robert Harper. Proof-directed debugging. Journal of Functional Programming, 9(4):463-469, July 1999.

[26] John E. Hopcroft and Jeffrey D. Ullman. Introduction to Automata Theory, Languages, and Computation. Addison-Wesley, 1979.

[27] John Hughes. Super combinators: A new implementation method for applicative languages. In Daniel P. Friedman and David S. Wise, editors, Conference Record of the 1982 ACM Symposium on Lisp and Functional Programming, pages 1-10, Pittsburgh, Pennsylvania, August 1982. ACM Press.

[28] John Hughes. A novel representation of lists and its application to the function “reverse”. Information Processing Letters, 22(3):141-144, 1986.

[29] Thomas Johnsson. Lambda lifting: Transforming programs to recursive equations. In Jean-Pierre Jouannaud, editor, Functional Programming Languages and Computer Architecture, number 201 in Lecture Notes in Computer Science, pages 190-203, Nancy, France, September 1985. Springer-Verlag.

[30] Peter J. Landin. The mechanical evaluation of expressions. Computer Journal, 6:308-320, 1964.

[31] Chris Mellish and Steve Hardy. Integrating Prolog in the POPLOG environment. In John A. Campbell, editor, Implementations of PROLOG, pages 147-162. Ellis Horwood, 1984.

[32] Yasuhiko Minamide, Greg Morrisett, and Robert Harper. Typed closure conversion. In Guy L. Steele Jr., editor, Proceedings of the Twenty-Third Annual ACM Symposium on Principles of Programming Languages, pages 271-283, St. Petersburg Beach, Florida, January 1996. ACM Press.

[33] Torben Æ. Mogensen. Efficient self-interpretation in lambda calculus. Journal of Functional Programming, 2(3):345-363, 1992.

[34] Tim Nicholson and Norman Y. Foo. A denotational semantics for Prolog. ACM Transactions on Programming Languages and Systems, 11(4):650-665, 1989.

[35] Lasse R. Nielsen. A denotational investigation of defunctionalization. Progress report (superseded by [[36](脱関数化を実用する 8#reference36)]), BRICS PhD School, University of Aarhus, June 1999.

[36] Lasse R. Nielsen. A denotational investigation of defunctionalization. Technical Report BRICS RS-00-47, DAIMI, Department of Computer Science, University of Aarhus, Aarhus, Denmark, December 2000.

[37] Simon L. Peyton Jones. The Implementation of Functional Programming Languages. Prentice Hall International Series in Computer Science. Prentice-Hall International, 1987.

[38] Simon L. Peyton Jones and David R. Lester. Implementing Functional Languages. Prentice Hall International Series in Computer Science. Prentice-Hall, 1992.

[39] Jeff Polakow. Linear logic programming with ordered contexts. In Maurizio Gabbrielli and Frank Pfenning, editors, Proceedings of the Second International Conference on Principles and Practice of Declarative Programming, pages 68-79, Montréal, Canada, September 2000. ACM Press.

[40] Jeff Polakow and Kwangkeun Yi. Proving syntactic properties of exceptions in an ordered logical framework. In Herbert Kuchen and Kazunori Ueda, editors, Fifth International Symposium on Functional and Logic Programming, number 2024 in Lecture Notes in Computer Science, pages 61-77, Tokyo, Japan, March 2001. Springer-Verlag.

[41] Todd A. Proebsting. Simple translation of goal-directed evaluation. In Ron K. Cytron, editor, Proceedings of the ACM SIGPLAN'97 Conference on Programming Languages Design and Implementation}, SIGPLAN Notices, Vol. 32, No 5, pages 1-6, Las Vegas, Nevada, June 1997. ACM Press.

[42] John C. Reynolds. The essence of Algol. In van Vliet, editor, International Symposium on Algorithmic Languages, pages 345-372, Amsterdam, The Netherlands, 1982. North-Holland.

[43] John C. Reynolds. Definitional interpreters for higher-order programming languages. Higher-Order and Symbolic Computation, 11(4):363-397, 1998. Reprinted from the proceedings of the 25th ACM National Conference (1972).

[44] John C. Reynolds. Definitional interpreters revisited. Higher-Order and Symbolic Computation, 11(4):355-361, 1998.

[45] John C. Reynolds. Theories of Programming Languages. Cambridge University Press, 1998.

[46] Olin Shivers. Control-Flow Analysis of Higher-Order Languages or Taming Lambda. PhD thesis, School of Computer Science, Carnegie Mellon University, Pittsburgh, Pennsylvania, May 1991. Technical Report CMUCS-91-145.

[47] Gert Smolka, editor. Proceedings of the Ninth European Symposium on Programming, number 1782 in Lecture Notes in Computer Science, Berlin, Germany, March 2000. Springer-Verlag.

[48] Paul A. Steckler and Mitchell Wand. Lightweight closure conversion. ACM Transactions on Programming Languages and Systems, 19(1):48-86, 1997.

[49] Guy L. Steele Jr. Rabbit: A compiler for Scheme. Technical Report AI-TR-474, Artificial Intelligence Laboratory, Massachusetts Institute of Technology, Cambridge, Massachusetts, May 1978.

[50] Christopher Strachey. Fundamental concepts in programming languages. Higher-Order and Symbolic Computation, 13(1/2):1-49, 2000.

[51] Andrew Tolmach and Dino P. Oliva. From ML to Ada: Strongly-typed language interoperability via source translation. Journal of Functional Programming, 8(4):367-412, 1998.

[52] David A. Turner. A new implementation technique for applicative languages. Software―Practice and Experience, 9(1):31-49, 1979.

[53] Philip Wadler. Deforestation: Transforming programs to eliminate trees. Theoretical Computer Science, 73(2):231-248, 1989.

[54] Mitchell Wand. Continuation-based program transformation strategies. Journal of the ACM, 27(1):164-180, January 1980.

[55] Daniel C. Wang and Andrew W. Appel. Type-safe garbage collectors. In Hanne Riis Nielson, editor, Proceedings of the Twenty-Eighth Annual ACM Symposium on Principles of Programming Languages, pages 166-178, London, United Kingdom, January 2001. ACM Press.

[56] Glynn Winskel. The Formal Semantics of Programming Languages. Foundation of Computing Series. The MIT Press, 1993.

[57] Yong Xiao, Amr Sabry, and Zena M. Ariola. From syntactic theories to interpreters: Automating proofs of decomposition lemma. Higher-Order and Symbolic Computation, 14(4), 2001. To appear.