A type system withlin earity is useful for checking software protocols and resource man agemen t at compile time. Lin#"$"M y provides powerfulreason#)M about state chan ges, but at the price of restriction son aliasin g. The hard division between lin ear an dn on lin ear types forces the programmer to make a trade-off between checkin g a protocol on an object an# aliasin# the object. ost on erous is the restriction that an y type with alin ear component must itself be linear. Because of this, checking a protocolon an object imposes aliasin g restriction s on an y data structure that directly orin directly points to the object. We propose an#$ type system that reduces these restrictions with the adoption and focus constructs. Adoption safely allows a programmer to alias objects on which she is checkin g protocols, and focus allows the reverse. A programmer can alias data structures that point to linear objects and use focus for safe access to those objects. We discuss how we implemented these ideas in the Vault programming language.

. The functional programming language Clean has a high level I/O system (version 0.8) in which complex yet efficient interactive programs can be created. In this paper we present its successor (version 1.0), the object I/O system. We consider some of the design considerations that have influenced the design of the new I/O system greatly. Key issues are compositionality, orthogonality, and extensibility. Apart from design, the object I/O system improves on its predecessor by two major contributions: programmers can introduce polymorphic local state at every (collection of) user interface component(s) and programmers can create interactive processes in a flexible way. All interface components can communicate with each other by sharing state but also using powerful message passing primitives in both synchronous, asynchronous, and uni- or bi-directional way. Using the message passing mechanism remote procedure calling can be added easily. The result is an object oriented I/O...

. Pure, functional programming languages oer several solutions to construct Graphical User Interfaces (GUIs). In this paper we report on a project in which we port the Clean Object I/O library to Haskell. The Clean Object I/O library uses an explicit environment passing scheme, based on the uniqueness type system of Clean. It supports many standard GUI features such as windows, dialogues, controls, and menus. Applications can have timing behaviour. In addition, there is support for interactive processes and message passing. The standard functional programming language Haskell uses a monadic framework for I/O. We discuss how the Object I/O library can be put in a monadic framework without loosing its essential features. We give an implementation of an essential fragment of the Object I/O library to demonstrate the feasibility. We take especial consideration for the relevant design choices. One particular design choice, how to handle state, results in two versions. 1 Intro...

This paper proposes a new functional programming language called Sac (Single Assignment C) which tries to combine the best of two worlds: the efficiency and portability of C (or Fortran) and the concurrency deducable from the functional paradigm. The major objectives in the design of Sac comprise support for high performance concurrent scientific applications (number crunching), a module concept which allows for the integration of non-funtional components, and a syntax as close as possible to C. 1 Introduction Functional programming languages did not yet find a broad acceptance by application programmers outside the functional community. The reasons for this situation are manifold and differ depending on the field of application. Of primary interest in this paper are scientific applications involving complex manipulations of arrays. For this class of applications the following criteria are the most important ones for the choice of a suitable language: ffl availability of primitive a...

Abstract. This paper introduces a new compiler optimization called with-loop-folding. It is based on a special loop construct, the withloop, which in the functional language Sac (for Single Assignment C) serves as a versatile vehicle to describe array operations on an elementwise basis. A general mechanism for combining two of these with-loops into a single loop construct is presented. This mechanism constitutes a powerful tool when it comes to generate efficiently executable code from high-level array specifications. By means of a few examples it is shown that even complex nestings of array operations similar to those available in Apl can be transformed into single loop operations which are similar to hand-optimized with-loop specifications. As a consequence, the way a complex array operation is combined from primitive array operations does not affect the runtime performance of the compiled code, i.e., the programmer is liberated from the burden to take performance considerations into account when specifying complex array operations. 1

The concept of a “unique ” object arises in many emerging programming languages such as Clean, CQual, Cyclone, TAL, and Vault. In each of these systems, unique objects make it possible to perform operations that would otherwise be prohibited (e.g., deallocating an object) or to ensure that some obligation will be met (e.g., an opened file will be closed). However, different languages provide different interpretations of “uniqueness ” and have different rules regarding how unique objects interact with the rest of the language. Our goal is to establish a common model that supports each of these languages, by allowing us to encode and study the interactions of the different forms of uniqueness. The model we provide is based on a substructural variant of the polymorphic λ-calculus, augmented with four kinds of mutable references: unrestricted, relevant, affine, and linear. The language has a natural operational semantics that supports deallocation of references, strong (typevarying) updates, and storage of unique objects in shared references. We establish the strong soundness of the type system by constructing a novel, semantic interpretation of the types.

Abstract not found

It has been claimed that recent developments in the research on the efficiency of code generation and on graphical input/output interfacing have made it possible to use a functional language to write efficient programs that can compete with industrial applications written in a traditional imperative language. As one of the early steps in verifying this claim, this paper describes a first attempt to implement a spreadsheet in a lazy, purely functional language. An interesting aspect of the design is that the language with which the user specifies the relations between the cells of the spreadsheet is itself a lazy, purely functional and higher order language as well, and not some special dedicated spreadsheet language. Another interesting aspect of the design is that the spreadsheet incorporates symbolic reduction and normalisation of symbolic expressions (including equations). This introduces the possibility of asking the system to prove equality of symbolic cell expressions: a property...

Skeletons are well-suited to structure parallel programming. They allow the easy use of some well-known parallel programming paradigms to construct portable, efficient programs. Much research has been focused on the use of skeletons in functional programming languages, because they can be expressed elegantly as higher order functions. On the other hand, little attention has been paid to an elementary weakness of skeletons: how to implement them. In this paper we will show that functional languages with some low level constructs for parallelism can be used to efficiently implement a range of high level skeletons. We will construct skeletons for data parallelism, for parallel I/O, and for stream processing. Our experiments demonstrate that no performance penalty needs to be paid, compared to more restrictive solutions. 1. Introduction The development of efficient parallel programs is an important non-trivial problem that programmers and compiler writers have to deal with. The use of fun...

The design and implementation of large distributed fault-tolerant systems in the telecommunications industry is becoming increasingly complex. Traditionally, telecommunications systems have been equipped with fault-tolerant hardware. Recent advances with cheap high speed o-the-shelf CPUs make an approach with fault-tolerance implemented in software moreattractive. This typically involves di erent techniques to replicate data over several computers. The actual implementation of such systems has however turned out to be acostly business. Our experiences indicate that traditional software engineering techniques for distributed systems where typically various interface description languages are used, lead to overly complex systems. The functional programming language Erlang has been designed toease the design of distributed fault-tolerant applications with massive concurrency. Erlang is currently being employed in a number of applications within the Swedish telecommunications company Ericsson, and the experiences so far are very promising. In this overview paper we will describe the ideas behind the support for distributed fault-tolerant programming in the language together with some implementation aspects. The main topic of the paper is the idea of dynamic interfaces. Symbolic programming languages often have the ability to dynamically identify the type of a data object at runtime. Using this capability it is possible to implement a general purpose encoder/decoder which maps data objects from the language to and from a stream of bytes which can be sent onto a network. We will show what implications this has on distributed programming techniques. 1