Results 1  10
of
15
A Calculus with Polymorphic and Polyvariant Flow Types
"... We present # CIL , a typed #calculus which serves as the foundation for a typed intermediate language for optimizing compilers for higherorder polymorphic programming languages. The key innovation of # CIL is a novel formulation of intersection and union types and flow labels on both terms and ..."
Abstract

Cited by 28 (11 self)
 Add to MetaCart
We present # CIL , a typed #calculus which serves as the foundation for a typed intermediate language for optimizing compilers for higherorder polymorphic programming languages. The key innovation of # CIL is a novel formulation of intersection and union types and flow labels on both terms and types. These flow types can encode polyvariant control and data flow information within a polymorphically typed program representation. Flow types can guide a compiler in generating customized data representations in a strongly typed setting. Since # CIL enjoys confluence, standardization, and subject reduction properties, it is a valuable tool for reasoning about programs and program transformations.
Equational Reasoning for Linking with FirstClass Primitive Modules
 In European Symposium on Programming
, 2000
"... . Modules and linking are usually formalized by encodings which use the calculus, records (possibly dependent), and possibly some construct for recursion. In contrast, we introduce the mcalculus, a calculus where the primitive constructs are modules, linking, and the selection and hiding of mo ..."
Abstract

Cited by 27 (5 self)
 Add to MetaCart
. Modules and linking are usually formalized by encodings which use the calculus, records (possibly dependent), and possibly some construct for recursion. In contrast, we introduce the mcalculus, a calculus where the primitive constructs are modules, linking, and the selection and hiding of module components. The mcalculus supports smooth encodings of software structuring tools such as functions ( calculus), records, objects (&calculus), and mutually recursive definitions. The mcalculus can also express widely varying kinds of module systems as used in languages like C, Haskell, and ML. We prove the mcalculus is confluent, thereby showing that equational reasoning via the mcalculus is sensible and well behaved. 1 Introduction A long version of this paper [43] which contains full proofs, more details and explanations, and comparisons with more calculi (including the calculus of Ancona and Zucca [4]), is available at http://www.cee.hw.ac.uk/~jbw/papers/. 1.1 Support f...
Mixin Modules and Computational Effects
, 2003
"... We define a calculus for investigating the interactions between mixin modules and computational effects, by combining the purely functional mixin calculus CMS with a monadic metalanguage supporting the two separate notions of simplification (local rewrite rules) and computation (global evaluation ab ..."
Abstract

Cited by 18 (6 self)
 Add to MetaCart
We define a calculus for investigating the interactions between mixin modules and computational effects, by combining the purely functional mixin calculus CMS with a monadic metalanguage supporting the two separate notions of simplification (local rewrite rules) and computation (global evaluation able to modify the store). This distinction is important for smoothly integrating the CMS rules (which are all local) with the rules dealing with the imperative features. In our calculus mixins...
Callbyvalue mixin modules: Reduction semantics, side effects, types
 Programming Languages & Systems, 13th European Symp. Programming
, 2004
"... Mixin modules are a framework for modular programming that supports code parameterization, incremental programming via late binding and redefinitions, and crossmodule recursion. In this paper, we develop a language of mixin modules that supports callbyvalue evaluation, and formalize a reduction ..."
Abstract

Cited by 15 (4 self)
 Add to MetaCart
Mixin modules are a framework for modular programming that supports code parameterization, incremental programming via late binding and redefinitions, and crossmodule recursion. In this paper, we develop a language of mixin modules that supports callbyvalue evaluation, and formalize a reduction semantics and a sound type system for this language.
Mixin Modules for Dynamic Rebinding
 IN: TGC 2005 SYMPOSIUM ON TRUSTWORTHY GLOBAL COMPUTING, LECTURE NOTES IN COMPUTER SCIENCE
, 2005
"... Dynamic rebinding is the ability of changing the definitions of names at execution time. While dynamic rebinding is clearly useful in practice, and increasingly needed in modern systems, most programming languages provide only limited and adhoc mechanisms, and no adequate semantic understanding cur ..."
Abstract

Cited by 6 (4 self)
 Add to MetaCart
Dynamic rebinding is the ability of changing the definitions of names at execution time. While dynamic rebinding is clearly useful in practice, and increasingly needed in modern systems, most programming languages provide only limited and adhoc mechanisms, and no adequate semantic understanding currently exists. Here, we provide
A casestudy in encoding configuration languages: Multiple class loaders
 JOURN. OF OBJECT TECHNOLOGY
, 2004
"... The contribution of the paper is twofold. First, we define a toy language, called MCL, which provides a very abstract view of the mechanism of dynamic class loading with multiple loaders as in Java. The aim is to study this feature in isolation, allowing a better understanding; moreover, this also s ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
The contribution of the paper is twofold. First, we define a toy language, called MCL, which provides a very abstract view of the mechanism of dynamic class loading with multiple loaders as in Java. The aim is to study this feature in isolation, allowing a better understanding; moreover, this also shows a stratified approach, which, differently from the Java approach based on reflection, distinguishes between the language at the user level and the configuration language. This approach is less flexible but allows to statically check type safety, hence provides an intermediate solution between the rigid approach based only on the class path and that which allows loaders to depend on execution of user applications, which can be intricate and errorprone. The second contribution is related to a recent stream of work aiming at defining simple and powerful calculi providing a common foundation for systems supporting dynamic reconfiguration. We use MCL as an extended casestudy, by defining an encoding in one of these kernel calculi, and prove the correctness of the translation.
Equivalence of callbyname and callbyneed for lambdacalculi with letrec. Frank report 25
 Inst. f. Informatik
, 2006
"... Abstract. We develop a proof method to show that in a (deterministic) lambda calculus with letrec and equipped with contextual equivalence the callbyname and the callbyneed evaluation are equivalent, and also that the unrestricted copyoperation is correct. Given a letbinding x = t, the copyop ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
Abstract. We develop a proof method to show that in a (deterministic) lambda calculus with letrec and equipped with contextual equivalence the callbyname and the callbyneed evaluation are equivalent, and also that the unrestricted copyoperation is correct. Given a letbinding x = t, the copyoperation replaces an occurrence of the variable x by the expression t, regardless of the form of t. This gives an answer to unresolved problems in several papers, it adds a strong method to the tool set for reasoning about contextual equivalence in higherorder calculi with letrec, and it enables a class of transformations that can be used as optimizations. The method can be used in different kind of lambda calculi with cyclic sharing. Probably it can also be used in nondeterministic lambda calculi if the variable x is “deterministic”, i.e., has no interference with nondeterministic executions. The main technical idea is to use a restricted variant of the infinitary lambdacalculus, whose objects are the expressions that are unrolled w.r.t. let, to define the infinite developments as a reduction calculus on the infinite trees and showing a standardization theorem. 1
Correctness of copy in calculi with letrec, case and constructors
, 2007
"... Callbyneed lambda calculi with letrec provide a rewritingbased operational semantics for (lazy) callbyname functional languages. These calculi model the sharing behavior during evaluation more closely than letbased calculi that use a fixpoint combinator. In a previous paper we showed that the ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Callbyneed lambda calculi with letrec provide a rewritingbased operational semantics for (lazy) callbyname functional languages. These calculi model the sharing behavior during evaluation more closely than letbased calculi that use a fixpoint combinator. In a previous paper we showed that the copytransformation is correct for the small calculus LRλ. In this paper we demonstrate that the proof method based on a calculus on infinite trees for showing correctness of instantiation operations can be extended to the calculus LRCCλ with case and constructors, and show that copying at compiletime can be done without restrictions. We also show that the callbyneed and callbyname strategies are equivalent w.r.t. contextual equivalence. A consequence is correctness of all the transformations like instantiation, inlining, specialization and common subexpression elimination in LRCCλ. We are confident that the method scales up for proving correctness of copyrelated transformations in nondeterministic lambda calculi if restricted to “deterministic” subterms.
Correctness of Program Transformations as a Termination Problem ⋆
"... Abstract. The diagrambased method to prove correctness of program transformations includes the computation of (critical) overlappings between the analyzed program transformation and the (standard) reduction rules which result in socalled forking diagrams. Such diagrams can be seen as rewrite rules ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Abstract. The diagrambased method to prove correctness of program transformations includes the computation of (critical) overlappings between the analyzed program transformation and the (standard) reduction rules which result in socalled forking diagrams. Such diagrams can be seen as rewrite rules on reduction sequences which abstract away the expressions and allow additional expressive power, like transitive closures of reductions. In this paper we clarify the meaning of forking diagrams using interpretations as infinite term rewriting systems. We then show that the termination problem of forking diagrams as rewrite rules can be encoded into the termination problem for conditional integer term rewriting systems, which can be solved by automated termination provers. Since the forking diagrams can be computed automatically, the results of this paper are a big step towards a fully automatic prover for the correctness of program transformations. 1
Computational Soundness of a Call by Name Calculus of Recursivelyscoped Records. Working Papers Series
"... The paper presents a calculus of recursivelyscoped records: a twolevel calculus with a traditional callbyname λcalculus at a lower level and unordered collections of labeled λcalculus terms at a higher level. Terms in records may reference each other, possibly in a mutually recursive manner, by ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
The paper presents a calculus of recursivelyscoped records: a twolevel calculus with a traditional callbyname λcalculus at a lower level and unordered collections of labeled λcalculus terms at a higher level. Terms in records may reference each other, possibly in a mutually recursive manner, by means of labels. We define two relations: a rewriting relation that models program transformations and an evaluation relation that defines a smallstep operational semantics of records. Both relations follow a callbyname strategy. We use a special symbol called a black hole to model cyclic dependencies that lead to infinite substitution. Computational soundness is a property of a calculus that connects the rewriting relation and the evaluation relation: it states that any sequence of rewriting steps (in either direction) preserves the meaning of a record as defined by the evaluation relation. The computational soundness property implies that any program transformation that can be represented as a sequence of forward and backward rewriting steps preserves the meaning of a record as defined by the small step operational semantics. In this paper we describe the computational soundness framework and prove computational soundness of the calculus. The proof is based on a novel inductive contextbased argument for meaning preservation of substituting one component into another. Keywords: Calculus, callbyname, computational soundness, recursivelyscoped records