This paper outlines the design and implementation of Glasgow distributed Haskell (GdH), a non-strict distributed functional language. The language

Abstract. This paper develops a language for reasoning about concurrent functional I/O. We assume that the API is specified as statetransformers on a single world state. We then prove that under certain conditions evaluation in this language is deterministic, and give some examples. All properties were machine-verified using the Sparkle proofassistant and using Core-Clean as a meta-language. 1

Abstract. This paper provides a self-contained formal description of the dynamic properties of Hume, a novel functionally-based concurrent language that aims to target space- and time-critical systems such as safetycritical, embedded and real-time systems. The language is designed to support rigorous cost and space analyses, whilst providing a high level of abstraction including polymorphic type inference, automatic memory management, higher-order functions, exception-handling and a good range of primitive types. 1

The problem of expressing I/O and side effects in functional languages is a well-established one. This paper addresses this problem from a general semantic viewpoint by giving a unified framework for describing shared state, I/O and deterministic concurrency. We develop a modified state transformer which lets us mathematically model the API, then investigate and machine verify some broad conditions under which confluence holds. This semantics is used as the basis for a small deterministic Haskell language extension called CURIO, which enforces determinism using runtime checks. Our confluence condition is first shown to hold for a variety of small components, such as individual shared variables, 1-to-1 communication channels, and I-structures. We then show how models of substantial APIs (like a modification of Haskell’s file I/O API which permits inter-process communication) may be constructed from these smaller components using “combinators ” in such a way that determinism is always preserved. We describe combinators for product, name-indexing and dynamic allocation, the last of which requires some small extensions to cater for process locality.

This document describes the Hume programming language. Hume (Higher-order Unified Meta-Environment) is a strongly typed, functionally-based language with an integrated tool set for developing, proving and assessing concurrent, resource-limited systems, such as embedded or safetycritical systems. It aims to extend the frontiers of language design for such systems, introducing new levels of abstraction and provability

This paper outlines the design and implementation of Glasgow Distributed Haskell (GdH). GdH combines the multiple processes of Concurrent Haskell with the multiple processing elements (PEs) of Parallel Haskell (GpH). It brings explicit PE identi ers to the language level thereby enabling the distribution of processes.

This thesis presents the Brisk Machine #54#, a machine for executing functional languages, designed to be simple and #exible to support a number of run-time execution models for the Brisk compiler. Design considerations have been made to support dynamic loading, deterministic concurrency #23,51#, distribution, debugging tools and logic programming #76#. To achieve this, the compiler's intermediate language, the Brisk Kernel Language BKL is simpler than the STG language #100#, as evaluation, extension and optimisation issues are relegated to special built-in functions. Moreover, function calls are saturated, as any function has an known arity and in every call to it, is applied to the rightnumber of arguments, which makes the machine dynamic and supports dynamic loading.

Abstract not found