Results 1  10
of
60
Comprehending Monads
 Mathematical Structures in Computer Science
, 1992
"... Category theorists invented monads in the 1960's to concisely express certain aspects of universal algebra. Functional programmers invented list comprehensions in the 1970's to concisely express certain programs involving lists. This paper shows how list comprehensions may be generalised t ..."
Abstract

Cited by 522 (16 self)
 Add to MetaCart
(Show Context)
Category theorists invented monads in the 1960's to concisely express certain aspects of universal algebra. Functional programmers invented list comprehensions in the 1970's to concisely express certain programs involving lists. This paper shows how list comprehensions may be generalised to an arbitrary monad, and how the resulting programming feature can concisely express in a pure functional language some programs that manipulate state, handle exceptions, parse text, or invoke continuations. A new solution to the old problem of destructive array update is also presented. No knowledge of category theory is assumed.
Linear Types Can Change the World!
 PROGRAMMING CONCEPTS AND METHODS
, 1990
"... The linear logic of J.Y. Girard suggests a new type system for functional languages, one which supports operations that "change the world". Values belonging to a linear type must be used exactly once: like the world, they cannot be duplicated or destroyed. Such values require no refere ..."
Abstract

Cited by 146 (9 self)
 Add to MetaCart
The linear logic of J.Y. Girard suggests a new type system for functional languages, one which supports operations that "change the world". Values belonging to a linear type must be used exactly once: like the world, they cannot be duplicated or destroyed. Such values require no reference counting or garbage collection, and safely admit destructive array update. Linear types extend Schmidt's notion of single threading; provide an alternative to Hudak and Bloss' update analysis; and offer a practical complement to Lafont and Holmström's elegant linear languages.
Lazy functional state threads
 In the ACM SIGPLAN Conference on Programming Language Design and Implementation
, 1994
"... 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

Cited by 124 (12 self)
 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. Intriguingly, this parametricity requires the provision of a (single) constant with a rank2 polymorphic type. 1
How to Declare an Imperative
, 1995
"... How can we integrate interaction into a purely declarative language? This tutorial describes a solution to this problem based on a monad. The solution has been implemented in the functional language Haskell and the declarative language Escher. Comparisons are given to other approaches to interaction ..."
Abstract

Cited by 111 (3 self)
 Add to MetaCart
How can we integrate interaction into a purely declarative language? This tutorial describes a solution to this problem based on a monad. The solution has been implemented in the functional language Haskell and the declarative language Escher. Comparisons are given to other approaches to interaction based on synchronous streams, continuations, linear logic, and side effects.
Is there a use for linear logic?
, 1991
"... Past attempts to apply Girard's linear logic have either had a clear relation to the theory (Lafont, Holmstrom, Abramsky) or a clear practical value (Guzm'an and Hudak, Wadler), but not both. This paper defines a sequence of languages based on linear logic that span the gap between theory ..."
Abstract

Cited by 98 (7 self)
 Add to MetaCart
Past attempts to apply Girard's linear logic have either had a clear relation to the theory (Lafont, Holmstrom, Abramsky) or a clear practical value (Guzm'an and Hudak, Wadler), but not both. This paper defines a sequence of languages based on linear logic that span the gap between theory and practice. Type reconstruction in a linear type system can derive information about sharing. An approach to linear type reconstruction based on use types is presented. Applications to the array update problem are considered.
Once Upon a Type
 In Functional Programming Languages and Computer Architecture
, 1995
"... A number of useful optimisations are enabled if we can determine when a value is accessed at most once. We extend the HindleyMilner type system with uses, yielding a typeinference based program analysis which determines when values are accessed at most once. Our analysis can handle higherorder fun ..."
Abstract

Cited by 90 (2 self)
 Add to MetaCart
A number of useful optimisations are enabled if we can determine when a value is accessed at most once. We extend the HindleyMilner type system with uses, yielding a typeinference based program analysis which determines when values are accessed at most once. Our analysis can handle higherorder functions and data structures, and admits principal types for terms. Unlike previous analyses, we prove our analysis sound with respect to callbyneed reduction. Callbyname reduction does not provide an accurate model of how often a value is used during lazy evaluation, since it duplicates work which would actually be shared in a real implementation. Our type system can easily be modified to analyse usage in a callbyvalue language. 1 Introduction This paper describes a method for determining when a value is used at most once. Our method is based on a simple modification of the HindleyMilner type system. Each type is labelled to indicate whether the corresponding value is used at most onc...
A Semantic Model of Reference Counting and its Abstraction
 In Proceedings ACM Conference on Lisp and Functional Programming
, 1986
"... Interpretation of Reference Counting The semantics presented thus far is exact, and thus evaluating a particular reference count may not terminate, any more than a program in the standard semantics would. For use by a compiler we must choose a suitable abstraction (i.e., approximation) that will gu ..."
Abstract

Cited by 73 (0 self)
 Add to MetaCart
(Show Context)
Interpretation of Reference Counting The semantics presented thus far is exact, and thus evaluating a particular reference count may not terminate, any more than a program in the standard semantics would. For use by a compiler we must choose a suitable abstraction (i.e., approximation) that will guarantee termination yet still provide useful information about the true reference counts. For us a suitable abstraction is one in which the inferred reference count is at least as great as the true one; i.e., we wish to err on the side of thinking there are more pointers to an object than there actually are. In this section we methodically develop such an abstraction in which: (1) the base domains are abstracted to powersets of finite approximations, (2) the primitive functions are abstracted similarly, (3) an abstract interpretation is thus induced on R p and R, and finally (4) a collecting interpretation of expressions is developed. 4.1 Preliminaries To set up things to come, we first gi...
Static and Dynamic Semantics Processing
 Proceedings of the Eighteenth Annual ACM Symposium on Principles of Programming Languages
, 1991
"... This paper presents a step forward in the use of partial evaluation for interpreting and compiling programs, as well as for automatically generating a compiler from denotational definitions of programming languages. We determine the static and dynamic semantics of a programming language, reduce the ..."
Abstract

Cited by 48 (23 self)
 Add to MetaCart
(Show Context)
This paper presents a step forward in the use of partial evaluation for interpreting and compiling programs, as well as for automatically generating a compiler from denotational definitions of programming languages. We determine the static and dynamic semantics of a programming language, reduce the expressions representing the static semantics, and generate object code by instantiating the expressions representing the dynamic semantics. By processing the static semantics of the language, programs get compiled. By processing the static semantics of the partial evaluator, compilers are generated. The correctness of a compiler is guaranteed by the correctness of both the executable specification and our partial evaluator. The results reported in this paper improve on previous work in the domain of compiler generation [16, 30], and solves several open problems in the domain of partial evaluation [15]. In essence: ffl Our compilation goes beyond a mere syntaxtosemantics mapping since the ...
Assignments for applicative languages
 Conf. on Functional Program. Lang. and Comput. Arch
, 1991
"... We propose a theoretical framework for adding assignments and dynamic data to functional languages without violating their semantic properties. This differs from semifunctional languages like Scheme and ML in that values of expressions remain static and sideeffectfree. A new form of abstraction c ..."
Abstract

Cited by 39 (11 self)
 Add to MetaCart
We propose a theoretical framework for adding assignments and dynamic data to functional languages without violating their semantic properties. This differs from semifunctional languages like Scheme and ML in that values of expressions remain static and sideeffectfree. A new form of abstraction called observer is designed to encapsulate stateoriented computation from the remaining purely applicative computation. The type system ensures that observers are combined linearly, allowing an implementation in terms of a global store. The utility of this extension is in manipulating shared dynamic data embedded in data structures. Evaluation of welltyped programs is ChurchRosser. Thus, programs produce the same results whether an eager or lazy evaluation order is used (assuming termination). A simple, sound logic permits reasoning about welltyped programs. The benefits of this work include greater expressive power and efficiency (compared to applicative languages), while retaining simplicity of reasoning.
Observers for Linear Types
 ESOP ’92: 4th European Symposium on Programming, Rennes, France, Proceedings
, 1992
"... Linear types provide the framework for a safe embedding of mutable state in functional languages by enforcing the principle that variables of linear type must be used exactly once. A potential disadvantage of this approach is that it places read accesses to suchvariables under the same restrictio ..."
Abstract

Cited by 30 (4 self)
 Add to MetaCart
(Show Context)
Linear types provide the framework for a safe embedding of mutable state in functional languages by enforcing the principle that variables of linear type must be used exactly once. A potential disadvantage of this approach is that it places read accesses to suchvariables under the same restriction as write accesses, and thus prevents reads to proceed in parallel. We present here an extension of linear types which augments the usual distinction between linear and nonlinear bya third state, observers of linear variables. Since, unlike linear variables, observers can be duplicated, multiple concurrent reads are made possible. On the other hand, observers must be shortlived enough to never overlap with mutations. The resulting type system is in many aspects similar to the one of ML: It is polymorphic, has principal types, and admits a type reconstruction algorithm. 1 Introduction We are investigating a type system that addresses the update problem in functional languages: How...