Results 1  10
of
13
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 44 (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...
Macros as multistage computations: Typesafe, generative, binding macros in MacroML
 IN MACROML. IN THE INTERNATIONAL CONFERENCE ON FUNCTIONAL PROGRAMMING (ICFP ’01
, 2001
"... ..."
A Simply Typed Context Calculus with FirstClass Environments
, 2002
"... . We introduce a simply typed calculus " which has both contexts and environments as firstclass values. In ", holes in contexts are represented by ordinary variables of appropriate types and hole filling is represented by the functional application together with a new abstraction mechani ..."
Abstract

Cited by 17 (1 self)
 Add to MetaCart
(Show Context)
. We introduce a simply typed calculus " which has both contexts and environments as firstclass values. In ", holes in contexts are represented by ordinary variables of appropriate types and hole filling is represented by the functional application together with a new abstraction mechanism which takes care of packing and unpacking of the term which is used to fill in the holes of the context. " is a conservative extension of the simply typed ficalculus, enjoys subject reduction property, is confluent and strongly normalizing. The traditional method of defining substitution does not work for our calculus. So, we also introduce a new method of defining substitution. Although we introduce the new definition of substitution out of necessity, the new definition turns out to be conceptually simpler than the traditional definition of substitution. 1 Introduction Informally speaking, a context (in calculus) is a term with some holes in it. For example, writing [ ] for a hole, y: [ ] is a...
Free Σmonoids: A higherorder syntax with metavariables
 In Proc. of APLAS’04, LNCS 3302
, 2004
"... Abstract. The notion of Σmonoids is proposed by Fiore, Plotkin and Turi, to give abstract algebraic model of languages with variable binding and substitutions. In this paper, we give a free construction of Σmonoids. The free Σmonoid over a given presheaf serves a wellstructured term language inv ..."
Abstract

Cited by 8 (4 self)
 Add to MetaCart
(Show Context)
Abstract. The notion of Σmonoids is proposed by Fiore, Plotkin and Turi, to give abstract algebraic model of languages with variable binding and substitutions. In this paper, we give a free construction of Σmonoids. The free Σmonoid over a given presheaf serves a wellstructured term language involving binding and substitutions. Moreover, the free Σmonoid naturally contains interesting syntactic objects which can be viewed as “metavariables ” and “environments”. We analyse the term language of the free Σmonoid by relating it with several concrete systems, especially the λcalculus extended with contexts. 1
A Calculus of Lambda Calculus Contexts
 Journal of Automated Reasoning
, 2001
"... The calculus c serves as a general framework for representing contexts. Essential features are control over variable capturing and the freedom to manipulate contexts before or after hole lling, by a mechanism of delayed substitution. The context calculus c is given in the form of an extension of th ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
(Show Context)
The calculus c serves as a general framework for representing contexts. Essential features are control over variable capturing and the freedom to manipulate contexts before or after hole lling, by a mechanism of delayed substitution. The context calculus c is given in the form of an extension of the lambda calculus. Many notions of context can be represented within the framework; a particular variation can be obtained by the choice of a pretyping, which we illustrate by three examples. 1.
ContextOriented Programming for Pervasive Systems
, 2002
"... We envision that pervasive computing will increasingly impact on daily life. Pervasive computing is a computing paradigm incorporated in a variety of devices (computers, clothes, cars, appliances, mobile phones etc.) to support daily activities. To make computers easier to use, computing tasks m ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
(Show Context)
We envision that pervasive computing will increasingly impact on daily life. Pervasive computing is a computing paradigm incorporated in a variety of devices (computers, clothes, cars, appliances, mobile phones etc.) to support daily activities. To make computers easier to use, computing tasks must be more sensitive to our needs and the context.
Runtime Behavior of Conversion Interpretation of Subtyping
"... A programming language with subtyping can be translated into a language without subtyping by inserting conversion functions. Previous studies of this interpretation showed only the extensional correctness of the translation. We study runtime behavior of translated programs and show that this transla ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
A programming language with subtyping can be translated into a language without subtyping by inserting conversion functions. Previous studies of this interpretation showed only the extensional correctness of the translation. We study runtime behavior of translated programs and show that this translation preserves execution time and stack space within a factor determined by the types in a program. Both the proofs on execution time and stack space are based on the method of logical relations where relations are extended with the factor of slowdown or increase of stack space.
Proof contexts with late binding
 In Typed Lambda Calculi and Applications, volume 3461 of LNCS
, 2005
"... Abstract. The Focal language (formerly FoC) allows one to incrementally build modules and to formally prove their correctness. In this paper, we present two formal semantics for encoding Focal constructions in the Coq proof assistant. The first one is implemented in the Focal compiler to have the ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
Abstract. The Focal language (formerly FoC) allows one to incrementally build modules and to formally prove their correctness. In this paper, we present two formal semantics for encoding Focal constructions in the Coq proof assistant. The first one is implemented in the Focal compiler to have the correctness of Focal libraries verified with the Coq proofchecker. The second one formalizes the Focal structures and their main properties as Coq terms (called mixDrecs). The relations between the two embeddings are examined in the last part of the paper. 1
Automatic Amortised Analysis of Dynamic Memory Allocation for Lazy Functional Programs
"... This paper describes the first successful attempt, of which we are aware, to define an automatic, typebased static analysis of resource bounds for lazy functional programs. Our analysis uses the automatic amortisation approach developed by Hofmann and Jost, which was previously restricted to eager ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
This paper describes the first successful attempt, of which we are aware, to define an automatic, typebased static analysis of resource bounds for lazy functional programs. Our analysis uses the automatic amortisation approach developed by Hofmann and Jost, which was previously restricted to eager evaluation. In this paper, we extend this work to a lazy setting by capturing the costs of unevaluated expressions in type annotations and by amortising the payment of these costs using a notion of lazy potential. We present our analysis as a proof system for predicting heap allocations of a minimal functional language (including higherorder functions and recursive data types) and define a formal cost model based on Launchbury’s natural semantics for lazy evaluation. We prove the soundness of our analysis with respect to the cost model. Our approach is illustrated by a number of representative and nontrivial examples that have been analysed using a prototype implementation of our analysis. 1.