the expression problem with true separate compilation

Type classes are perhaps the most exciting feature of Haskell’s type system. Although type classes were only proposed as a solution for overloading identifiers, they have become an active research topic where experimental type class extensions are still being proposed. On top of that, the underlying principles are also used to encode various other extensions, such as extensible records, implicit parameters, and subtyping. However, implementing type classes and type class extensions is not a trivial task. It is not only a matter of type checking to resolve overloading, but also evidence for overloaded identifiers has to be inserted. A uniform approach to easily formulate type class extensions side by side is missing. In addition, error messages concerning type classes are difficult to understand or sometimes not present at all. We propose a constraint-based framework for the resolution of overloading. Assumptions and proof obligations are explicitly encoded into the constraint language of this framework. Furthermore, type class extensions can be easily formulated using Constraint Handling Rules (CHRs). The confluence requirement is circumvented by using only propagation CHRs, and by specifying design decisions in the form of heuristics. Using the resulting framework, we show how various context reduction strategies can be specified side by side. Furthermore, we explain how scoped instances and overlapping instances are naturally supported. We also show how functional dependencies can be supported using the existing translation into CHRs.

We describe universal types, existential types, and type constructors in Cyclone, a strongly-typed C-like language. We show how the language naturally supports first-class polymorphism and polymorphic recursion while requiring an acceptable amount of explicit type information. More importantly, we consider the soundness of type variables in the presence of C-style mutation and the address-of operator. For polymorphic references, we describe a solution more natural for the C level than the ML-style “value restriction.” For existential types, we discover and subsequently avoid a subtle unsoundness issue resulting from the address-of operator. We develop a formal abstract machine and type-safety proof that captures the essence of type variables at the C level.

The development of complex, multi-user, interactive systems is a difficult process that requires both a rapid iterative approach, and the ability to reason carefully about system designs. This thesis argues that a combination of declarative prototyping and formal specification provides a suitable way of satisfying these requirements. The focus of this thesis is on the development of software tools for prototyping interactive systems. In particular, it uses a declarative approach, based on the functional programming paradigm. This thesis makes two contributions. The most significant contribution is the presentation of FranTk, a new Graphical User Interface language, embedded in the functional language Haskell. It is suitable for prototyping complex, concurrent, multi-user systems. It allows systems to be built in a high level, structured manner. In particular, it provides good support for specifying real-time properties of such systems. The second contribution is a mechanism that allows a formal specification to be derived from a high level FranTk prototype. The approach allows this to be done automatically. This specification can then be checked, with tool support, to verify some safety properties about a system. To avoid the state space explosion problem that would be faced when verifying an entire system, we focus on partial verification. This concentrates on key areas of a design: in particular this means that we only derive a specification from parts of a prototype. To demonstrate the scalability of both the prototyping and verification approaches, this thesis uses a series of case studies including a multi-user design rationale editor and a prototype data-link