Skip to main content Accessibility help
×
Home

Reference counting as a computational interpretation of linear logic

  • Jawahar Chirimar (a1), Carl A. Gunter (a1) and Jon G. Riecke (a2)

Abstract

We develop an operational model for a language based on linear logic. Our semantics is ‘low-level’ enough to express sharing and copying while still being ‘high-level’ enough to abstract away from details of memory layout, and thus can be used to test potential applications of linear logic for analysis of programs. In particular, we demonstrate a precise relationship between type correctness for the linear-logic-based language and the correctness of a reference-counting interpretation of the primitives, and formulate and prove a result describing the possible run-time reference counts of values of linear type.

Copyright

References

Hide All
Abramsky, S. (1993) Computational interpretations of linear logic. Theoretical Computer Science 111:357.
Abramsky, S. and Hankin, C. (eds.) (1987) Abstract Interpretation of Declarative Languages. Ellis Horwood.
Appel, A. (1992) Compiling with Continuations. Cambridge University Press.
Baker, H. G. (1978) List processing in real time on a serial computer. Communications of the ACM 21(7):1120.
Benton, N., Bierman, G., de Paiva, V. and Hyland, M. (1992) Term assignment for intuitionistic linear logic. Technical Report 262, University of Cambridge Computer Laboratory.
Benton, N., Bierman, G., de Paiva, V. and Hyland, M. (1993) A term calculus for intuitionistic linear logic. In Typed Lambda Calculi and Applications: Lecture Notes in Computer Science vol 664, pp. 7590. Springer-Verlag.
Bloss, A., Hudak, P. and Young, J. (1988) An optimizing compiler for a modern functional programming language. Computer Journal 31(6).
Breazu-Tannen, V., Gunter, C. and Scedrov, A. (1990) Computing with coercions. Proceedings of the ACM Conference on Lisp and Functional Programming, pp. 4460.
Chirimar, J., Gunter, C. A. and Riecke, J. G. (1992) Proving memory management invariants for a language based on linear logic. Proceedings of the ACM Conference on Lisp and Functional Programming, pp. 139150.
Collins, G. E. (1960) A method for overlapping and erasure of lists. Communications of the ACM 3(12): 655657.
Despeyroux, J. (1986) Proof of translation in natural semantics. Proceedings, Symposium on Logic in Computer Science. IEEE.
Deutsch, L. P. and Bobrow, D. G. (1976) An efficient, incremental, automatic garbage collector. Communications of the ACM 19(9): 522526.
Filinski, A. (1992) Linear continuations. Conference Record of the 19th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pp. 2738. ACM.
Gabriel, R. P. (1985) Performance and Evaluation of Lisp Systems. MIT Press.
Girard, J.-Y. (1987) Linear logic. Theoretical Computer Science 50: 1102.
Goldberg, B. and Gloger, M. (1992) Polymorphic type reconstruction for garbage collection without tags. Proceedings of the ACM Conference on Lisp and Functional Programming, pp. 5365. ACM.
Guzmán, J. C. and Hudak, P. (1990) Single-threaded polymorphic lambda calculus. Proceedings 5th Annual IEEE Symposium on Logic in Computer Science, pp. 333343.
Holmström, S. (1988) Linear functional programming. In Implementation of Lazy Functional Languages, Johnsson, T., Peyton-Jones, S. and Karlsson, K. (eds.), pp. 1332.
Howard, W. A. (1980) The formulae-as-types notion of construction. In To H. B. Curry: Essays on Combinatory Logic, Lambda Calculus and Formalism, Hindley, J. and Seldin, J. (eds.), pp. 479490. Academic Press.
Hudak, P. (1987) A semantic model of reference counting and its abstraction. In Abstract Interpretation of Declarative Languages, pp. 4562. Chichester: Ellis Horwood. (Preliminary version appeared in Proceedings 1986 ACM Conference on LISP and Functional Programming, August 1986, pp. 351–363).
Kahn, G. (1987) Natural semantics. Proceedings Symposium on Theoretical Aspects of Computer Science: Lecture Notes in Computer Science vol 247. Springer-Verlag.
Lafont, Y. (1988) The linear abstract machine. Theoretical Computer Science 59: 157180.
Launchbury, J. (1993) A natural semantics for lazy evaluation. Conference Record of the 20th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pp. 144154. ACM.
Lawall, J. L. and Danvy, O. (1993) Separating stages in the continuation-passing style transformation. Conference Record of the 20th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pp. 124136. ACM.
Lincoln, P. and Mitchell, J. C. (1992) Operational aspects of linear lambda calculus. Proceedings 7th Annual IEEE Symposium on Logic in Computer Science, pp. 235247.
Mackie, I. (1991) Lilac: A functional programming language based on linear logic. Master's thesis, Imperial College, University of London.
Milner, R. and Tofte, M. (1991) Commentary on Standard ML. MIT Press.
Milner, R., Tofte, M. and Harper, R. (1990) The Definition of Standard ML. MIT Press.
O'Hearn, P. W. (1991) Linear logic and interference control (preliminary report). In Category Theory and Computer Science: Lecture Notes in Computer Science vol 530, Pitt, D. H. (ed.), pp. 7493. Springer-Verlag.
Plotkin, G. D. (1975) Call-by-name, call-by-value and the λ-calculus. Theoretical Computer Science 1:125159.
Plotkin, G. D. (1977) LCF considered as a programming language. Theoretical Computer Science 5: 223257.
Purushothaman, S. and Seaman, J. (1991) An adequate operational semantics of sharing in lazy evaluation. Technical Report PSU-CS-91-18, Pennsylvania State University.
Scott, D. S. (1993) A type theoretical alternative to CUCH, ISWIM, OWHY. Theoretical Computer Science 121: 411440. (Published version of unpublished manuscript, Oxford University, 1969.)
Wadler, P. (1990) Linear types can change the world! In Programming Concepts and Methods, Broy, M. and Jones, C. B. (eds.). North Holland.
Wadler, P. (1991) Is there a use for linear logic? Proceedings of the Symposium on Partial Evaluation and Semantics-Based Program Manipulation, pp. 255273. ACM.
Wadler, P. (1993) A syntax for linear logic. Workshop on Mathematical Foundations of Programming Language Semantics, New Orleans, LA.
Wand, M. and Oliva, D. P. (1992) Proving the correctness of storage representations. In Lisp and Functional Programming, Clinger, W. (ed.), pp. 151160. ACM.
Wise, D. S., Hess, C., Hunt, W. and Ost, E. (1992) Uniprocessor performance of reference-counting hardware heap. Unpublished manuscript.

Related content

Powered by UNSILO

Reference counting as a computational interpretation of linear logic

  • Jawahar Chirimar (a1), Carl A. Gunter (a1) and Jon G. Riecke (a2)

Metrics

Full text views

Total number of HTML views: 0
Total number of PDF views: 0 *
Loading metrics...

Abstract views

Total abstract views: 0 *
Loading metrics...

* Views captured on Cambridge Core between <date>. This data will be updated every 24 hours.

Usage data cannot currently be displayed.

Reference counting as a computational interpretation of linear logic

  • Jawahar Chirimar (a1), Carl A. Gunter (a1) and Jon G. Riecke (a2)
Submit a response

Discussions

No Discussions have been published for this article.

×

Reply to: Submit a response


Your details


Conflicting interests

Do you have any conflicting interests? *