Results 1 
7 of
7
A Functional Abstraction of Typed Contexts
, 1989
"... ion of Typed Contexts Olivier Danvy & Andrzej Filinski DIKU  Computer Science Department, University of Copenhagen Universitetsparken 1, 2100 Copenhagen , Denmark uucp: danvy@diku.dk & andrzej@diku.dk Abstract This report investigates abstracting control with functions. This is achieved b ..."
Abstract

Cited by 70 (8 self)
 Add to MetaCart
ion of Typed Contexts Olivier Danvy & Andrzej Filinski DIKU  Computer Science Department, University of Copenhagen Universitetsparken 1, 2100 Copenhagen , Denmark uucp: danvy@diku.dk & andrzej@diku.dk Abstract This report investigates abstracting control with functions. This is achieved by defining continuations as functions abstracting lexically a delimited context [C[ ]] rather than dynamically an unlimited one C[ ], as it is usually the case. Because their codomain is distinguished from the final domain of Answers, such continuations can be composed, and this contrasts with the simple exceptions of ML and Lisp and the unlimited firstclass continuations of Scheme. Making these functional control abstractions firstclass o#ers a new area in programming which this paper explores. The key points obtained here are: a denotational semantics for a simple, callbyvalue, strongly typed expression language with higherorder functions and firstclass continuations; its congruence with a ...
LambdaDropping: Transforming Recursive Equations into Programs with Block Structure
, 2001
"... Lambdalifting a blockstructured program transforms it into a set of recursive equations. We present the symmetric transformation: lambdadropping. Lambdadropping a set of recursive equations restores block structure and lexical scope. For lack ..."
Abstract

Cited by 42 (11 self)
 Add to MetaCart
(Show Context)
Lambdalifting a blockstructured program transforms it into a set of recursive equations. We present the symmetric transformation: lambdadropping. Lambdadropping a set of recursive equations restores block structure and lexical scope. For lack
Pragmatic Aspects of TypeDirected Partial Evaluation
, 1996
"... Typedirected partial evaluation stems from the residualization of static values in dynamic contexts, given their type and the type of their free variables. Its algorithm coincides with the algorithm for coercing a subtype value into a supertype value, which itself coincides with Berger and Schw ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
(Show Context)
Typedirected partial evaluation stems from the residualization of static values in dynamic contexts, given their type and the type of their free variables. Its algorithm coincides with the algorithm for coercing a subtype value into a supertype value, which itself coincides with Berger and Schwichtenberg's normalization algorithm for the simply typed calculus. Typedirected partial evaluation thus can be used to specialize a compiled, closed program, given its type.
c○2000 Elsevier Publishing, published in TCS Volume 248/12 Abstract LambdaDropping: Transforming Recursive Equations into Programs with Block Structure
"... Lambdalifting a blockstructured program transforms it into a set of recursive equations. We present the symmetric transformation: lambdadropping. Lambdadropping a set of recursive equations restores block structure and lexical scope. For lack of block structure and lexical scope, recursive equati ..."
Abstract
 Add to MetaCart
(Show Context)
Lambdalifting a blockstructured program transforms it into a set of recursive equations. We present the symmetric transformation: lambdadropping. Lambdadropping a set of recursive equations restores block structure and lexical scope. For lack of block structure and lexical scope, recursive equations must carry around all the parameters that any of their callees might possibly need. Both lambdalifting and lambdadropping thus require one to compute Def/Use paths: • for lambdalifting: each of the functions occurring in the path of a free variable is passed this variable as a parameter; • for lambdadropping: parameters which are used in the same scope as their definition do not need to be passed along in their path. A program whose blocks have no free variables is scopeinsensitive. Its blocks are then free to float (for lambdalifting) or to sink (for lambdadropping) along the vertices of the scope tree. Preprint submitted to Elsevier Preprint 2 May 2001 To summarize: lambda lifting � � recursive� � equations block block floating sinking lambda scopeinsensitive � � program dropping parameter parameter lifting dropping blockstructured program Our primary application is partial evaluation. Indeed, many partial evaluators for procedural programs operate on recursive equations. To this end, they lambdalift source programs in a preprocessing phase. But often, partial evaluators [automatically] produce residual recursive equations with dozens of parameters, which most compilers do not handle efficiently. We solve this critical problem by lambdadropping residual programs in a postprocessing phase, which significantly improves both their compile time and their run time. To summarize: source blockstructured lambdalifting source recursive
Maintaining Dynamic State: Deep, Shallow, and Parallel
, 1995
"... In the presence of firstclass continuations, shallow maintenance of dynamic bindings requires more than the traditional stackbased techniques. This paper provides correctness criteria for such dynamic environments, along with contrasting implementations. A store semantics provides the framework fo ..."
Abstract
 Add to MetaCart
(Show Context)
In the presence of firstclass continuations, shallow maintenance of dynamic bindings requires more than the traditional stackbased techniques. This paper provides correctness criteria for such dynamic environments, along with contrasting implementations. A store semantics provides the framework for our correctness criteria and presentation of deep and shallowbinding implementations. The latter implementation is a new statespace algorithm, which is proved correct. A variation of the algorithm implements Scheme's dynamicwind operation. Finally, a technique for maintaining dynamic state called semishallow binding is presented. This compromise between deep and shallowbinding appears suitable for parallel systems. Applications include fluid binding of lexical variables and logic programming with firstclass continuations. 1 Introduction Dynamic statemanagement is required in many situations. Usually dynamic contexts are associated with control contexts, as with dynamic variables, ...
Under consideration for publication in J. Functional Programming 1 Compilation of a Specialized Functional Language for Massively Parallel Computers
"... We propose a parallel specialized language that ensures portable and costpredictable implementations on parallel computers. The language is basically a firstorder, recursionless, strict functional language equipped with a collection of higherorder functions or skeletons. These skeletons apply on ..."
Abstract
 Add to MetaCart
(Show Context)
We propose a parallel specialized language that ensures portable and costpredictable implementations on parallel computers. The language is basically a firstorder, recursionless, strict functional language equipped with a collection of higherorder functions or skeletons. These skeletons apply on (nested) vectors and can be grouped in four classes: computation, reorganization, communication, and mask skeletons. The compilation process is described as a series of transformations and analyses leading to spmdlike functional programs which can be directly translated into real parallel code. The language restrictions enforce a programming discipline whose benefit is to allow a static, symbolic, and accurate cost analysis. The parallel cost takes into account both load balancing and communications, and can be statically evaluated even when the actual size of vectors or the number of processors are unknown. It is used to automatically select the best data distribution among a set of standard distributions. Interestingly, this work can be seen as a cross fertilization between techniques developed within the Fortran parallelization, skeleton, and functional programming communities. 1