. The paper presents several analyses to detect non-deterministic expressions in the parallel-functional language Eden. First, the need for the analysis is motivated, and then each one is presented. The first one is type-based, while the other two are based on abstract interpretation. Their power and efficiency is discussed, and an example is used to illustrate the differences. Two interesting functions to adapt abstract values to types appear, and they happen to be a Galois connection. 1 Introduction The paper presents several analyses to determine when an Eden [BLOMP96] expression is sure to be deterministic, and when it may be non-deterministic. The parallel-functional language Eden extends the lazy functional language Haskell by constructs to explicitly define and communicate processes. The three main new concepts are process abstractions, process instantiations and the nondeterministic process abstraction merge. Process abstractions of type Process a b can be compared to ...

Using a language without exception handling is like driving a car with no brakes and no seatbelt --- things work fine until something goes wrong. You also learn to drive rather carefully. This paper describes an exception handling extension to the Haskell lazy functional language. The implementation turned out to be very easy but we had problems finding a viable semantics for our system. The resulting semantics is a compromise between theoretical beauty and practical utility. 1 Introduction Haskell is an ivory tower language: full of lofty ideas, built on solid semantic foundations, praised by grey-bearded professors and about as much use in the real world as a chocolate teapot. For Haskell to emerge from the ivory tower, it must be possible to write the kinds of programs that less idealistic programmers can write in C, Java, Ada and other useful languages: programs that interact with the real world in interesting ways (using graphics, GUIs, databases, etc) and which are robust enough...

Non-determinism may affect the referential transparency of the programs written in Eden: If a nondeterministic expression is evaluated in different processes, the variable it is bound to it will denote possibly different values. It would be desirable to warn the programmer about this situation, or to force the evaluation of such an expression so that all the occurrences of the variable have the same value. Additionally there exist sequential transformations that are incorrect when non-determinism is involved. Such transformations should be applied only to those parts of the program that are sure to be deterministic. In this paper several analyses of different efficiency and power are presented. Several techniques are used: A types annotation system and abstract interpretation. 1 Introduction The parallel-functional language Eden extends the lazy functional language Haskell by syntactic constructs to explicitly define and communicate processes. The three main new concepts are process a...

The paper compares three analyses to determine when an Eden expression is sure to be deterministic, and when it may be nondeterministic. This work extends

This paper looks at the issues involved in incorporating nondeterminism into functional languages and particularly in representing the nondeterminacy which may arise in representing parallel programs in a functional language. It presents an implementation which does so without breaking the ability to perform equational reasoning, and shows how it may be incorporated into the APM (Abstract Parallel Machines) methodology for deriving parallel programs [5]. 1 Introduction Nondeterminism occurs when a program can choose between two or more values and this choice is not fixed in advance. It may be constrained under certain conditions, leading to different types of nondeterminism. One common area in which nondeterminism may occur is in parallel programming. This is because processors may execute independently and messages can be sent asynchronously. Here nondeterminism arises from the parallelism itself. The programmer may be unaware of it, and, although it may be useful, it may cau...

We study the encoding of λ [] , the call by name λ-calculus enriched with McCarthy’s amb operator, into the π-calculus. Semantically, amb is a challenging operator, for the fairness constraints that it expresses. We prove that, under a certain interpretation of divergence in the λ-calculus (weak divergence), a faithful encoding is impossible. However, with a different interpretation of divergence (strong divergence), the encoding is possible, and for this case we derive results and coinductive proof methods to reason about λ [] that are similar to those for the encoding of pure λ-calculi. We then use these methods to derive the most important laws concerning amb. We take bisimilarity as behavioural equivalence on the π-calculus, which sheds some light on the relationship between fairness and bisimilarity.

We investigate the extension of non-strict functional languages like Haskell or Clean by a non-deterministic interaction with the external world. Using call-by-need and a natural semantics which describes the reduction of graphs, this can be done such that the Church-Rosser Theorems 1 and 2 hold. Our operational semantics is a base to recognise which particular equivalencies are preserved by program transformations. The amount of sequentialisation may be smaller than that enforced by other approaches, and the programming style is closer to the common one of side-effecting programming. However, not all program transformations used by an optimising compiler for Haskell remain correct in all contexts. Our result can be interpreted as a possibility to extend current I/Omechanism by non-deterministic memoryless function calls. For example, this permits a call to a random number generator. Adding memoryless function calls to monadic I/O is possible and has a potential to extend the Haskell I...

This paper only deals with laws about expressions with one dummy.

Eden is a parallel extension of Haskell allowing the programmer to explicitly specify which expressions must be evaluated as parallel processes. Eden is implemented by modifying the Glasgow Haskell Compiler (GHC). This decision has saved a lot of work but has also produced some drawbacks: Some optimizing transformations done by GHC are not convenient for Eden, either because they spoil its semantics or because they negatively affect its efficiency. The paper explains how to circumvent these drawbacks and also how to add our own optimizing analysis and transformation steps in order to generate a (correct and) better parallel code.

This paper is an extension of a previous work where two nondeterminism analyses were presented. One of them was ecient but not very powerful and the other one was more powerful but very expensive. Here, we develop an intermediate analysis in both aspects, eciency and power. The improvement in eciency is obtained by speeding up the xpoint calculation by means of a widening operator, and the representation of functions through easily comparable signatures. Also details about the implementation and its cost are given. 1