Results 1  10
of
18
Improvement in a Lazy Context: An Operational Theory for CallByNeed
 Proc. POPL'99, ACM
, 1999
"... Machine The semantics presented in this section is essentially Sestoft's \mark 1" abstract machine for laziness [Sestoft 1997]. In that paper, he proves his abstract machine 6 A. K. Moran and D. Sands h fx = Mg; x; S i ! h ; M; #x : S i (Lookup) h ; V; #x : S i ! h fx = V g; V; S i (Up ..."
Abstract

Cited by 43 (8 self)
 Add to MetaCart
Machine The semantics presented in this section is essentially Sestoft's \mark 1" abstract machine for laziness [Sestoft 1997]. In that paper, he proves his abstract machine 6 A. K. Moran and D. Sands h fx = Mg; x; S i ! h ; M; #x : S i (Lookup) h ; V; #x : S i ! h fx = V g; V; S i (Update) h ; M x; S i ! h ; M; x : S i (Unwind) h ; x:M; y : S i ! h ; M [ y = x ]; S i (Subst) h ; case M of alts ; S i ! h ; M; alts : S i (Case) h ; c j ~y; fc i ~x i N i g : S i ! h ; N j [ ~y = ~x j ]; S i (Branch) h ; let f~x = ~ Mg in N; S i ! h f~x = ~ Mg; N; S i ~x dom(;S) (Letrec) Fig. 1. The abstract machine semantics for callbyneed. semantics sound and complete with respect to Launchbury's natural semantics, and we will not repeat those proofs here. Transitions are over congurations consisting of a heap, containing bindings, the expression currently being evaluated, and a stack. The heap is a partial function from variables to terms, and denoted in an identical manner to a coll...
Relational Reasoning about Contexts
 HIGHER ORDER OPERATIONAL TECHNIQUES IN SEMANTICS, PUBLICATIONS OF THE NEWTON INSTITUTE
, 1998
"... ..."
(Show Context)
Bisimilarity of Open Terms
, 2000
"... Traditionally, in process calculi, relations over open terms, i.e., terms with free process variables, are defined as extensions of closedterm relations: two open terms are related if and only if all their closed instantiations are related. Working in the context of bisimulation, in this paper we s ..."
Abstract

Cited by 21 (0 self)
 Add to MetaCart
Traditionally, in process calculi, relations over open terms, i.e., terms with free process variables, are defined as extensions of closedterm relations: two open terms are related if and only if all their closed instantiations are related. Working in the context of bisimulation, in this paper we study a different approach; we define semantic models for open terms, socalled conditional transition systems, and define bisimulation directly on those models. It turns out that this can be done in at least two different ways, one giving rise to De Simone's formal hypothesis bisimilarity and the other to a variation which we call hypothesispreserving bisimilarity (denoted t fh and t hp, respectively). For open terms, we have (strict) inclusions t fh /t hp / t ci (the latter denoting the standard ``closed instance' ' extension); for closed terms, the three coincide. Each of these relations is a congruence in the usual sense. We also give an alternative characterisation of t hp in terms of nonconditional transitions, as substitutionclosed bisimilarity (denoted t sb). Finally, we study the issue of recursion congruence: we prove that each of the above relations is a congruence with respect to the recursion operator; however, for t ci this result holds under more restrictive conditions than for tfh and thp.]
Positive Supercompilation for a higher order callbyvalue language
 In Proc. IFL 2007
, 2007
"... Abstract. Previous deforestation and supercompilation algorithms may introduce termination when applied to callbyvalue programs. This hides looping bugs from the programmer, and changes the behaviour of a program depending on whether it is optimized or not. We present a supercompilation algorithm ..."
Abstract

Cited by 15 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Previous deforestation and supercompilation algorithms may introduce termination when applied to callbyvalue programs. This hides looping bugs from the programmer, and changes the behaviour of a program depending on whether it is optimized or not. We present a supercompilation algorithm for a higherorder callbyvalue language that preserves termination properties. This algorithm utilizes strictness information for deciding whether to substitute or not and compares favorably with previous callbyname transformations. 1
SOS formats and metatheory: 20 years after
, 2007
"... In 1981 Structural Operational Semantics (SOS) was introduced as a systematic way to define operational semantics of programming languages by a set of rules of a certain shape [G.D. Plotkin, A structural approach to operational semantics, Technical ..."
Abstract

Cited by 11 (5 self)
 Add to MetaCart
In 1981 Structural Operational Semantics (SOS) was introduced as a systematic way to define operational semantics of programming languages by a set of rules of a certain shape [G.D. Plotkin, A structural approach to operational semantics, Technical
Strengthening supercompilation for callbyvalue languages
 SECOND INTERNATIONAL WORKSHOP ON METACOMPUTATION IN RUSSIA (META 2010)
, 2010
"... A termination preserving supercompiler for a callbyvalue language sometimes fails to remove intermediate structures that a supercompiler for a callbyname language would remove. This discrepancy in power stems from the fact that many function bodies are either nonlinear in use of an important va ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
A termination preserving supercompiler for a callbyvalue language sometimes fails to remove intermediate structures that a supercompiler for a callbyname language would remove. This discrepancy in power stems from the fact that many function bodies are either nonlinear in use of an important variable or often start with a pattern match on their first argument and are therefore not strict in all their arguments. As a consequence, intermediate structures are left in the output program, making it slower. We present a revised supercompilation algorithm for a callbyvalue language that propagates letbindings into casebranches and uses termination analysis to remove dead code. This allows the algorithm to remove all intermediate structures for common examples where previous algorithms for callbyvalue languages had to leave the intermediate structures in place.
Dynamic Slicing: A Generic Analysis Based on a Natural Semantics Format
, 1998
"... Slicing analyses have been proposed for dioeerent programming languages. Rather than defining a new analysis from scratch for each programming language, we would like to specify such an analysis once for all, in a languageindependent way, and then specialise it for different programming languages. ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Slicing analyses have been proposed for dioeerent programming languages. Rather than defining a new analysis from scratch for each programming language, we would like to specify such an analysis once for all, in a languageindependent way, and then specialise it for different programming languages. In order to achieve this goal, we propose a notion of natural semantics format and a dynamic slicing analysis format. The natural semantics format formalises a class of natural semantics and the analysis format is a generic, languageindependent, slicing analysis. The correctness of the generic analysis is established as a relation between the derivation trees of the original program and the slice. This generic analysis is then instantiated to several programming languages conforming the semantics format (an imperative language, a logic programming language and a functional language), yielding a dynamic slicing analyser for each of these languages.
On the observational theory of the CPScalculus
"... We study the observational theory of Thielecke’s CPScalculus, a distillation of the target language of ContinuationPassing Style transforms. We define a labelled transition system for the CPScalculus from which we derive a (weak) labelled bisimilarity that completely characterises Morris’ context ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
We study the observational theory of Thielecke’s CPScalculus, a distillation of the target language of ContinuationPassing Style transforms. We define a labelled transition system for the CPScalculus from which we derive a (weak) labelled bisimilarity that completely characterises Morris’ contextequivalence. We prove a context lemma showing that Morris’ contextequivalence coincides with a simpler contextequivalence closed under a smaller class of contexts. Then we profit of the determinism of the CPScalculus to give a simpler labelled characterisation of Morris’ equivalence, in the style of Abramsky’s applicative bisimilarity. We enhance our bisimulation proofmethods with upto bisimilarity and upto context proof techniques. We use our bisimulation proof techniques to investigate a few algebraic properties on diverging terms that cannot be proved using the original axiomatic semantics of the CPScalculus. Finally, we prove the full abstraction of Thielecke’s encoding of the CPScalculus into a fragment of Fournet and Gonthier’s Joincalculus with single pattern definitions.
Interpreting functions as πcalculus processes: a tutorial
, 1999
"... This paper is concerned with the relationship betweencalculus and ��calculus. Thecalculus talks about functions and their applicative behaviour. This contrasts with the ��calculus, that talks about processes and their interactive behaviour. Application is a special form of interaction, and there ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
This paper is concerned with the relationship betweencalculus and ��calculus. Thecalculus talks about functions and their applicative behaviour. This contrasts with the ��calculus, that talks about processes and their interactive behaviour. Application is a special form of interaction, and therefore functions can be seen as a special form of processes. We study how the functions of thecalculus (the computable functions) can be represented as ��calculus processes. The ��calculus semantics of a language induces a notion of equality on the terms of that language. We therefore also analyse the equality among functions that is induced by their representation as ��calculus processes. This paper is intended as a tutorial. It however contains some original contributions. The main ones are: the use of wellknown Continuation Passing Style transforms to derive the encodings into ��calculus and prove their correctness; the encoding of typedcalculi.