Results 11  20
of
20
What is a Purely Functional Language?
 Journal of Functional Programming
, 1998
"... Functional programming languages are informally classified into pure and impure languages. The precise meaning of this distinction has been a matter of controversy. We therefore investigate a formal definition of purity. We begin by showing that some proposed definitions that rely on confluence, sou ..."
Abstract

Cited by 14 (6 self)
 Add to MetaCart
Functional programming languages are informally classified into pure and impure languages. The precise meaning of this distinction has been a matter of controversy. We therefore investigate a formal definition of purity. We begin by showing that some proposed definitions that rely on confluence, soundness of the beta axiom, preservation of pure observational equivalences, and independence of the order of evaluation, do not withstand close scrutiny. We propose instead a definition based on parameterpassing independence. Intuitively, the definition implies that functions are pure mappings from arguments to results; the operational decision of how to pass the arguments is irrelevant. In the context of Haskell, our definition is consistent with the fact that the traditional callbyname denotational semantics coincides with the traditional callbyneed implementation. Furthermore, our definition is compatible with the streambased, continuationbased, and monadbased integration of computa...
Reasoning about Explicit and Implicit Representations of State
 YALE UNIVERSITY
, 1993
"... The semantics of imperative languages are often expressed in terms of a storepassing translation and an algebra for reasoning about stores. We axiomatize the semantics of several typical imperative languages via equational axioms by "inverting" the storepassing translation as well as the algebra ..."
Abstract

Cited by 12 (4 self)
 Add to MetaCart
The semantics of imperative languages are often expressed in terms of a storepassing translation and an algebra for reasoning about stores. We axiomatize the semantics of several typical imperative languages via equational axioms by "inverting" the storepassing translation as well as the algebraic axioms for reasoning about the store. The inversion process is simple and systematic and results in theories that are similar to equational theories for imperative languages that have been derived in more complicated ways, and is likely to be applicable to languages other than those presented here.
Delimiting the Scope of Effects
 In Proceedings of the Conference on Functional Programming Languages and Computer Architecture
, 1993
"... Program fragments in functional languages may be observationally congruent in a language without effects (continuations, state, exceptions) but not in an extension with effects. We give a generic way to preserve pure functional congruences by means of an effects delimiter. The effects delimiter is ..."
Abstract

Cited by 11 (1 self)
 Add to MetaCart
Program fragments in functional languages may be observationally congruent in a language without effects (continuations, state, exceptions) but not in an extension with effects. We give a generic way to preserve pure functional congruences by means of an effects delimiter. The effects delimiter is defined semantically using the retraction techniques of [14], but can also be given an operational semantics. We show that the effects delimiter restores observational congruences between purely functional pieces of code, thus achieving a modular separation between the purely functional language and its extensions. 1 Introduction Functional programming is a powerful paradigm, but it has long been recognized that purely functional programs are often inefficient and cumbersome. Many modern functional languages, e.g., SML [9], build in control and state features that strictly fall outside the functional paradigm. For example, SML of New Jersey includes a "callwithcurrentcontinuation" opera...
The Typed Polymorphic LabelSelective λCalculus
 IN PROC. ACM SYMPOSIUM ON PRINCIPLES OF PROGRAMMING LANGUAGES
, 1994
"... Formal calculi of record structures have recently been a focus of active research. However, scarcely anyone has studied formally the dual notioni.e., argumentpassing to functions by keywords, and its harmonization with currying. We have. Recently, we introduced the labelselective calculus, a ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
Formal calculi of record structures have recently been a focus of active research. However, scarcely anyone has studied formally the dual notioni.e., argumentpassing to functions by keywords, and its harmonization with currying. We have. Recently, we introduced the labelselective calculus, a conservative extension of calculus that uses a labeling of abstractions and applications to perform unordered currying. In other words, it enables some form of commutation between arguments. This improves program legibility, thanks to the presence of labels, and efficiency, thanks to argument commuting. In this paper, we propose a simply typed version of the calculus, then extend it to one with MLlike polymorphic types. For the latter calculus, we establish the existence of principal types and we give an algorithm to compute them. Thanks to the fact that labelselective calculus is a conservative extension of calculus by adding numeric labels to stand for argument positions, its...
Imperative Lambda Calculus Revisited
, 1997
"... Imperative Lambda Calculus is a type system designed to combine functional and imperative programming features in an orthogonal fashion without compromising the algebraic properties of functions. It has been noted that the original system is too restrictive and lacks the subject reduction property. ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
Imperative Lambda Calculus is a type system designed to combine functional and imperative programming features in an orthogonal fashion without compromising the algebraic properties of functions. It has been noted that the original system is too restrictive and lacks the subject reduction property. We define a revised type system that solves these problems using ideas from Reynolds's Syntactic Control of Interference. We also extend it to handle HindleyMilner style polymorphism and devise type reconstruction algorithms. A sophisticated constraint language is designed to formulate principal types for terms. 1 Introduction The recent research in programming languages has greatly clarified the interaction between imperative and functional programming. The conventional notion that functional programming and imperative statemanipulation are in conflict has been dispelled. Several programming languages have now been designed which combine functions and assignments without destroying algeb...
Type reconstruction for SCI
 Functional Programming, Glasgow 1995, Electronic Workshops in Computing
, 1996
"... We present atype reconstruction algorithm for SCIR [10], atype system for a language with syntactic control of interference. SCIR guarantees that terms of passive type do not cause any side e ects, and that distinct identi ers do not interfere. A reconstruction algorithm for this type system must de ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
We present atype reconstruction algorithm for SCIR [10], atype system for a language with syntactic control of interference. SCIR guarantees that terms of passive type do not cause any side e ects, and that distinct identi ers do not interfere. A reconstruction algorithm for this type system must deal with di erent kinds (passive and general) and di erent uses of identi ers (passive and active). In particular, there may not be a unique choice of kinds for type variables. Our work extends SCIR typings with kind constraints. We show that principal type schemes exist for this extended system and outline an algorithm for computing them. 1
Typing of Selective lambdaCalculus
, 1993
"... Record calculi have recently been a very active field of research, but its reciprocal, i.e. the use of keywords in functions, is still ignored. Selective calculus is a conservative extension of lambda calculus which, by labeling abstractions and applications, enables some form of commutation betwee ..."
Abstract
 Add to MetaCart
Record calculi have recently been a very active field of research, but its reciprocal, i.e. the use of keywords in functions, is still ignored. Selective calculus is a conservative extension of lambda calculus which, by labeling abstractions and applications, enables some form of commutation between arguments. It is an enhancement for both clarity, thanks to labels, and power with the possibility to commute. We propose here a simply typed version of this calculus, and show that it extends to second order and polymorphic typing. For this last one there exists a most generic type, and we give the algorithm to find it. This, combined with the fact selective calculus extends naturally lambda calculus, giving numeric labels their intuitive meaning, provides us with a keyword extension for polymorphically typed languages like ML, compatible with the original syntax, where unlabeled abstractions and applications can be seen as labeled by 1. 1 Introduction The idea of introducing labels in ...
Compiling DataParallel Languages for Distributed Memory MultiProcessors
"... This paper introduces a succinct intermediate representation for compiling highlevel, dataparallel languages. It is shown how inferences applied to this representation can infer the necessary information to compile it into efficient code. Further inference procedures are being investigated in orde ..."
Abstract
 Add to MetaCart
This paper introduces a succinct intermediate representation for compiling highlevel, dataparallel languages. It is shown how inferences applied to this representation can infer the necessary information to compile it into efficient code. Further inference procedures are being investigated in order to automatically distribute and align data objects on distributed memory multiprocessors. The inferences shown in this paper are just those which infer the shape, type, rank and `sort' of data parallel operations. Shape inference and type inference create expressions (in the same representation) which evaluate to the type and shape at runtime. Thus the intermediate representation is polymorphic in terms of shape (the shape of dataparallel operations and variables) and type. Inference on an access subtyping structure will eventually provide the mapping information. Compilers from Eval to Fcode and from Fcode to C exist and a new frontend compiler from FORTRAN 90 is being developed, a...
State in Haskell
, 1996
"... Some algorithms make critical internal use of updatable state, even though their external specification is purely functional. Based on earlier work on monads, we present a way of securely encapsulating stateful computations that manipulate multiple, named, mutable objects, in the context of a nonst ..."
Abstract
 Add to MetaCart
Some algorithms make critical internal use of updatable state, even though their external specification is purely functional. Based on earlier work on monads, we present a way of securely encapsulating stateful computations that manipulate multiple, named, mutable objects, in the context of a nonstrict, purelyfunctional language. The security of the encapsulation is assured by the type system, using parametricity. The same framework is also used to handle input/output operations (state changes on the external world) and calls to C.
Doctor Thesis LABELSELECTIVE LAMBDACALCULI AND TRANSFORMATION CALCULI
, 1994
"... The labelselective lambdacalculus, in its different variants, and its offspring, the transformation calculus, are the results of a research on the role of Currying in the lambda calculus. Currying is the simple trick by which functions of multiple arguments can be written in the lambda calculus, w ..."
Abstract
 Add to MetaCart
The labelselective lambdacalculus, in its different variants, and its offspring, the transformation calculus, are the results of a research on the role of Currying in the lambda calculus. Currying is the simple trick by which functions of multiple arguments can be written in the lambda calculus, which is essentialy monoargument. The idea is to transform a function on a pair, into a function whose result, once applied to its first argument, must be applied to its second one. That is f (a; b) = (f (a))(b). In our first system, the labelselective lambdacalculus, we give a method to curry starting from a labeled record, in place of a simple pair. The calculus we encode in has to be more complex than simple lambdacalculus, because of these labels, but it appears to keep the quasi totality of its properties. We have of course confluence, and models similar to lambda calculus; and we can apply both simple and polymorphic typings, for which we get strong normalization, as we had with lambda calculus. An immediate application of such a system is to add outoforder labeled application to curried functional languages, like ML. Since Currying introduces partial applications,