Denotational semantics [Sch86] is a powerful framework for describing programming languages; however, its descriptions lack modularity: conceptually independent language features influence each others' semantics. We address this problem by presenting a theory of modular denotational semantics. Following Mosses [Mos92], we divide a semantics into two parts, a computation ADT and a language ADT (abstract data type). The computation ADT represents the basic semantic structure of the language. The language ADT represents the actual language constructs, as described by a grammar. We define the language ADT using the computation ADT; in fact, language constructs are polymorphic over many different computation ADTs. Following Moggi [Mog89a], we build the computation ADT from composable parts, using monads and monad transformers. These techniques allow us to build many different computation ADTs, and, since our language constructs are polymorphic, many different language semantics. We autom...

This paper proposes a syntactic reformulation of the modular approach to Denotational Semantics in [Mog89a, Mog91a]. This reformulation is based on a duality between model constructions and translations of theories (often called relative interpretations), analogous to Gabriel-Ulmer duality. To demonstrate the simplicity and usability of the syntactic reformulation, we give a sample of theories and translations, which can be used to give semantics to concurrent languages (via translation into suitable metalanguages).

A programming metalogic is a formal system into which programming languages can be translated and given meaning. The translation should both reflect the structure of the language and make it easy to prove properties of programs. This thesis develops certain metalogics using techniques of category theory and treats recursion in a new way. The notion of a category with fixpoint object is defined. Corresponding to this categorical structure there are type theoretic equational rules which will be present in all of the metalogics considered. These rules define the fixpoint type which will allow the interpretation of recursive declarations. With these core notions FIX categories are defined. These are the categorical equivalent of an equational logic which can be viewed as a very basic programming metalogic. Recursion is treated both syntactically and categorically. The expressive power of the equational logic is increased by embedding it in an intuitionistic predicate calculus, giving rise to the FIX logic. This contains propositions about the evaluation of computations to values and an induction principle which is derived from the definition of a fixpoint object as an initial algebra. The categorical structure which accompanies the FIX logic is defined, called a FIX hyperdoctrine, and certain existence and disjunction properties of FIX are stated. A particular FIX hyperdoctrine is constructed and used in the proof of the same properties. PCF-style languages are translated into the FIX logic and computational adequacy reaulta are proved. Two languages are studied: Both are similar to PCF except one has call by value recursive function declararations and the other higher order conditionals. ...

The influential pure embedding methodology of embedding domainspecific languages (DSLs) as libraries into a general-purpose host language forces the DSL designer to commit to a single semantics. This precludes the subsequent addition of compilation, optimization or domain-specific analyses. We propose polymorphic embedding of DSLs, where many different interpretations of a DSL can be provided as reusable components, and show how polymorphic embedding can be realized in the programming language Scala. With polymorphic embedding, the static type-safety, modularity, composability and rapid prototyping of pure embedding are reconciled with the flexibility attainable by external toolchains. Categories and Subject Descriptors D.3.2 [Programming Languages]: Language Classifications—Extensible languages, Specialized

Abstract not found

Following the program of Moggi, the semantics of a simple non-deterministic functional language with recursion and failure is described by a monad. We show that this monad cannot be any of the known power domain constructions, because they do not handle non-termination properly. Instead, a novel construction is proposed and investigated. It embodies both nondeterminism (choice and failure) and possible non-termination caused by recursion. 1 Introduction Following the proposals of Moggi [Mog89, Mog91b], functional languages with various notions of computations can be denotationally described by means of monads. Monads are constructions mapping domains of values into domains of computations for these values. Computations involving destructive assignments, for instance, are handled by the state transformer monad [Wad90], whereas computations by non-deterministic choice are handled by power domain constructions [Plo76, Smy78, Gun90]. All known power domain constructions and many others ar...