From ML to Ada: Strongly-typed language interoperability via source translation

Journal of Functional Programming

Volumn 8, Issue 4, 1998, Pages 367-412

  Tolmach, Andrew ^a   Oliva, Dino P ^b,c  

^a Portland State University   (United States)

^b OREGON HEALTH AND SCIENCE UNIVERSITY   (United States)

^c LUCENT TECHNOLOGIES   (United States)

Author keywords

[No Author keywords available]

Indexed keywords

EID: 0032281046     PISSN: 09567968     EISSN: None     Source Type: Journal    
DOI: 10.1017/S0956796898003086     Document Type: Article

References (58)

1. Appel, A. W. (1992) Compiling with Continuations. Cambridge University Press.
2. Appel, A. W. and Jim, T. (1989) Continuation-passing, closure-passing style. 16th ACM Symp. on Principles of Programming Languages, pp. 293-302, New York. ACM Press.
3. Appel, A. W. and Jim, T. (1997) Shrinking lambda expressions in linear time. J. Functional Programming 7(5), 515-540.
4. Baker, H. G. (1990) Unify and conquer (garbage collection, updating, aliasing,...) in functional languages. Proc. 1990 ACM Conference on Lisp and Functional Programming, pp. 218-226.
5. Bell, J. M. (1994) An implementation of Reynold's defunctionalization method for a modern functional language. Master's thesis, Oregon Graduate Institute.
6. Bell, J. M., Bellegarde, F. and Hook, J. (1997) Type-driven defunctionalization. Proc. 2nd International Conference on Functional Programming, pp. 25-37.
7. Bellegarde, F. and Hook, J. (1994) Substitution: A formal methods case study using monads and transformations. Science of Computer Programming, 23(2-3), 287-311.
8. Boehm, H.-J. and Weiser, M. (1988) Garbage collection in an uncooperative environment. Software-Practice and Experience, 18(9), 807-820.
9. Bondorf, A. (1990) Automatic autoprojection of higher order recursive equations. Science of Computer Programming, 17(1-3), 3-34.
10. Bondorf, A. and Jorgensen, J. (1993) Efficient analyses for realistic off-line partial evaluation. J. Functional Programming, 3(3), 315-346.
11. Cardelli, L. (1984) Compiling a functional language. Proc. 1984 ACM Conference on Lisp and Functional Programming, pp. 208-217.
12. Cardelli, L. (1987) Basic polymorphic typechecking. Science of Computer Programming, 8, 147-172.
13. Chailloux, E. (1992) An efficient way of compiling ML to C. Proc. ACM Workshop on ML and its Applications, pp. 37-51.
14. Chin, W.-N. and Darlington, J. (1996) A higher order removal method. Lisp and Symbolic Computation, 9(4), 287-322.
15. Cridlig, R. (1992) An optimizing ML to C compiler. Proc. ACM Workshop on ML and its Applications, pp. 28-36.
16. Damas, L. (1984) Type Assignment in Programming Languages. PhD thesis, University of Edinburgh.
17. Flanagan, C., Sabry, A., Duba, B. F. and Felleisen, M. (1993) The essence of compiling with continuations. SIGPLAN Notices, 28(6), 237-247. (Proc. ACM SIGPLAN '93 Conference on Programming Language Design and Implementation.)
18. Flanagan, C., Sabry, A., Duba, B. F. and Felleisen, M. (1993) The essence of compiling with continuations. SIGPLAN Notices, 28(6), 237-247. (Proc. ACM SIGPLAN '93 Conference on Programming Language Design and Implementation.)
19. Hindley, R. (1969) The principal type-scheme of an object in combinatory logic. Trans. Am. Math. Soc., 146, 29-60.
20. Huelsbergen, L. (1996) A portable C interface for Standard ML of New Jersey. Available at http://cm.bell-labs.com/who/lorenz/papers/smlnj-c.ps.
21. Jagannathan, S. and Wright, A. K. (1996) Flow-directed inlining. Proc. ACM Conference on Programming Language Design and Implementation, pp. 193-205.
22. Jones, M. P. (1994) Dictionary-free overloading by partial evaluation. Proc. PEPM '94 ACM SIGPLAN Workshop on Partial Evaluation and Semantics-Based Program Manipulation, pp. 107-117.
23. Kelsey, R. A. (1995) A correspondence between continuation passing style and static single assignment form. Proc. ACM SIGPLAN Workshop on Intermediate Representations, pp. 13-22.
24. Kieburtz, R. B., Bellegarde, F., Bell, J., Hook, J., Lewis, J., Oliva, D., Sheard, T., Walton, L. and Zhou, T. (1995) Calculating software generators from solution specifications. TAPSOFT'95: Lecture Notes in Computer Science 915, pp. 546-560. Springer-Verlag.
25. Koch, M. and Olesen, T. H. (1996) Compiling a higher-order call-by-value functional programming language to a RISC using a stack of regions. Master's thesis, University of Copenhagen.
26. Kranz, D., Kelsey, R., Rees, J., Hudak, P., Philbin, J. and Adams, N. (1986) Orbit: An optimizing compiler for Scheme. SIGPLAN Notices, 21(7), 219-233. (Proc. ACM SIGPLAN '86 Symposium on Compiler Construction.)
27. Kranz, D., Kelsey, R., Rees, J., Hudak, P., Philbin, J. and Adams, N. (1986) Orbit: An optimizing compiler for Scheme. SIGPLAN Notices, 21(7), 219-233. (Proc. ACM SIGPLAN '86 Symposium on Compiler Construction.)
28. Lawall, J. L. and Danvy, O. (1993) Separating stages in the continuation-passing style transformation. Conference Record of the Twentieth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pp. 124-136, Charleston, SC.
29. Leroy, X. (1991) The ZINC experiment: an economical implementation of the ML language. Technical Report 117, INRIA, France.
30. Leroy, X. (1992) Unboxed object and polymorphic typing. Conference Record of the Nineteenth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pp. 177-188.
31. Leroy, X. (1997) The Objective Caml System: Documentation and User's Manual, Version 1.07. INRIA, France.
32. Milner, R. (1978) A theory of type polymorphism in programming. J. Computer and System Sciences, 17, 348-375.
33. Milner, R., Tofte, M., Harper, R. and MacQueen, D. (1997) The Definition of Standard ML (Revised). MIT Press.
34. Minamide, Y., Morrisett, G. and Harper, R. (1996) Typed closure conversion. Conference Record of POPL '96: 23rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pp. 271-283.
35. Morrisett, G. (1995) Compiling with Types. PhD thesis, Carnegie Mellon University. (Available as TR CMU-CS-95-226.)
36. Morrisett, G., Felleisen, M. and Harper, R. (1995) Abstract models of memory management. FPCA '95 SIGPLAN-SIGARCH-WG2.8 Conference on Functional Programming Languages and Computer Architecture, pp. 66-77.
37. Palsberg, J. (1995) Closure analysis in constraint form. ACM Trans. Programming Languages and Systems, 17(1), 47-62.
38. Peyton Jones, S. L. (1992) Implementing lazy functional languages on stock hardware: the Spineless Tagless G-machine. J. Functional Programming, 127-202.
39. Peyton Jones, S. L. (1996) Compilation by transformation: A report from the trenches. Euro. Symposium on Programming (ESOP'96): Lecture Notes in Computer Science 1058, pp. 18-40. Springer-Verlag.
40. Peyton Jones, S. L., Hall, C., Hammond, K., Partain, W. and Wadler, P. (1993) The Glasgow Haskell compiler: a technical overview. Proc. UK Joint Framework for Information Technology (JFIT) Technical Conference, Keele.
41. Peyton Jones, S. L., Nordin, T. and Reid, A. (1997) Green Card: A foreign language interface for Haskell. Proc. ACM SIGLAN Haskell Workshop.
42. Reade, C. (1989) Elements of Functional Programming. Addison-Wesley.
43. Reynolds, J. C. (1972) Definitional interpreters for higher-order programming languages. In ACM National Conference, pp. 717-740. ACM.
44. Sestoft, P. (1988) Replacing function parameters by global variables. Master's thesis, University of Copenhagen. DIKU Master's thesis no. 254.
45. Shivers, O. (1991) Control-Flow Analysis of Higher-Order Languages. PhD thesis, Carnegie-Mellon University, Pittsburgh, PA. CMU-CS-91-145.
46. Steele, G. L. (1978) Rabbit: a compiler for Scheme. Technical Report AI-TR-474, MIT, Cambridge, MA.
47. Talpin, J.-P. and Jouvelot, P. (1992) Polymorphic type, region, and effect inference. J. Functional Programming, 2(3), 245-272.
48. Tarditi, D. (1996) Design and Implementation of Code Optimizations for a Type-Directed Compiler for Standard ML. PhD thesis, Carnegie Mellon University. Technical Report CMU-CS-97-108.
49. Tarditi, D., Lee, P. and Acharya, A. (1992). No assembly required: Compiling Standard ML to C. ACM Letters on Programming Languages and Systems, 1(2), 161-177.
50. Tarditi, D., Morrisett, G., Cheng, P., Stone, C., Harper, R. and Lee, P. (1996) TIL: A type-directed optimizing compiler for ML. Proc. ACM SIGPLAN '96 Conference on Programming Language Design and Implementation, pp. 181-192.
51. Tofte, M., Birkedal, L., Elsman, M., Hallenberg, N., Olesen, T. H., Sestoft, P. and Bertelsen, P. (1997) Programming with regions in the ML Kit. Technical Report DIKU-TR-97/12, University of Copenhagen Department of Computer Science (DIKU).
52. Tofte, M. and Talpin, J.-P. (1997) Region-based memory management. Information and Computation, 132(2), 109-176.
53. Tolmach, A. (1997) Combining closure conversion with closure analysis using algebraic types. Workshop on Types in Compilation TIC97. Boston College Computer Science Technical Report BCCS-97-03.
54. Volpano, D. and Kieburtz, R. B. (1985) Software templates. Proc. 8th International Conference on Software Engineering, pp. 55-60. IEEE.
55. Volpano, D. and Kieburtz, R. B. (1989) The templates approach to software reuse. In: Biggersstaff, T. J. and Perils, A. J., editors, Software Reusability, pp. 247-255. ACM Press.
56. Wadler, P. (1989) Theorems for free! Proc. 4th Int. Conf. on Functional Programming Languages and Computer Architecture, pp. 347-359.
57. Warren, D. (1982) Higher-order extensions to PROLOG: are they needed? In: Hayes, J., Michie, D. and Pao, Y.-H., editors, Machine Intelligence 10, pp. 441-454. Edinburgh University Press.
58. Wright, A. K. (1995) Simple imperative polymorphism. Lisp and Symbolic Computation, 8(4), 343-356.