Results 1 
5 of
5
Infinite Objects in Type Theory
"... . We show that infinite objects can be constructively understood without the consideration of partial elements, or greatest fixedpoints, through the explicit consideration of proof objects. We present then a proof system based on these explanations. According to this analysis, the proof expressions ..."
Abstract

Cited by 83 (2 self)
 Add to MetaCart
. We show that infinite objects can be constructively understood without the consideration of partial elements, or greatest fixedpoints, through the explicit consideration of proof objects. We present then a proof system based on these explanations. According to this analysis, the proof expressions should have the same structure as the program expressions of a pure functional lazy language: variable, constructor, application, abstraction, case expressions, and local let expressions. 1 Introduction The usual explanation of infinite objects relies on the use of greatest fixedpoints of monotone operators, whose existence is justified by the impredicative proof of Tarski's fixed point theorem. The proof theory of such infinite objects, based on the so called coinduction principle, originally due to David Park [21] and explained with this name for instance in the paper [18], reflects this explanation. Constructively, to rely on such impredicative methods is somewhat unsatisfactory (see fo...
Implicit and Explicit Parallel Programming in Haskell
, 1993
"... Abstract It has often been suggested that functional languages provide an excellent basis for programming parallel computer systems. This is largely a result of the lack of side effects which makes it possible to evaluate the subexpressions of a given term without any risk of interference. On the ot ..."
Abstract

Cited by 31 (1 self)
 Add to MetaCart
Abstract It has often been suggested that functional languages provide an excellent basis for programming parallel computer systems. This is largely a result of the lack of side effects which makes it possible to evaluate the subexpressions of a given term without any risk of interference. On the other hand, the lack of sideeffects has also been seen as a weakness of functional languages since it rules out many features of traditional imperative languages such as state, I/O and exceptions. These ideas can be simulated in a functional language but the resulting programs are sometimes unnatural and inefficient. On the bright side, recent work has shown how many of these features can be naturally incorporated into a functional language without compromising efficiency by expressing computations in terms of monads or continuations. Unfortunately, the "singlethreading " implied by these techniques often destroys many opportunities for parallelism. In this paper, we describe a simple extension to the Haskell I/O monad that allows a form of explicit highlevel concurrency. It is a simple matter to incorporate these features in a sequential implementation, and genuine parallelism can be obtained on a parallel machine. In addition, the inclusion of constructs for explicit concurrency enhances the use of Haskell as an executable specification language, since some programs are most naturally described as a composition of parallel processes. \Lambda This research was supported by ARPA via a subcontract to Intermetrics, Inc. 1
A nondeterministic callbyneed lambda calculus
 INTERNATIONAL CONFERENCE ON FUNCTIONAL PROGRAMMING
, 1998
"... In this paper we present a nondeterministic callbyneed (untyped) lambda calculus nd with a constant choice and a letsyntax that models sharing. Our main result is that nd has the nice operational properties of the standard lambda calculus: confluence on sets of expressions, and normal order redu ..."
Abstract

Cited by 14 (7 self)
 Add to MetaCart
In this paper we present a nondeterministic callbyneed (untyped) lambda calculus nd with a constant choice and a letsyntax that models sharing. Our main result is that nd has the nice operational properties of the standard lambda calculus: confluence on sets of expressions, and normal order reduction is sufficient to reach head normal form. Using a strong contextual equivalence we show correctness of several program transformations. In particular of lambdalifting using deterministic maximal free expressions. These results show that nd is a new and also natural combination of nondeterminism and lambdacalculus, which has a lot of opportunities for parallel evaluation. An intended application of nd is as a foundation for compiling lazy functional programming languages with I/O based on direct calls. The set of correct program transformations can be rigorously distinguished from noncorrect ones. All program transformations are permitted with the slight exception that for transformations like common subexpression elimination and lambdalifting with maximal free expressions the involved subexpressions have to be deterministic ones.
FUNDIO: A LambdaCalculus with a letrec, case, Constructors, and an IOInterface: Approaching a Theory of unsafePerformIO
, 2003
"... This paper proposes a nonstandard way to combine lazy functional languages with I/O. In order to demonstrate the usefulness of the approach, a tiny lazy functional core language “FUNDIO”, which is also a callbyneed lambda calculus, is investigated. The syntax of “FUNDIO ” has case, letrec, constr ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
This paper proposes a nonstandard way to combine lazy functional languages with I/O. In order to demonstrate the usefulness of the approach, a tiny lazy functional core language “FUNDIO”, which is also a callbyneed lambda calculus, is investigated. The syntax of “FUNDIO ” has case, letrec, constructors and an IOinterface: its operational semantics is described by smallstep reductions. A contextual approximation and equivalence depending on the inputoutput behavior of normal order reduction sequences is defined and a context lemma is proved. This enables to study a semantics of “FUNDIO ” and its semantic properties. The paper demonstrates that the technique of complete reduction diagrams enables to show a considerable set of program transformations to be correct. Several optimizations of evaluation are given, including strictness optimizations and an abstract machine, and shown to be correct w.r.t. contextual equivalence. Correctness of strictness optimizations also justifies correctness of parallel evaluation.
Thus this calculus has a potential to integrate nonstrict functional programming with a nondeterministic approach to inputoutput and also to provide a useful semantics for this combination.
It is argued that monadic IO and unsafePerformIO can be combined in Haskell, and that the result is reliable, if all reductions and transformations are correct w.r.t. to the FUNDIOsemantics. Of course, we do not address the typing problems the are involved in the usage of Haskell’s
unsafePerformIO.
The semantics can also be used as a novel semantics for strict functional languages with IO, where the sequence of IOs is not fixed.
NonDeterminism in a Functional Setting (Extended Abstract)
 In Proceedings 8th LICS
, 1993
"... ) C.H. Luke Ong Computer Laboratory, University of Cambridge, Pembroke Street, CB2 3QG England. Email: Luke.Ong@cl.cam.ac.uk and discs, National University of Singapore. Abstract The pure untyped Lambda Calculus augmented with an (erratic) choice operator is considered as an idealised nondeter ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
) C.H. Luke Ong Computer Laboratory, University of Cambridge, Pembroke Street, CB2 3QG England. Email: Luke.Ong@cl.cam.ac.uk and discs, National University of Singapore. Abstract The pure untyped Lambda Calculus augmented with an (erratic) choice operator is considered as an idealised nondeterministic functional language. Both the "may" and the "must" modalities of convergence are of interest to us. Following Abramsky's work on domain theory in logical form, we identify the denotational type that captures our computational situation: ffi = P[[ffi ! ffi ] ? ] where P[\Gamma] is the Plotkin powerdomain functor. We then carry out a systematic programme which hinges on three distinct interpretations of ffi , namely, processtheoretic, denotational and logical. The main theme of our programme is the complementarity of the various interpretations of ffi . This work may be seen as a step towards a reapprochement between the algebraic theory of processes in Concurrency on the one hand, ...