## A Concurrent Lambda Calculus with Futures (2006)

### Cached

### Download Links

- [www.ps.uni-sb.de]
- [www.ps.uni-sb.de]
- [www.ps.uni-sb.de]
- DBLP

### Other Repositories/Bibliography

Venue: | THEORETICAL COMPUTER SCIENCE |

Citations: | 26 - 4 self |

### BibTeX

@ARTICLE{Niehren06aconcurrent,

author = {Joachim Niehren and Jan Schwinghammer and Gert Smolka},

title = {A Concurrent Lambda Calculus with Futures},

journal = {THEORETICAL COMPUTER SCIENCE},

year = {2006},

volume = {364},

number = {3},

pages = {338--356}

}

### OpenURL

### Abstract

We introduce a new lambda calculus with futures, λ(fut), to model the operational semantics of concurrent extensions of ML. λ(fut) can safely express a variety of high-level concurrency constructs, including channels, semaphores, or ports. Safe implementations of these constructs in (fut) cannot be corrupted in any well-typed context. We prove safety on basis of a linear type system.

### Citations

547 | Conjoining Specifications
- Abadi, Lamport
- 1993
(Show Context)
Citation Context ...rom Γ ′ , which we write Γ ′ − x. The typing rule for a parallel composition C1 | C2 is reminiscent of the circular assume-guarantee reasoning used in compositional verification of concurrent systems =-=[1]-=-. Recall that the combined environment Γ1, Γ2 in the conclusion is only defined if the variables appearing in Γ1 and Γ2 are disjoint. So the rule ensures that the sets of variables declared by C2 and ... |

460 | Multilisp: A language for concurrent symbolic computation
- Halstead
- 1985
(Show Context)
Citation Context ...ronisation is based on futures rather than channels [22, 20, 10]. Many ideas in Alice are inspired by and inherited from the concurrent constraint programming language Mozart-Oz [26, 13, 19]. Futures =-=[5, 12]-=- are a restricted form of logic variables, which carefully separate read and write permissions. In contrast to logic variables, futures grant for static data flow that can be predicted at compile time... |

343 | The mechanical evaluation of expressions - Landin - 1964 |

306 | The Oz Programming Model
- Smolka
- 1995
(Show Context)
Citation Context ...of SML where all synchronisation is based on futures rather than channels [22, 20, 10]. Many ideas in Alice are inspired by and inherited from the concurrent constraint programming language Mozart-Oz =-=[26, 13, 19]-=-. Futures [5, 12] are a restricted form of logic variables, which carefully separate read and write permissions. In contrast to logic variables, futures grant for static data flow that can be predicte... |

276 | The polyadic -calculus: a tutorial - Milner - 1991 |

275 |
The family of concurrent logic programming languages
- Shapiro
- 1989
(Show Context)
Citation Context ...to logic variables, futures grant for static data flow that can be predicted at compile time. Otherwise, they behave like the logic variables of concurrent logic and concurrent constraint programming =-=[25, 24]-=-: A future is a transparent placeholder for a value; it disappears once its value becomes available. Operations that need the value of a future block until the value becomes available. Other operation... |

262 | Semantic foundations of concurrent constraint programming
- Saraswat, Rinard, et al.
- 1991
(Show Context)
Citation Context ...to logic variables, futures grant for static data flow that can be predicted at compile time. Otherwise, they behave like the logic variables of concurrent logic and concurrent constraint programming =-=[25, 24]-=-: A future is a transparent placeholder for a value; it disappears once its value becomes available. Operations that need the value of a future block until the value becomes available. Other operation... |

260 | Pict: A programming language based on the picalculus
- Pierce, Turner
- 1997
(Show Context)
Citation Context ...approaches to concurrent programming: It prohibited static typing in programming languages with unrestricted logic variables such as Oz [18, 26] and in π-calculus based extensions of SML such as Pict =-=[21]-=-. The problem for πcalculus based channel approaches was solved with the join-calculus [10, 11] and the corresponding programming language JoCaml [8] which extends on CAML [7]. The join-calculus, howe... |

245 |
The reflexive chemical abstract machine and the join-calculus
- Fournet, Gonthier
- 1996
(Show Context)
Citation Context ...oncurrent extension of Standard ML (SML) [17] for typed open distributed programming. Alice is the first concurrent extension of SML where all synchronisation is based on futures rather than channels =-=[22, 20, 10]-=-. Many ideas in Alice are inspired by and inherited from the concurrent constraint programming language Mozart-Oz [26, 13, 19]. Futures [5, 12] are a restricted form of logic variables, which carefull... |

237 | I-structures: Data structure for parallel computing
- Arvind, Nikhil, et al.
- 1989
(Show Context)
Citation Context ...futures. We propose to add indeterminism via reference cells, as these are already available in SML. Furthermore, we propose handled futures for single assignment, similarly to the I-structures of Id =-=[4]-=- and promises of [14]. A handled future comes with a handle that can eventually assign a value to a future. Any attempt to use the same handle twice raises a programming error. Explicit recursion. Sim... |

208 | Concurrent Haskell - Jones, Gordon, et al. |

188 | A Call-By-Need Lambda Calculus
- Ariola, Felleisen, et al.
- 1995
(Show Context)
Citation Context ...chnical problems, some of which are known from call-by-need λ-calculi with explicit recursion. Indeed, we can easily extend λ(fut) by lazy threads, so that we obtain an elegant model for call-by-need =-=[3, 15]-=- mixed with call-by-value computation. Static typing. We have to add a type system, as previous λ-calculi with futures were untyped. We show that λ(fut) can safely express concurrency constructs, so t... |

184 | A Natural Semantics for Lazy Evaluation - Launchbury - 1993 |

179 | The polyadic π-calculus: A tutorial
- Milner
- 1992
(Show Context)
Citation Context ... and expression, resp., and e[ e ′ /x] for capture-free substitution of e ′ for x in e. We do not want the order of components in configurations to matter. Following the presentation of π-calculus in =-=[16]-=- we use a structural congruence ≡ to simplify the statement of the operational semantics. This is the least congruence relation on configurations containing the identities in Fig. 2. The first two 3sa... |

148 |
Concurrent Programming in ML
- Reppy
- 1999
(Show Context)
Citation Context ...oncurrent extension of Standard ML (SML) [17] for typed open distributed programming. Alice is the first concurrent extension of SML where all synchronisation is based on futures rather than channels =-=[22, 20, 10]-=-. Many ideas in Alice are inspired by and inherited from the concurrent constraint programming language Mozart-Oz [26, 13, 19]. Futures [5, 12] are a restricted form of logic variables, which carefull... |

143 |
Promises: linguistic support for efficient asynchronous procedure calls in distributed systems
- Liskov, Shrira
- 1988
(Show Context)
Citation Context ...to add indeterminism via reference cells, as these are already available in SML. Furthermore, we propose handled futures for single assignment, similarly to the I-structures of Id [4] and promises of =-=[14]-=-. A handled future comes with a handle that can eventually assign a value to a future. Any attempt to use the same handle twice raises a programming error. Explicit recursion. Similarly to cells, hand... |

140 | Linearity and the pi-calculus - Kobayashi, Pierce, et al. - 1996 |

138 | types can change the world!, in - Wadler, Linear - 1990 |

95 | Simple imperative polymorphism - Wright - 1994 |

85 | Once upon a type
- Turner, Wadler, et al.
- 1995
(Show Context)
Citation Context ...hat these cannot be corrupted in any well-typed context, in that their usage never raises handle errors. We prove this kind of safety result on basis of a linear type system we introduce, inspired by =-=[27]-=-. We present λ(fut) in Sects. 2 and 3. The linear type system for λ(fut) that excludes handle errors is given in Sect. 4. We then express diverse concurrency constructs in λ(fut) (Sect. 5) and prove t... |

77 | The incremental garbage collection of processes
- Hewitt
- 1977
(Show Context)
Citation Context ...ronisation is based on futures rather than channels [22, 20, 10]. Many ideas in Alice are inspired by and inherited from the concurrent constraint programming language Mozart-Oz [26, 13, 19]. Futures =-=[5, 12]-=- are a restricted form of logic variables, which carefully separate read and write permissions. In contrast to logic variables, futures grant for static data flow that can be predicted at compile time... |

65 | The π-Calculus in Direct Style - Boudol - 1998 |

48 | Implicit typing à la ML for the join-calculus
- Fournet, Maranget, et al.
- 1997
(Show Context)
Citation Context ...with unrestricted logic variables such as Oz [18, 26] and in π-calculus based extensions of SML such as Pict [21]. The problem for πcalculus based channel approaches was solved with the join-calculus =-=[10, 11]-=- and the corresponding programming language JoCaml [8] which extends on CAML [7]. The join-calculus, however, does not model futures on which we focus in this paper.sWe introduce a new concurrent lamb... |

43 | Generativity and dynamic opacity for abstract types - Rossberg - 2003 |

42 | The call-by-need lambda calculus
- Maraist, Odersky, et al.
- 1998
(Show Context)
Citation Context ...chnical problems, some of which are known from call-by-need λ-calculi with explicit recursion. Indeed, we can easily extend λ(fut) by lazy threads, so that we obtain an elegant model for call-by-need =-=[3, 15]-=- mixed with call-by-value computation. Static typing. We have to add a type system, as previous λ-calculi with futures were untyped. We show that λ(fut) can safely express concurrency constructs, so t... |

40 | Fessant. Jocaml: Mobile agents for objective-cam
- Conchon, Le
(Show Context)
Citation Context ...n π-calculus based extensions of SML such as Pict [21]. The problem for πcalculus based channel approaches was solved with the join-calculus [10, 11] and the corresponding programming language JoCaml =-=[8]-=- which extends on CAML [7]. The join-calculus, however, does not model futures on which we focus in this paper.sWe introduce a new concurrent lambda calculus with futures λ(fut) that models the operat... |

39 | A fully abstract may testing semantics for concurrent objects - Jeffrey, Rathke |

37 | Lambda calculus with explicit recursion - Ariola, Klop - 1997 |

37 | A Theory of Distributed Object - Caromel, Henrio - 2005 |

28 |
The semantics of future and an application
- Flanagan, Felleisen
- 1999
(Show Context)
Citation Context ...ull expressiveness to define, implement, and combine a variety of standard concurrency constructs, including channels, semaphores, and ports. Previous λ-calculi with futures by Felleisen and Flanagan =-=[9]-=- were proposed to model the parallel execution of otherwise purely functional programs. They too describe a set of parallel threads that communicate through futures. However, our very different perspe... |

27 | Operational interpretations of linear logic - Turner, Wadler - 1999 |

24 | Efficient logic variables for distributed computing
- Haridi, Roy, et al.
- 1999
(Show Context)
Citation Context ...of SML where all synchronisation is based on futures rather than channels [22, 20, 10]. Many ideas in Alice are inspired by and inherited from the concurrent constraint programming language Mozart-Oz =-=[26, 13, 19]-=-. Futures [5, 12] are a restricted form of logic variables, which carefully separate read and write permissions. In contrast to logic variables, futures grant for static data flow that can be predicte... |

21 | Alice through the looking glass
- Rossberg, Botlan, et al.
(Show Context)
Citation Context ...ns and their combinations can be proved: Well-typed implementations cannot be corrupted in any well-typed context. 1 Introduction The goal of this paper is to model the operational semantics of Alice =-=[23, 2]-=-, a concurrent extension of Standard ML (SML) [17] for typed open distributed programming. Alice is the first concurrent extension of SML where all synchronisation is based on futures rather than chan... |

19 | The semantics of Scheme with futures - MOREAU |

13 | The missing link – dynamic components for ML - ROSSBERG |

11 |
Uniqueness type inference
- Barendsen, Smetsers
- 1995
(Show Context)
Citation Context ...ce. We do also not discuss how to deal with handle errors in a concrete programming language. Most previous uses of linear type systems in functional languages, such as the uniqueness typing of Clean =-=[6]-=-, aimed at preserving referential transparency in the presence of side-effects, and taking advantage of destructive updates for efficiency reasons. In contrast, our system rules out a class of program... |

9 |
Developing applications with Objective Caml. O’Reilly and Associates
- Chailloux, Manoury, et al.
- 2000
(Show Context)
Citation Context ...ons of SML such as Pict [21]. The problem for πcalculus based channel approaches was solved with the join-calculus [10, 11] and the corresponding programming language JoCaml [8] which extends on CAML =-=[7]-=-. The join-calculus, however, does not model futures on which we focus in this paper.sWe introduce a new concurrent lambda calculus with futures λ(fut) that models the operational semantics of Alice a... |

6 |
The Standard ML Programming Language (Revised
- Milner, Tofte, et al.
- 1997
(Show Context)
Citation Context ...mplementations cannot be corrupted in any well-typed context. 1 Introduction The goal of this paper is to model the operational semantics of Alice [23, 2], a concurrent extension of Standard ML (SML) =-=[17]-=- for typed open distributed programming. Alice is the first concurrent extension of SML where all synchronisation is based on futures rather than channels [22, 20, 10]. Many ideas in Alice are inspire... |

6 | Generic pickling and minimization - Tack, Kornstaedt, et al. - 2006 |

4 | Set-based Failure Diagnosis for Concurrent Constraint Programming. Doctoral Dissertation. Univ. des Saarlandes, Tech. Fak
- Müller
- 1997
(Show Context)
Citation Context ...s well-known, as it led to serious problems in several previous approaches to concurrent programming: It prohibited static typing in programming languages with unrestricted logic variables such as Oz =-=[18, 26]-=- and in π-calculus based extensions of SML such as Pict [21]. The problem for πcalculus based channel approaches was solved with the join-calculus [10, 11] and the corresponding programming language J... |

4 | Promises: Linguistic support for e#cient asynchronous procedure calls in distributed systems - Liskov, Shrira - 1988 |

2 | Uniform confluence in concurrent computation
- Niehren
- 2000
(Show Context)
Citation Context ...of SML where all synchronisation is based on futures rather than channels [22, 20, 10]. Many ideas in Alice are inspired by and inherited from the concurrent constraint programming language Mozart-Oz =-=[26, 13, 19]-=-. Futures [5, 12] are a restricted form of logic variables, which carefully separate read and write permissions. In contrast to logic variables, futures grant for static data flow that can be predicte... |

1 |
x:β ⊢ e : α and x /∈ fv(e) then Γ ⊢ e : α. Proof. Again, by an induction on Γ ⊢ e : α. – Case e is c: Clearly no variable is free in e in this case, and once(Γ ) = ∅ by the typing rule for constants, so for all x:β ∈ Γ we have |β| = ω. Finally, Γ ⊢ c : Ty
- If
(Show Context)
Citation Context ...chnical problems, some of which are known from call-by-need λ-calculi with explicit recursion. Indeed, we can easily extend λ(fut) by lazy threads, so that we obtain an elegant model for call-by-need =-=[3, 15]-=- mixed with call-by-value computation. Static typing. We have to add a type system, as previous λ-calculi with futures were untyped. We show that λ(fut) can safely express concurrency constructs, so t... |

1 | Uniform con in concurrent computation - Niehren - 2000 |