We present a formulae-as-types interpretation of Subtractive Logic (i.e. bi-intuitionistic logic). This presentation is two-fold: we first define a very natural restriction of the λµ-calculus which is closed under reduction and whose type system is a constructive restriction of the Classical Natural Deduction. Then we extend this deduction system conservatively to Subtractive Logic. From a computational standpoint, the resulting calculus provides a type system for first-class coroutines (a restricted form of first-class continuations). Keywords: Curry-Howard isomorphism, Subtractive Logic, control operators, coroutines. 1

. The UniForM Concurrency Toolkit is a comprehensive library of abstract data types for shared memory and message passing communication that extends Concurrent Haskell with a concept of dynamic types, thread identity, thread local state and selective communication as found in CML. Notable features of the toolkit are its support for reentrant monitors, interactors providing iterative choice and the uniform representation of internal channel events as well as external tool events of the environment in the form of first class synchronous event values. 1 Introduction The UniForM Concurrency ToolKit 1 has primarily been designed to support the development of reactive systems using Concurrent Haskell [PJGF96]. The toolkit provides, partially backed up by a class system, a number of archetypical shared memory abstractions such as semaphores, locks and shared variables. The most important contribution, however, is the concept of reentrant monitors, whose main advantage over MVar's is that r...

In Concurrent ML, synchronization abstractions can be defined and passed as values, much like functions in ML. This mechanism admits a fairly powerful, modular style of concurrent programming, called higher-order concurrent programming. Unfortunately, it is not clear whether this style of programming can be practiced in languages such as Concurrent Haskell, that support only first-order message passing. Indeed, the implementation of synchronization abstractions in Concurrent ML relies on fairly low-level, languagespecific details. Fortunately, it turns out that synchronization abstractions can in fact be supported in a language that supports only first-order message passing. We implement such a library in this paper. This library makes it possible to practice Concurrent ML-style programming directly in Concurrent Haskell. We begin with a core implementation of synchronization abstractions in the π-calculus, that serves as a foundation for other concrete implementations. Then, we extend this implementation to encode all of Concurrent ML’s concurrency primitives (and more!) in Concurrent Haskell. Our implementation is surprisingly efficient, even without possible optimizations. Preliminary experiments suggest that our library can consistently outperform a standard implementation of Concurrent ML-style primitives. At the heart of our implementation is a new distributed synchronization protocol that we prove correct. Unlike several previous translations of synchronization abstractions in concurrent languages, we remain faithful to the standard semantics for Concurrent ML’s concurrency primitives; for example, we retain the symmetry of choose, that is required to express generalized selective communication. As a corollary, we establish that implementing generalized selective communication on distributed machines is no harder than implementing first-order message passing on such machines.

We define a very natural restriction of the λµ-calculus which is stable under reduction and whose type system is a restriction of the Classical Natural Deduction to intuitionistic logic. However, we show that this system is in some sense degenerated unless we provide a native disjunction. We prove that the system with native disjunction is conservative over DIS-logic and also that DIS-logic is constructive. From a computational standpoint, this restriction on λµ-terms prevents a coroutine from accessing the local environment of another coroutine.

Abstract. Writing concurrent programs in languages that lack explicit support for concurrency can often be awkward and difficult. Haskell’s monads provide a way to explicitly specify sequence and effects in a functional language, and monadic combinators allow composition of monadic actions, for example via parallelism and choice – two core aspects of Communicating Sequential Processes (CSP). We show how the use of these combinators, and being able to express processes as first-class types (monadic actions) allow for easy and elegant programming of process-oriented concurrency in a new CSP library for Haskell: Communicating Haskell Processes.

Abstract. Writing concurrent programs in languages that lack explicit support for concurrency can often be awkward and difficult. Haskell’s monads provide a way to explicitly specify sequence and effects in a functional language, and monadic combinators allow composition of monadic actions, for example via parallelism and choice – two core aspects of Communicating Sequential Processes (CSP). We show how the use of these combinators, and being able to express processes as first-class types (monadic actions) allow for easy and elegant programming of process-oriented concurrency in a new CSP library for Haskell: Communicating Haskell Processes.