Modules and linking are usually formalized by encodings which use the lambda calculus, records (possibly dependent), and possibly some construct for recursion. In contrast, we present the m-calculus, a calculus where the primitive constructs are modules, linking, and the selection and hiding of module components. In addition to supporting equational reasoning about modules and linking, the m-calculus allows smooth encodings of software structuring tools such as the lambda calculus, mutually recursive definitions, records (including operations like extension and concatenation), and objects. The m-calculus is extremely well behaved --- we show not only that the m-calculus is confluent but also that it satisfies the strong finite developments property.

Traditionally the integration of functional and logic languages is performed by attempting to integrate their semantic logics in some way. Many languages have been developed by taking this approach, but none manages to exploit fully the programming features of both functional and logic languages and provide a smooth integration of the two paradigms. We propose that improved integrated systems can be constructed by taking a broader view of the underlying semantics of logic programming. A novel integrated language paradigm, Definitional Constraint Programming (DCP), is proposed. DCP generalises constraint logic programming by admitting user-defined functions via a purely functional subsystem and enhances it with the power to solve constraints over functional programs. This constraint approach to integration results in a homogeneous unified system in which functional and logic programming features are combined naturally. 1 Introduction During the past ten years the integration of funct...

Abstract. The JMatch language extends Java with iterable abstract pattern matching, pattern matching that is compatible with the data abstraction features of Java and makes iteration abstractions convenient. JMatch has ML-style deep pattern matching, but patterns can be abstract; they are not tied to algebraic data constructors. A single JMatch method may be used in several modes; modes may share a single implementation as a boolean formula. Modal abstraction simplifies specification and implementation of abstract data types. This paper describes the JMatch language and its implementation. 1

We describe a metalanguage MMML, which makes explicit the order of evaluation (in the spirit of monadic metalanguages) and the staging of computations (as in languages for multi-level binding-time analysis). The main contribution of the paper is an operational semantics which is sufficiently detailed for analyzing subtle aspects of multi-stage programming, but also intuitive enough to serve as a reference semantics. For instance, the separation of computational types from code types, makes clear the distinction between a computation for generating code and the generated code, and provides a basis for multi-lingual extensions, where a variety of programming languages (aka monads) coexist. The operational semantics consists of two parts: local (semantics preserving) simplification rules, and computation steps executed in a deterministic order (because they may have side-effects). We focus on the computational aspects, thus we adopt a simple type system, that can detect usual type errors, but not the unresolved link errors. Because of its explicit annotations, MMML is suitable as an intermediate language.

Specification languages like PVS are designed to be expressive rather than executable. However, execution is useful for animating and validating specifications, and for automating certain kinds of proofs. A surprisingly large fragment of PVS turns out to be executable as a functional language with quite reasonable efficiency. Execution is achieved by generating Common Lisp code from PVS. The key step in generating efficient code is the use of static analysis to determine safe destructive array updates. Contents 1 Introduction 5 2 A Brief Summary of the PVS Specification Language 7 3 Executing PVS 13 3.1 Translating Primitive Operations . . . . . . . . . . . . . . . . 15 3.2 Translating Expressions . . . . . . . . . . . . . . . . . . . . . 16 3.3 Optimizing Unary to Multiary Function Application . . . . . . 19 3.3.1 Examples . . . . . . . . . . . . . . . . . . . . . . . . . 20 3.4 Translating Recursive Datatypes . . . . . . . . . . . . . . . . . 25 4 Optimizing Nondestructive to Destr...

Introduction Arithmetic coding is a method for data compression. Although the idea was developed in the 1970's, it wasn't until the publication of an "accessible implementation " [14] that it achieved the popularity it has today. Over the past ten years arithmetic coding has been refined and its advantages and disadvantages over rival compression schemes, particularly Hu#man [9] and Shannon-Fano [5] coding, have been elucidated. Arithmetic coding produces a theoretically optimal compression under much weaker assumptions than Hu#man and Shannon-Fano, and can compress within one bit of the limit imposed by Shannon's Noiseless Coding Theorem [13]. Additionally, arithmetic coding is well suited to adaptive coding schemes, both character and word based. For recent perspectives on the subject, see [10, 12]. The "accessible implementation" of [14] consisted of a 300 line C program, and much of the paper was a blow-by-blow description of the workings of the code. There was little in the way

This paper discusses a new method for typed functional languages to access libraries written in a lower-level language. More specifically, it introduces an interfacing tool that eases Haskell access to C libraries. The tool obtains information about the C data type denitions and function signatures by analysing the C header les of the library. It uses this information to compute the missing details in the template of a Haskell module that implements a Haskell binding to the C library. Hooks embedded in the binding le signal where, which, and how C objects are accessed from Haskell. The Haskell code in the binding le determines Haskell type signatures and marshaling details. The approach is lightweight and does not require an extra interface description language. 1 Introduction The complexity of modern software environments frequently requires interoperability between software components that are coded in dierent programming languages. Thus, the lack of access to librar...

A language with a programmable type system is vital for the construction of an embedded domain specific language (EDSL). Driven by the requirements posed by the implementation of an EDSL for server-side Web scripting, we examine two major of extensions to the type system of the host language, Haskell. We show that a component that ensures the generation of correct HTML documents can take good advantage of type-level functions, as implemented using functional logic overloading. We further show that a function that ensures the consistency of data submitted to a Web script with the data expected by the script is less awkward to use in the presence of lambda expressions in the type language. In both cases we assess the guarantees obtained by the use of the typing and explore alternative solutions.

In modern statically typed functional languages, type inference is used to determine the type of each function automatically. Whenever this fails, the compiler emits an error message that...

This paper argues that the core of modularity problems is an understanding of how individual components of a large system interact with each other, and that this interaction can be described by a layer structure. We propose a uniform treatment of layers based upon the concept of a monad. The combination of different systems can be described by the coproduct of monads.