. 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...

Creating GUI programs is hard even for prototyping purposes.

Abstract. It is important to be able to program GUI applications in a fast and easy manner. Current GUI tools for creating visually attractive applications offer limited functionality. In this paper we introduce a new, easy to use method to program GUI applications in a pure functional language such as Clean or Generic Haskell. The method we use is a refined version of the model-view paradigm. The basic component in our approach is the Graphical Editor Component (GECτ) that can contain any value of any flat data type τ and that can be freely used to display and edit its value. GECτ s can depend on others, but also on themselves. They can even be mutually dependent. With these components we can construct a flexible, reusable and customizable editor. For the realization of the components we had to invent a new generic implementation technique for interactive applications. 1

. The functional programming language Clean offers an extensive library, the object I/O library, to programmers to create interactive applications that use Graphical User Interfaces (GUI). Programs are constructed by composition of interactive objects. Interactive objects share state. To support modular programming it is also possible to provide objects with local state. Hierarchies of stateful objects are defined by means of algebraic specifications. Good use is made of the fact that Clean is a strongly typed language. In this paper we show how the evaluation of interactive objects is implemented in the object I/O library. The evaluation can be handled elegantly using lazy evaluation. 1 Introduction For many years the functional programming language Clean [7, 13, 14] enables programmers to create efficient, interactive applications that use Graphical User Interfaces (GUIs). This is done by means of an extensive library that has been developed in Clean. The first publicly av...

. In this paper we look at Concurrent Clean and concurrency and notice that the language has some shortcomings with respect to communication. It does not provide non-determinism, efficient multicasting and data-driven communication. A message passing extension for Concurrent Clean is proposed which provides efficient many-to-many communication. In contrast to other solutions, we chose to have an asynchronous system where sending and receiving do not have to occur simultaneously. We discuss design decisions with respect to concurrent evaluation and unique messages. Furthermore, we show some implementation aspects of this message passing system. 1 Introduction An important topic in computer science is concurrency. It is getting more attention nowadays with the introduction of shared memory machines, like multiPentium computers. For these systems, concurrency is often provided through a library which enables the programmer to create processes or threads and have communication between the...

Programming GUIs with conventional GUI APIs is notoriously tedious. In these notes we present the GEC toolkit in which the programmer can create user interfaces without any knowledge of lowlevel I/O handling. Instead, he works with Graphical Editor Components (GEC). A GEC is an interactive component that is automatically derived from an arbitrary monomorphic data type, including higher order types.

With generic functional programming techniques, we have eased GUI programming by constructing a programming toolkit with which one can create GUIs in an abstract and compositional way, using type-directed Graphical Editor Components (GECs). In this toolkit, the programmer specifies a GUI by means of a data model instead of lowlevel GUI programming. In earlier versions of this toolkit, the data model must have a first-order type. In this paper we show that the programming toolkit can be extended in two ways, such that the data model can contain higher-order types. We added support for dynamic polymorphic higher-order editors using the functional shell Esther. By combining the earlier developed techniques of generic GECs, abstract editors, we also added statically typed higher-order editors. In principle this solution extends our GUI programming toolkit with the full expressive power of functional programming languages.

In this paper we discuss the surprisingly elegant interaction between two lines of rather independent research, namely generic (or polytypic) programming and dynamic types. We show how the two disciplines meet and emphasize their characteristics in the area of interactive programming as implemented in the functional language Clean. In this language, an extensive library for creating Graphical User Interfaces is provided. We demonstrate how dynamic types can be used to store arbitrary GUI objects as resources and how generic functions can be used to manipulate these values. This results in a exible system of strongly typed and higher-order resources.

Abstract. Source-to-source transformations play crucial role in weaving multiple aspects of computation in aspect languages. Except that expressing imperative programs in the uniform form of expressions simplifies these transformations, this form is useful from the viewpoint of recognizing different aspects of computation at any level of program structure. In this paper we present the relation between imperative language and PFL – a process functional language, which manipulate environment variables in a side-effect manner, still preserving a purely functional principle based on evaluating expressions. Using an example of an imperative structured program, we will show the semantical equivalence of process functional and imperative programs. As a result, fine grained PFL form for picking out potential join points in imperative programs is obtained.

Abstract. This paper presents FunctionalForms, a combinator library for constructing fully functioning forms in a concise and flexible way. A form is a part of a graphical user interface (GUI) restricted to displaying a value and allowing the user to modify it. The library is built on top of the medium-level GUI library wxHaskell. To obtain complete separation between the structure of a form’s layout and that of the edited values, we introduce a novel use of compositional functional references. 1