Heap recycling for lazy languages

Stefan Holdermans; Jurriaan Hage

doi:10.1145/1328408.1328436

Heap recycling for lazy languages

Stefan Holdermans, Jurriaan Hage

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

6 Citations (Scopus)

Abstract

Pure functional programming languages preclude destructive updates of heap-allocated data. In such languages, all newly computed algebraic values claim freshly allocated heap space, which typically causes idiomatic programs to be notoriously inefficient when compared to their imperative and impure counterparts. We partly overcome this shortcoming by considering a syntactically light language construct for enabling user-controlled in-place updates of algebraic values. The resulting calculus, that is based on a combination of type-based uniqueness and constructor analysis, is guaranteed to maintain referential transparency and is fully compatible with existing run-time systems for nonstrict, pure functional languages.

Original language	English
Title of host publication	Proceedings of the 2008 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Subtitle of host publication	PEPM '08
Editors	J. Hatcliff, R. Glück, O. de Moor
Publisher	Association for Computing Machinery
Pages	189-197
Number of pages	9
ISBN (Print)	9781595939777
DOIs	https://doi.org/10.1145/1328408.1328436
Publication status	Published - 7 Jan 2008

Keywords

Wiskunde en Informatica (WIIN)

Access to Document

10.1145/1328408.1328436

Cite this

@inproceedings{14dc1079a9e9490f9a6343d8664c92ac,

title = "Heap recycling for lazy languages",

abstract = "Pure functional programming languages preclude destructive updates of heap-allocated data. In such languages, all newly computed algebraic values claim freshly allocated heap space, which typically causes idiomatic programs to be notoriously inefficient when compared to their imperative and impure counterparts. We partly overcome this shortcoming by considering a syntactically light language construct for enabling user-controlled in-place updates of algebraic values. The resulting calculus, that is based on a combination of type-based uniqueness and constructor analysis, is guaranteed to maintain referential transparency and is fully compatible with existing run-time systems for nonstrict, pure functional languages.",

keywords = "Wiskunde en Informatica (WIIN)",

author = "Stefan Holdermans and Jurriaan Hage",

year = "2008",

month = jan,

day = "7",

doi = "10.1145/1328408.1328436",

language = "English",

isbn = "9781595939777",

pages = "189--197",

editor = "J. Hatcliff and R. Gl{\"u}ck and {de Moor}, O.",

booktitle = "Proceedings of the 2008 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation",

publisher = "Association for Computing Machinery",

address = "United States",

}

Heap recycling for lazy languages. / Holdermans, Stefan; Hage, Jurriaan.
Proceedings of the 2008 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation: PEPM '08. ed. / J. Hatcliff; R. Glück; O. de Moor. Association for Computing Machinery, 2008. p. 189-197.

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

TY - GEN

T1 - Heap recycling for lazy languages

AU - Holdermans, Stefan

AU - Hage, Jurriaan

PY - 2008/1/7

Y1 - 2008/1/7

N2 - Pure functional programming languages preclude destructive updates of heap-allocated data. In such languages, all newly computed algebraic values claim freshly allocated heap space, which typically causes idiomatic programs to be notoriously inefficient when compared to their imperative and impure counterparts. We partly overcome this shortcoming by considering a syntactically light language construct for enabling user-controlled in-place updates of algebraic values. The resulting calculus, that is based on a combination of type-based uniqueness and constructor analysis, is guaranteed to maintain referential transparency and is fully compatible with existing run-time systems for nonstrict, pure functional languages.

AB - Pure functional programming languages preclude destructive updates of heap-allocated data. In such languages, all newly computed algebraic values claim freshly allocated heap space, which typically causes idiomatic programs to be notoriously inefficient when compared to their imperative and impure counterparts. We partly overcome this shortcoming by considering a syntactically light language construct for enabling user-controlled in-place updates of algebraic values. The resulting calculus, that is based on a combination of type-based uniqueness and constructor analysis, is guaranteed to maintain referential transparency and is fully compatible with existing run-time systems for nonstrict, pure functional languages.

KW - Wiskunde en Informatica (WIIN)

U2 - 10.1145/1328408.1328436

DO - 10.1145/1328408.1328436

M3 - Conference contribution

SN - 9781595939777

SP - 189

EP - 197

BT - Proceedings of the 2008 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation

A2 - Hatcliff, J.

A2 - Glück, R.

A2 - de Moor, O.

PB - Association for Computing Machinery

ER -

Heap recycling for lazy languages

Abstract

Keywords

Access to Document

Fingerprint

Cite this