Embedded systems present a wide variety of challenges for developers of language tools. Verification of correctness, flexibility for adding new language features, and retargeting new architectures all present significant problems when developing a compiler for embedded systems. In this paper we present a domain-specific language based on modular monadic semantics which addresses many of these challenges. 1

The problem of writing modular interpreters for functional languages has largely been studied from the perspective of statically typed languages. This paper explores the use of an object-oriented extension of Scheme for this purpose, and nds it to be largely successful. Use of a dynamically typed language has the advantages of greater uniformity and exibility. 1 The Problem of Extensibility, the Test Case of Modular Interpreters and the Search for a Solution in Object-Oriented Programming Extensibility is the ability of a program to be adapted to new tasks without accessing its source code [7]. Interpreters make an interesting extensibility problem, because in the terminology of Duponcheel [4], there are both syntactic and semantic aspects. By syntax, here, he means abstract syntax, i.e., the logical structure of expressions. By semantics, he means the computations and values engendered by those expressions. This extensibility problem should be contrasted with another that has also...

A framework for speci cation of programming language semantics, abstract and concrete syntax, and lexical structure is proposed. The framework is based on Modular Monadic Semantics and allows independent specification of various language features. Features such as arithmetics, conditionals, exceptions, state and nondeterminism can be freely combined into working interpreters, facilitating experiments in language design. A prototype implementation of this system in Haskell is described and possibilities for more sophisticated interpreter generator are outlined.

The objective of this thesis is to demonstrate the feasibility of performing static analysis, specifically type checking, in a particularly modular way. We use a term space of fixpoints of sums of functors so that, by writing individual type checkers for each portion of the entire language, we can then combine those algebras into an algebra that functions over the entire target language. The overall computational style employed uses a sequenced paramorphism to reduce the terms to the value space of types. As a proof of concept, this thesis presents a nominal typechecker in Haskell for the language Rosetta. It relies heavily on InterpreterLib, a Haskell library for designing interpreters in exactly the style described.

Methods for reusing code are widespread and well researched, but methods for reusing proofs are still emerging. We consider the use of dependent types for this purpose, introducing a modular approach for composing mechanized proofs. We show that common techniques for abstracting algorithms over data structures naturally translate to abstractions over proofs. We introduce a language composed of a series of smaller language components, each defined as functors, and tie them together by taking the fixed point of their sum [Malcom, 1990]. We then give proofs of type preservation for each language component and show how to compose these proofs into a proof for the entire language, again by taking the fixed point of a sum of functors.