The wide practice of objected oriented programming (OOP) in current software practice is evident. Despite extensive studies on typing programming objects, it is still undeniably a challenging research task to design a type system that can satisfactorily account for a variety of features (e.g., binary methods and multiple inheritance) in OOP. In this paper, we present a typeful approach to implementing objects that makes use of a recently introduced notion of guarded datatypes. In particular, we demonstrate how the feature of multiple inheritance can be supported with this approach, presenting a simple and general account for multiple inheritance in a typeful manner.

Abstract. An approach to software composition from heterogeneous components is presented. The focus is on heterogeneity of interaction styles. The interface of a component is described in an abstract manner, hiding the component’s actual interaction style. This allows for automatic generation of code that mediates between incompatible styles, thus obviating the need for manual construction of wrappers. 1

When constructing programs to process XML documents, we immediately face the question as to how XML documents should be represented internally in the programming language we use. Currently, most representations for XML documents are typeless in the sense that the type information of an XML document cannot be reflected in the type of the representation of the document (if the representation is assumed to be typed). Though convenient to construct, a typeless representation for XML documents often makes use of a large number of representation tags, which not only require some significant amount of space to store but may also incur numerous run-time tag checks when the represented documents are processed. Moreover, with a typeless representation for XML documents, it becomes di#cult or even impossible to statically capture program invariants that are related to the type information of XML documents. Building upon our recent work on guarded recursive datatypes, we present an approach to representing XML documents in this paper that not only allows the type information of an XML document to be reflected in the type of the representation of the document but also significantly reduces the need for representation tags that are required in typeless representations. With this approach, we become able to process XML documents in a typeful manner, thus reaping various well-known software engineering benefits from the presence of types.

We consider the model checking problem for FLC, a modal fixpoint logic capable of defining non-regular properties. This paper presents a refinement of a symbolic model checker and discusses how to parallelise this algorithm. It reports on a prototype implementation of the algorithm in Glasgow Parallel Haskell (GpH) and its performance on a cluster of workstations. Key words: Symbolic Model Checking, Functional Programming.

. Xml, the Extensible Markup Language, is a standard for storing and exchanging hierarchically structured text. Due to Xml's tree-like view of documents, modern functional programming languages such as Sml, with trees as the basic data types, are well-suited for implementing Xml processing software. The basis of all such applications is an Xml parser, serving as a front-end to the Xml syntax. This paper presents fxp, an Xml parser written entirely in Sml. It reads and validates Xml documents and provides a programming interface for document processing applications. 1 Introduction Documents usually have a hierarchical logical structure: a book, e.g., is divided into chapters which are themselves made up of sections that consist of subsections, and so on. Modern document processing systems therefore have a tree-like view of documents; document processing basically comes down to tree manipulation. The implementation language of a document processing application should therefore ...

as counted by wc-w applied to the detexed output

An XPath data binding for a given host language provides a translation of XPath expressions to expressions in the host language. This paper discusses an XPathHaskell data binding. XPath validation ensures that a path addresses a possibly nonempty set of nodes in XML documents described by an XML Schema. We present a generic function (defined by induction on the type structure) that validates XPath expressions with respect to an XML Schema. We use Generic Haskell, an extension of Haskell that supports the construction of generic programs. Furthermore we present generic programs that use a valid XPath expression to query and update documents in a typed way.

Incompatibility of component interaction styles is identified as a major obstacle to interoperability when using off-the-shelf components or dealing with legacy software in compositional development. It is argued that a language for defining abstract interfaces -- AID -- can serve as a basis for accommodating heterogeneous interaction styles. AID is independent of any concrete style, such as invocation, pipe-and-filter, event-based or others. An AID text just specifies elementary input and output events which happen at the boundary of a component.