Results 1  10
of
63
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 to an arbit ..."
Abstract

Cited by 456 (13 self)
 Add to MetaCart
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.
Lively Linear Lisp  'Look Ma, No Garbage!'
 ACM Sigplan Notices
, 1992
"... Linear logic has been proposed as one solution to the problem of garbage collection and providing efficient "updatein place" capabilities within a more functional language. Linear logic conserves accessibility, and hence provides a mechanical metaphor which is more appropriate for a distributedme ..."
Abstract

Cited by 92 (6 self)
 Add to MetaCart
Linear logic has been proposed as one solution to the problem of garbage collection and providing efficient "updatein place" capabilities within a more functional language. Linear logic conserves accessibility, and hence provides a mechanical metaphor which is more appropriate for a distributedmemory parallel processor in which copying is explicit. However, linear logic's lack of sharing may introduce significant inefficiencies of its own. We show an efficient implementation of linear logic called Linear Lisp that runs within a constant factor of nonlinear logic. This Linear Lisp allows RPLACX operations, and manages storage as safely as a nonlinear Lisp, but does not need a garbage collector. Since it offers assignments but no sharing, it occupies a twilight zone between functional languages and imperative languages. Our Linear Lisp Machine offers many of the same capabilities as combinator/graph reduction machines, but without their copying and garbage collection problems. Intr...
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 81 (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 syntax for linear logic
 Presented at Conference on Mathematical Foundations of Programming Language Semantics
, 1993
"... Abstract. This tutorial paper provides an introduction to intuitionistic logic and linear logic, and shows how they correspond to type systems for functional languages via the notion of ‘Propositions as Types’. The presentation of linear logic is simplified by basing it on the Logic of Unity. An app ..."
Abstract

Cited by 72 (5 self)
 Add to MetaCart
Abstract. This tutorial paper provides an introduction to intuitionistic logic and linear logic, and shows how they correspond to type systems for functional languages via the notion of ‘Propositions as Types’. The presentation of linear logic is simplified by basing it on the Logic of Unity. An application to the array update problem is briefly discussed. 1
Strictness Analysis in Logical Form
, 1991
"... This paper presents a framework for comparing two strictness analysis techniques: Abstract interpretation and nonstandard type inference. The comparison is based on the representation of a lattice by its ideals. A formal system for deducing inclusions between ideals of a lattice is presented and p ..."
Abstract

Cited by 44 (2 self)
 Add to MetaCart
This paper presents a framework for comparing two strictness analysis techniques: Abstract interpretation and nonstandard type inference. The comparison is based on the representation of a lattice by its ideals. A formal system for deducing inclusions between ideals of a lattice is presented and proved sound and complete. Viewing the ideals as strictness properties we use the formal system to define a program logic for deducing strictness properties of expressions in a typed lambda calculus. This strictness logic is shown to be sound and complete with respect to the abstract interpretation, which establishes the main result that strictness analysis by typeinference and by abstract interpretation are equally powerful techniques. 1 Introduction Abstract interpretation is a wellestablished technique for static analysis of programs. Its virtue is its strong connection with denotational semantics which provides a means of proving the analysis correct. Its vice is that the process of...
Applications of Linear Logic to Computation: An Overview
, 1993
"... This paper is an overview of existing applications of Linear Logic (LL) to issues of computation. After a substantial introduction to LL, it discusses the implications of LL to functional programming, logic programming, concurrent and objectoriented programming and some other applications of LL, li ..."
Abstract

Cited by 41 (3 self)
 Add to MetaCart
This paper is an overview of existing applications of Linear Logic (LL) to issues of computation. After a substantial introduction to LL, it discusses the implications of LL to functional programming, logic programming, concurrent and objectoriented programming and some other applications of LL, like semantics of negation in LP, nonmonotonic issues in AI planning, etc. Although the overview covers pretty much the stateoftheart in this area, by necessity many of the works are only mentioned and referenced, but not discussed in any considerable detail. The paper does not presuppose any previous exposition to LL, and is addressed more to computer scientists (probably with a theoretical inclination) than to logicians. The paper contains over 140 references, of which some 80 are about applications of LL. 1 Linear Logic Linear Logic (LL) was introduced in 1987 by Girard [62]. From the very beginning it was recognized as relevant to issues of computation (especially concurrency and stat...
Linear Logic and Noncommutativity in the Calculus of Structures
, 2003
"... macro \clap,whichisused on almost every page, came out of such a discussion. This thesis would not exist without the support of my wife Jana. During all the time she has been a continuous source of love and inspiration. This PhD thesis has been written with the financial support of the DFGGraduiert ..."
Abstract

Cited by 38 (12 self)
 Add to MetaCart
macro \clap,whichisused on almost every page, came out of such a discussion. This thesis would not exist without the support of my wife Jana. During all the time she has been a continuous source of love and inspiration. This PhD thesis has been written with the financial support of the DFGGraduiertenkolleg 334 "Spezifikation diskreter Prozesse und Prozesysteme durch operationelle Modelle und Logiken". iii iv Tab l e o f Contents Acknowledgements iii Tab l e of Contents v List of Figures vii 1Introduction 1 1.1Proof Theory andDeclarativeProgramming .................. 1 1.2LinearLogic .................................... 5 1.3Noncommutativity ................................ 8 1.4The Calculus of Structures . .......................... 9 1.5 Summary of Results............................... 12 1.6OverviewofContents.............................. 15 2LinearLogic and the Sequent Calculus 17 2.1Formulaeand Sequents . ............................. 17 2.2Rules andDerivations . .............
Once Upon a Polymorphic Type
, 1998
"... We present a sound typebased `usage analysis' for a realistic lazy functional language. Accurate information on the usage of program subexpressions in a lazy functional language permits a compiler to perform a number of useful optimisations. However, existing analyses are either adhoc and approxim ..."
Abstract

Cited by 38 (5 self)
 Add to MetaCart
We present a sound typebased `usage analysis' for a realistic lazy functional language. Accurate information on the usage of program subexpressions in a lazy functional language permits a compiler to perform a number of useful optimisations. However, existing analyses are either adhoc and approximate, or defined over restricted languages. Our work extends the Once Upon A Type system of Turner, Mossin, and Wadler (FPCA'95). Firstly, we add type polymorphism, an essential feature of typed functional programming languages. Secondly, we include general Haskellstyle userdefined algebraic data types. Thirdly, we explain and solve the `poisoning problem', which causes the earlier analysis to yield poor results. Interesting design choices turn up in each of these areas. Our analysis is sound with respect to a Launchburystyle operational semantics, and it is straightforward to implement. Good results have been obtained from a prototype implementation, and we are currently integrating the system into the Glasgow Haskell Compiler.
Reference Counting as a Computational Interpretation of Linear Logic
 Journal of Functional Programming
, 1996
"... We develop formal methods for reasoning about memory usage at a level of abstraction suitable for establishing or refuting claims about the potential applications of linear logic for static analysis. In particular, we demonstrate a precise relationship between type correctness for a language based o ..."
Abstract

Cited by 34 (0 self)
 Add to MetaCart
We develop formal methods for reasoning about memory usage at a level of abstraction suitable for establishing or refuting claims about the potential applications of linear logic for static analysis. In particular, we demonstrate a precise relationship between type correctness for a language based on linear logic and the correctness of a referencecounting interpretation of the primitives that the language draws from the rules for the `of course' operation. Our semantics is `lowlevel' enough to express sharing and copying while still being `highlevel ' enough to abstract away from details of memory layout. This enables the formulation and proof of a result describing the possible runtime reference counts of values of linear type. Contents 1 Introduction 1 2 Operational Semantics with Memory 4 3 A Programming Language Based on Linear Logic 9 4 Semantics 14 5 Properties of the Semantics 24 6 Linear Logic and Memory 27 7 Discussion 32 A Proofs of the Main Theorems 36 Acknowledgements...
Linear Logic, Monads and the Lambda Calculus
 In 11 th LICS
, 1996
"... Models of intuitionistic linear logic also provide models of Moggi's computational metalanguage. We use the adjoint presentation of these models and the associated adjoint calculus to show that three translations, due mainly to Moggi, of the lambda calculus into the computational metalanguage (direc ..."
Abstract

Cited by 32 (4 self)
 Add to MetaCart
Models of intuitionistic linear logic also provide models of Moggi's computational metalanguage. We use the adjoint presentation of these models and the associated adjoint calculus to show that three translations, due mainly to Moggi, of the lambda calculus into the computational metalanguage (direct, callbyname and callbyvalue) correspond exactly to three translations, due mainly to Girard, of intuitionistic logic into intuitionistic linear logic. We also consider extending these results to languages with recursion. 1. Introduction Two of the most significant developments in semantics during the last decade are Girard's linear logic [10] and Moggi's computational metalanguage [14]. Any student of these formalisms will suspect that there are significant connections between the two, despite their apparent differences. The intuitionistic fragment of linear logic (ILL) may be modelled in a linear model  a symmetric monoidal closed category with a comonad ! which satisfies some extr...