Concurrent programs require high-level abstractions in order to manage complexity and enable compositional reasoning. In this paper, we introduce a novel concurrency abstraction, dubbed transactional events, which combines first-class synchronous message passing events with all-or-nothing transactions. This combination enables simple solutions to interesting problems in concurrent programming. For example, guarded synchronous receive can be implemented as an abstract transactional event, whereas in other languages it requires a non-abstract, non-modular protocol. As another example, three-way rendezvous can be implemented as an abstract transactional event, which is impossible using first-class events alone. Both solutions are easy to code and easy to reason about. The expressive power of transactional events arises from a sequencing combinator whose semantics enforces an all-or-nothing transactional property – either both of the constituent events synchronize in sequence or neither of them synchronizes. This sequencing combinator, along with a non-deterministic choice combinator, gives transactional events the compositional structure of a monad-with-plus. We provide a formal semantics for transactional events and give a detailed account of an implementation.

Language-based security relies on the assumption that all potential attacks are bound by the rules of the language in question. When programs are compiled into a different language, this is true only if the translation process preserves observational equivalence. We investigate the problem of fully abstract compilation, i.e., compilation that both preserves and reflects observational equivalence. In particular, we prove that typed closure conversion for the polymorphic λ-calculus with existential and recursive types is fully abstract. Our proof uses operational techniques in the form of a step-indexed logical relation and construction of certain wrapper terms that “back-translate ” from target values to source values. Although typed closure conversion has been assumed to be fully abstract, we are not aware of any previous result that actually proves this.

. This paper is about the relationship between the theory of monadic types and the practice of concurrent functional programming. We present a typed functional programming language CMML, with a type system based on Moggi's monadic metalanguage, and concurrency based on Reppy's Concurrent ML. We present an operational and denotational semantics for the language, and show that the denotational semantics is fully abstract for may-testing. We show that a fragment of CML can be translated into CMML, and that the translation is correct up to weak bisimulation. Contents 1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 2 Mathematical preliminaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.1 Categories and monads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Partial orders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ....

Transactional events (TE) are an approach to concurrent programming that enriches the first-class synchronous message-passing of Concurrent ML (CML) with a combinator that allows multiple messages to be passed as part of one all-or-nothing synchronization. Donnelly and Fluet (2006) designed and implemented TE as a Haskell library and demonstrated that it enables elegant solutions to programming patterns that are awkward or impossible in CML. However, both the definition and the implementation of TE relied fundamentally on the code in a synchronization not using mutable memory, an unreasonable assumption for mostly functional languages like ML where functional interfaces may have impure implementations. We present a definition and implementation of TE that supports ML-style references and nested synchronizations, both of which were previously unnecessary due to Haskell’s more restrictive type system. As in prior work, we have a high-level semantics that makes nondeterministic choices such that synchronizations succeed whenever possible and a low-level semantics that uses search to implement the high-level semantics soundly and completely. The key design trade-off in the semantics is to allow updates to mutable memory without requiring the implementation to consider all possible thread interleavings. Our solution uses first-class heaps and allows interleavings only when a message is sent or received. We have used Coq to prove the high- and low-level semantics equivalent. We have implemented our approach by modifying the Objective Caml run-time system. By modifying the run-time system, rather than relying solely on a library, we can eliminate the potential for nonterminating computations within unsuccessful synchronizations to run forever.

We develop a model of concurrent imperative programming with threads. We focus on a small imperative language with cooperative threads which execute without interruption until they terminate or explicitly yield control. We define and study a trace-based denotational semantics for this language; this semantics is fully abstract but mathematically elementary. We also give an equational theory for the computational effects that underlie the language, including thread spawning. We then analyze threads in terms of the free algebra monad for this theory. 1

We study an applied typed call-by-value -calculus which in addition to the usual types for higher-order functions contains an extra type called proc, for processes. The constructors for terms of this type are similar to those found in standard process calculi such as CCS. We first give an operational semantics for this language in terms of a labelled transition system which is then used to give a behavioural preorder based on contexts: the expression N dominates M if in every appropriate context if M can produce a boolean value then so can N. Based on standard domain constructors we define a model, a prime algebraic lattice, which is fully abstract with respect to this behaviour preorder.

This paper presents two typed higher-order concurrent functional programming languages, based on Reppy's Concurrent ML. The first is a simplified, monomorphic variant of CML, which allows reduction of terms of any type. The second uses an explicit type constructor for computation, in the style of Moggi's monadic metalanguage. Each of these languages is given an operational semantics, which can be used as the basis of bisimulation equivalence. We show how Moggi's translation of the call-by-value lambdacalculus into the mondadic metalanguage can be extended to these concurrent languages, and that this translation is correct up to weak bisimulation. 1 Introduction Reppy's (1991, 1992) Concurrent ML is an extension of New Jersey ML with features for spawning threads, which can communicate by one-to-one synchronous handshake in the style of Milner's (1989) CCS. There are (at least) two approaches to giving the operational semantics to CML. The `functional language definition' tradition (Mi...

We describe the concurrency monad of the functional language Opal, which realizes a smooth integration of concurrent processes in a purely functional framework, providing a general choice and client-server based communication. We develop an axiomatic semantics for the concurrency monad using a variant of temporal interval logic as syntactic sugar on top of the logic of computable functions. 1. Introduction Extensions of the well-known I/O monad by concurrency and communication have recently been designed and implemented in the context of pure functional languages such as Haskell or Opal [12, 5]. These extensions, which have been applied, for instance, to the construction of graphical user interfaces [4, 5], raise the question of an adequate semantic model of I/O monads in the presence of indeterministic computations. We present a semantic model for the concurrency monad of the purely functional programming and specification language Opal [3] which is formulated by means of a tempora...

This document makes proposals for the data language of Enhanced LOTOS. It describes a core language, plus a module system and standard libraries. Possible approaches to the dynamic and static semantics of the language are sketched out. The relationship of the model to the behavioural part of LOTOS and the other E-LOTOS enhancements are discussed. Contents 1 Summary 3 1.1 Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.2 Coverage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.3 Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.4 Status . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.5 Standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2 Introduction 3 3 Related work 5 3.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 3.2 The PhD Thesis of Ed Brinksma . . . . . . . . . . . . . . . . . . . . . 5 3.3 The LOTOSPHERE pr...

We develop a model of concurrent imperative programming with threads. We focus on a small imperative language with cooperative threads which execute without interruption until they terminate or explicitly yield control. We define and study a trace-based denotational but mathematically elementary. We also give an equational theory for the computational effects that underlie the language, including thread spawning. We then analyze threads in terms of the free algebra monad for this theory.