The call-by-need lambda calculus

Journal of Functional Programming

Volumn 8, Issue 3, 1998, Pages 275-317

  Maraist, John ^a   Odersky, Martin ^a   Wadler, Philip ^b  

^a UNIVERSITY OF SOUTH AUSTRALIA   (Australia)

^b LUCENT TECHNOLOGIES   (United States)

Author keywords

[No Author keywords available]

Indexed keywords

EID: 0032389647     PISSN: 09567968     EISSN: None     Source Type: Journal    
DOI: 10.1017/S0956796898003037     Document Type: Article

References (40)

1. Abadi, M., Cardelli, L., Curien, P.-L. and Lévy, J.-J. (1990) Explicit substitutions. Proc. 18th ACM Symposium on Principles of Programming Languages, San Francisco, CA. ACM Press.
2. Abramsky, S. (1990) The Lazy Lambda Calculus, Chapter 4, pp. 65-116. The UT Year of Programming Series. Addison-Wesley.
3. Ariola, Z. M. and Blom, S. (1997) Cyclic lambda calculi. Proc. Third Int. Sym. on Theoretical Aspects of Computer Science (TACS'97), Sendai, Japan.
4. Ariola, Z. M. and Felleisen, M. (1994) The call-by-need lambda calculus. Technical Report CIS-TR-94-23, Department of Computer Science, University of Oregon.
5. Ariola, Z. M., Felleisen, M., Maraist, J., Odersky, M. and Wadler, P. (1995) A call-by-need lambda calculus. In Proc. 22nd Sym. on Principles of Programming Languages, San Francisco, CA. ACM Press.
6. Ariola, Z. M. and Klop, J. W. (1994) Cyclic lambda graph rewriting. In Proc. LICS'94, Eighth IEEE Symposium on Logic in Computer Science, Paris.
7. Barber, A. (1995) DILL - dual intuitionistic linear logic. Draft paper, available from the author (October).
8. Barendregt, H. (1981) The Lambda Calculus: Its Syntax and Semantics, volume 103 of Studies in Logic and the Foundations of Mathematics. North-Holland.
9. Benaisaissa, Z.-El-A., Lescanne, P. and Rose, K. H. (1996) Modelling sharing and recursion for weak reduction strategies using explicit substitution. Proc. PLILP'96, Eighth Int. Sym. on Programming Languages, Implementations, Logics and Programs, Aix-la-Chapelle, Germany.
10. Church, A. (1941) The Calculi of Lambda Conversion. Princeton University Press.
11. Field, J. (1990) On laziness and optimality in lambda interpreters: Tools for specification and analysis. Proc. 18th ACM Symposium on Principles of Programming Languages, San Francisco, CA. ACM Press.
12. Girard, J.-Y. (1987) Linear logic. Theoretical Computer Science, 50: 1-102.
13. Hughes, R. J. M. (1983) The Design and Implementation of Programming Languages. Doctoral Thesis, Programming Research Group, Oxford University.
14. Jacobs, B. (1994) Semantics of weakening and contraction. Annals of Pure and Applied Logic, 69: 73-106.
15. Johnsson, T. (1984) Efficient compilation of lazy evaluation. Proceedings of the 1984 ACM SIGPLAN Conference on Compiler Construction, New York, ACM.
16. Josephs, M. B. (1989). The semantics of lazy functional languages. Theoretical Computer Science, 68: 105-111.
17. Koopman, P. J., Jr. and Lee, P. (1989) A fresh look at combinator graph reduction. Proc. SIGPLAN'89, ACM Conference on Programming Language Design and Implementation. ACM Press.
18. Lamping, J. (1990) An algorithm for optimal lambda calculus reduction. Proc. 17th ACM Symposium on Principles of Programming Languages, San Francisco, CA. ACM Press.
19. Launchbury, J. (1993) A natural semantics for lazy evaluation. In Proc. 21st ACM Symposium on Principles of Programming Languages, Charleston, SC. ACM Press.
20. Lévy, J.-J. (1980) Optimal reductions in the lambda-calculus. In: J. P. Seldin and J. R. Harding, editors, To H. B. Curry: Essays on Combinatory Logic, Lambda Calculus and Formalism, pp. 159-191. Academic Press.
21. Mackie, I. (1994) The Geometry of Implementation. Doctoral Thesis, Imperial College, London.
22. Maraist, J., Odersky, M., Turner, D. N. and Wadler, P. (1995) Call-by-name, call-by-value, call-by-need and the linear lambda calculus. Proc. MFPS'95, Eleventh Conference on the Mathematical Foundations of Programming Semantics, New Orleans, LA. Elsevier, Electronic Notes in Theoretical Computer Science 1.
23. Maraist, J. (1997) Comparing Reduction Strategies in Resource-Conscious Lambda Calculi. Doctoral thesis, University of Karlsruhe.
24. Maraist, J., Odersky, M. and Wadler, P. (1994) The call-by-need lambda calculus (unabridged). Technical Report 28/94, Universität Karlsruhe.
25. Maranget, L. (1991) Optimal derivations in weak lambda-calculi and in orthogonal term rewriting systems. Proc. POPL'91, 19th ACM Symposium on Principles of Programming Languages, Orlando, FL, pp. 255-269. ACM Press.
26. Moggi, E. (1991) Notions of computation and monads. Information and Computation, 93: 55-92.
27. Mossin, C., Turner, D. N. and Wadler, P. (1995) Once upon a type. In FPCA'95: Conference on Functional Programming Languages and Computer Architecture, La Jolla, CA. ACM Press.
28. Ong, C.-H. L. (1988) Fully abstract models of the lazy lambda calculus. Proceedings of the 29th Symposium on Foundations of Computer Science, pp. 368-376. IEEE.
29. Nederpelt, R. P. (1973) Strong Normalization in a Typed Lambda Calculus with Lambda Structured Typed. Doctoral thesis, Department of Mathematics and Computer Science, Eindhoven University of Technology.
30. Peyton Jones, S. L. (1987) The Implementation of Functional Programming Languages. International Series in Computer Science. Prentice Hall.
31. Peyton Jones, S. L. (1992) Implementing lazy functional languages on stock hardware: the Spineless Tagless G-machine. Journal of Functional Programming, 2(2): 127-202.
32. Plotkin, G. D. (1975) Call-by-name, call-by-value and the λ calculus. Theoretical Computer Science, 1: 125-159.
33. Purushothaman, S. and Seaman, J. (1992) An adequate operational semantics of sharing in lazy evaluation. In: B. Krieg-Brückner, editor, Proc. ESOP'92, Fourth European Symposium on Programming: Lecture Notes in Computer Science 582, pp. 435-450. Springer-Verlag.
34. Rose, K. H. (1993) Explicit cyclic substitution. Technical report D-166, Department of Computer Science, University of Copenhagen (DIKU).
35. Sansom, P. M. and Peyton Jones, S. L. (1995) Time and space profiling for non-strict, higher-order functional languages. Proc. 22nd Sym. on Principles of Programming Languages, San Francisco, CA. ACM Press.
36. Turner, D. A. (1979) A new implementation technique for applicative programming languages. Software - Practice and Experience, 9, 31-49.
37. Wadler, P. (1993) A syntax for linear logic. Proc. MFPS'93, Ninth International Conference on the Mathematical Foundations of Programming Semantics, New Orleans, LA. Springer-Verlag.
38. Wadler, P. (1993) A taste of linear logic. In Proc. Mathematical Foundations of Computer Science, Gdansk, Poland. Springer-Verlag.
39. Wadsworth, C. P. (1971) Semantics and Pragmatics of the Lambda Calculus. PhD thesis, Oxford University.
40. Yoshida, N. (1993) Optimal reduction in weak-lambda-calculus with shared environments. FPCA'93: Conference on Functional Programming Languages and Computer Architecture, Copenhagen, Denmark. ACM Press.