71 research outputs found
A modular structural operational semantics for delimited continuations
It has been an open question as to whether the Modular Structural Operational Semantics framework can express the dynamic semantics of call/cc. This paper shows that it can, and furthermore, demonstrates that it can express the more general delimited control operators control and shift
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
A DSEL for Studying and Explaining Causation
We present a domain-specific embedded language (DSEL) in Haskell that
supports the philosophical study and practical explanation of causation. The
language provides constructs for modeling situations comprised of events and
functions for reliably determining the complex causal relationships that emerge
between these events. It enables the creation of visual explanations of these
causal relationships and a means to systematically generate alternative,
related scenarios, along with corresponding outcomes and causes. The DSEL is
based on neuron diagrams, a visual notation that is well established in
practice and has been successfully employed for causation explanation and
research. In addition to its immediate applicability by users of neuron
diagrams, the DSEL is extensible, allowing causation experts to extend the
notation to introduce special-purpose causation constructs. The DSEL also
extends the notation of neuron diagrams to operate over non-boolean values,
improving its expressiveness and offering new possibilities for causation
research and its applications.Comment: In Proceedings DSL 2011, arXiv:1109.032
Tutorial on Online Partial Evaluation
This paper is a short tutorial introduction to online partial evaluation. We
show how to write a simple online partial evaluator for a simple, pure,
first-order, functional programming language. In particular, we show that the
partial evaluator can be derived as a variation on a compositionally defined
interpreter. We demonstrate the use of the resulting partial evaluator for
program optimization in the context of model-driven development.Comment: In Proceedings DSL 2011, arXiv:1109.032
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
Effects for Efficiency: Asymptotic Speedup with First-Class Control
We study the fundamental efficiency of delimited control. Specifically, we
show that effect handlers enable an asymptotic improvement in runtime
complexity for a certain class of functions. We consider the generic count
problem using a pure PCF-like base language and its extension with
effect handlers . We show that admits an asymptotically
more efficient implementation of generic count than any
implementation. We also show that this efficiency gap remains when
is extended with mutable state. To our knowledge this result is the first of
its kind for control operators
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
- …