A simple implementation of an SML-like module system is presented as a module parameterized by a base language and its type-checker. This implementation is useful both as a detailed tutorial on the Harper-Lillibridge-Leroy module system and its implementation, and as a constructive demonstration of the applicability of that module system to a wide range of programming languages.

The programming language Standard ML is an amalgam of two, largely orthogonal, languages. The Core language expresses details of algorithms and data structures. The Modules language expresses the modular architecture of a software system. Both languages are statically typed, with their static and dynamic semantics specified by a formal definition.

Introduction We present our implementation AGDA of type theory. We limit ourselves in this presentation to a rather primitive form of type theory (dependent product with a simple notion of sorts) that we extend to structure facility we find in most programming language: let expressions (local definition) and a package mechanism. We call this language Structured Type Theory. The first part describes the syntax of the language and an informal description of the type-checking. The second part contains a detailed description of a core language, which is used to implement Strutured Type Theory. We give a realisability semantics, and type-checking rules are proved correct with respect to this semantics. The notion of meta-variables is explained at this level. The third part explains how to interpret Structured Type Theory in this core language. The main contributions are: ffl use of explicit substitution to simplify and make

Abstract. In a previous work, we proved that an important part of the Calculus of Inductive Constructions (CIC), the basis of the Coq proof assistant, can be seen as a Calculus of Algebraic Constructions (CAC), an extension of the Calculus of Constructions with functions and predicates defined by higher-order rewrite rules. In this paper, we prove that almost all CIC can be seen as a CAC, and that it can be further extended with non-strictly positive types and inductive-recursive types together with non-free constructors and pattern-matching on defined symbols. 1.

Abstract not found

. The SML-like module systems are small typed languages of their own. As is, one would expect a proof of their soundness following from a proof of subject reduction. Unfortunately, the subject-reduction property and the preservation of type abstraction seem to be incompatible. As a consequence, in relevant module systems, the theoretical study of reductions is meaningless, and for instance, the question of normalization of module expressions can not even be considered. In this paper, we analyze this problem as a misunderstanding of the notion of module definition. We build a variant of the SML module system --- inspired from recent works by Leroy, Harper, and Lillibridge --- which enjoys the subject reduction property. Type abstraction --- achieved through an explicit declaration of the signature of a module at its definition --- is preserved. This was the initial motivation. Besides our system enjoys other type-theoretic properties: the calculus is strongly normalizing, there are no syntactic restrictions on module paths, it enjoys a purely applicative semantics and type inference is decidable. Neither Leroy's system nor Harper and Lillibridge's system has all of them.

this paper appears in Theorem Proving in Higher Order Logics, TPHOLs 2000, c

This paper presents the formal verication with the Coq proof assistant of several applicative data structures implementing nite sets. These implementations are parameterized by an ordered type for the elements, using functors from the ML module system. The verication follows closely this scheme, using the newly Coq module system.

We reconsider the well-known concept of Haskell-style type classes within the logical framework of Isabelle. So far, axiomatic type classes in Isabelle merely account for the logical aspect as predicates over types, while the operational part is only a convention based on raw overloading. Our more elaborate approach to constructive type classes provides a seamless integration with Isabelle locales, which are able to manage both operations and logical properties uniformly. Thus we combine the convenience of type classes and the flexibility of locales. Furthermore, we construct dictionary terms derived from notions of the type system. This additional internal structure provides satisfactory foundations of type classes, and supports further applications, such as code generation and export of theories and theorems to environments without type classes.

The implicit universe hierarchy implemented in proof assistants such as Coq and Lego, although really needed, is painful, both for the implementer and the user: it interacts badly with modularity features, errors are difficult to report and to understand. Moreover, typechecking is quite complex.