55 research outputs found
Repetitive Reduction Patterns in Lambda Calculus with letrec (Work in Progress)
For the lambda-calculus with letrec we develop an optimisation, which is
based on the contraction of a certain class of 'future' (also: virtual)
redexes.
In the implementation of functional programming languages it is common
practice to perform beta-reductions at compile time whenever possible in order
to produce code that requires fewer reductions at run time. This is, however,
in principle limited to redexes and created redexes that are 'visible' (in the
sense that they can be contracted without the need for unsharing), and cannot
generally be extended to redexes that are concealed by sharing constructs such
as letrec. In the case of recursion, concealed redexes become visible only
after unwindings during evaluation, and then have to be contracted time and
again.
We observe that in some cases such redexes exhibit a certain form of
repetitive behaviour at run time. We describe an analysis for identifying
binders that give rise to such repetitive reduction patterns, and eliminate
them by a sort of predictive contraction. Thereby these binders are lifted out
of recursive positions or eliminated altogether, as a result alleviating the
amount of beta-reductions required for each recursive iteration.
Both our analysis and simplification are suitable to be integrated into
existing compilers for functional programming languages as an additional
optimisation phase. With this work we hope to contribute to increasing the
efficiency of executing programs written in such languages.Comment: In Proceedings TERMGRAPH 2011, arXiv:1102.226
Maximal Sharing in the Lambda Calculus with letrec
Increasing sharing in programs is desirable to compactify the code, and to
avoid duplication of reduction work at run-time, thereby speeding up execution.
We show how a maximal degree of sharing can be obtained for programs expressed
as terms in the lambda calculus with letrec. We introduce a notion of `maximal
compactness' for lambda-letrec-terms among all terms with the same infinite
unfolding. Instead of defined purely syntactically, this notion is based on a
graph semantics. lambda-letrec-terms are interpreted as first-order term graphs
so that unfolding equivalence between terms is preserved and reflected through
bisimilarity of the term graph interpretations. Compactness of the term graphs
can then be compared via functional bisimulation.
We describe practical and efficient methods for the following two problems:
transforming a lambda-letrec-term into a maximally compact form; and deciding
whether two lambda-letrec-terms are unfolding-equivalent. The transformation of
a lambda-letrec-term into maximally compact form proceeds in three
steps:
(i) translate L into its term graph ; (ii) compute the maximally
shared form of as its bisimulation collapse ; (iii) read back a
lambda-letrec-term from the term graph with the property . This guarantees that and have the same unfolding, and that
exhibits maximal sharing.
The procedure for deciding whether two given lambda-letrec-terms and
are unfolding-equivalent computes their term graph interpretations and , and checks whether these term graphs are bisimilar.
For illustration, we also provide a readily usable implementation.Comment: 18 pages, plus 19 pages appendi
Continuation-Passing C: compiling threads to events through continuations
In this paper, we introduce Continuation Passing C (CPC), a programming
language for concurrent systems in which native and cooperative threads are
unified and presented to the programmer as a single abstraction. The CPC
compiler uses a compilation technique, based on the CPS transform, that yields
efficient code and an extremely lightweight representation for contexts. We
provide a proof of the correctness of our compilation scheme. We show in
particular that lambda-lifting, a common compilation technique for functional
languages, is also correct in an imperative language like C, under some
conditions enforced by the CPC compiler. The current CPC compiler is mature
enough to write substantial programs such as Hekate, a highly concurrent
BitTorrent seeder. Our benchmark results show that CPC is as efficient, while
using significantly less space, as the most efficient thread libraries
available.Comment: Higher-Order and Symbolic Computation (2012). arXiv admin note:
substantial text overlap with arXiv:1202.324
A Symmetric Approach to Compilation and Decompilation
Just as specializing a source interpreter can achieve compilation from a source language to a target language, we observe that specializing a target interpreter can achieve compilation from the target language to the source language. In both cases, the key issue is the choice of whether to perform an evaluation or to emit code that represents this evaluation. We substantiate this observation by specializing two source interpreters and two target interpreters. We first consider a source language of arithmetic expressions and a target language for a stack machine, and then the lambda-calculus and the SECD-machine language. In each case, we prove that the target-to-source compiler is a left inverse of the source-to-target compiler, i.e., it is a decompiler. In the context of partial evaluation, compilation by source-interpreter specialization is classically referred to as a Futamura projection. By symmetry, it seems logical to refer to decompilation by target-interpreter specialization as a Futamura embedding
Process types as a descriptive tool for interaction
We demonstrate a tight relationship between linearly typed π-calculi and typed λ-calculi by giving a type-preserving translation from the call-by-value λµ-calculus into a typed π-calculus. The λµ-calculus has a particularly simple representation as typed mobile processes. The target calculus is a simple variant of the linear π-calculus. We establish full abstraction up to maximally consistent observational congruences in source and target calculi using techniques from games semantics and process calculi
Adaptation-Based Programming in Haskell
We present an embedded DSL to support adaptation-based programming (ABP) in
Haskell. ABP is an abstract model for defining adaptive values, called
adaptives, which adapt in response to some associated feedback. We show how our
design choices in Haskell motivate higher-level combinators and constructs and
help us derive more complicated compositional adaptives.
We also show an important specialization of ABP is in support of
reinforcement learning constructs, which optimize adaptive values based on a
programmer-specified objective function. This permits ABP users to easily
define adaptive values that express uncertainty anywhere in their programs.
Over repeated executions, these adaptive values adjust to more efficient ones
and enable the user's programs to self optimize.
The design of our DSL depends significantly on the use of type classes. We
will illustrate, along with presenting our DSL, how the use of type classes can
support the gradual evolution of DSLs.Comment: In Proceedings DSL 2011, arXiv:1109.032
A Domain-Specific Language for Incremental and Modular Design of Large-Scale Verifiably-Safe Flow Networks (Preliminary Report)
We define a domain-specific language (DSL) to inductively assemble flow
networks from small networks or modules to produce arbitrarily large ones, with
interchangeable functionally-equivalent parts. Our small networks or modules
are "small" only as the building blocks in this inductive definition (there is
no limit on their size). Associated with our DSL is a type theory, a system of
formal annotations to express desirable properties of flow networks together
with rules that enforce them as invariants across their interfaces, i.e, the
rules guarantee the properties are preserved as we build larger networks from
smaller ones. A prerequisite for a type theory is a formal semantics, i.e, a
rigorous definition of the entities that qualify as feasible flows through the
networks, possibly restricted to satisfy additional efficiency or safety
requirements. This can be carried out in one of two ways, as a denotational
semantics or as an operational (or reduction) semantics; we choose the first in
preference to the second, partly to avoid exponential-growth rewriting in the
operational approach. We set up a typing system and prove its soundness for our
DSL.Comment: In Proceedings DSL 2011, arXiv:1109.032
Genetic diversity of a large set of horse breeds raised in France assessed by microsatellite polymorphism
After the recent publication of our article (Leroy, Genetics Selection Evolution 2009 41:5), we found several errors in the published Table Three, concerning the computation of contribution to within-breed diversity (CW). We apologize to the readers for these errors, which are corrected in the present erratum
- …