Qualified types provide a general framework for constrained type systems, with applications including type class overloading, subtyping and record calculi. This paper presents an extended version of the type inference algorithm used in previous work, that can take account of the satisfiability of constraints to obtain more accurate principal types. The new algorithm is obtained by adding two new rules, one for simplification and one for improvement of constraint sets. In particular, it permits a better treatment of the previously troublesome multiple parameter extensions of Haskell type classes, generalizing the system of parametric type classes proposed by Chen, Hudak and Odersky.

Operational semantics provide a simple, high-level and elegant means of specifying interpreters for programming languages. In natural semantics, a form of operational semantics, programs are traditionally represented as first-order tree structures and reasoned about using natural deduction-like methods. Hannan and Miller combined these methods with higher-order representations using Prolog. In this paper we go one step further and investigate the use of the logic programming language Elf to represent natural semantics. Because Elf is based on the LF Logical Framework with dependent types, it is possible to write programs that reason about their own partial correctness. We illustrate these techniques by giving type checking rules and operational semantics for Mini-ML, a small functional language based on a simply typed -calculus with polymorphism, constants, products, conditionals, and recursive function definitions. We also partially internalize proofs for some meta-theoretic properti...

We sketch a methodology for the verification of compiler correctness based on the LF Logical Framework as realized within the Elf programming language. We have applied this technique to specify, implement, and verify a compiler from a simple functional programming language to a variant of the Categorical Abstract Machine (CAM). 1 Introduction Compiler correctness is an essential aspect of program verification as almost all programs are compiled before being executed. Unfortunately, even for small languages and simple compilers, proving their correctness can be an enormous task, and verifying these proofs becomes an equally difficult task. Our goal is to develop techniques for mechanizing proofs of compiler correctness. To this end we employ 1. the LF Logical Framework [13] to specify relationships between source and target languages; 2. the Elf programming language [21] to provide an operational semantics for these relationships; and 3. a related meta-theory [22] to reason about the ...

We extend the ML language by allowing a sorted regular equational theory on types for which unification is decidable and unitary. We prove that the extension keeps principal typings and subject reduction. A new set of typing rules is proposed so that type generalization is simpler and more efficient. We consider typing problems as general unification problems, which we solve with a formalism of unificands. Unificands naturally deal with sharing between types and lead to a more efficient type inference algorithm. The use of unificands also simplifies the proof of correctness of the algorithm by splitting it into more elementary steps. Extension du syst`eme de type de ML par une th'eorie 'equationnelle avec sortes sur les types R'esum'e Le typage du langage ML est 'etendu en consid'erant les types modulo une th'eorie 'equationnelle r'eguli`ere avec sortes pour laquelle l'unification est d'ecidable. Cette extension conserve la propri'et'e d'avoir un type principal ainsi que la conservatio...

. We exhibit a methodology for formulating and verifying metatheorems about deductive systems in the Elf language, an implementation of the LF Logical Framework with an operational semantics in the spirit of logic programming. It is based on the mechanical verification of properties of transformations between deductions, which relies on type reconstruction and schema-checking. The latter is justified by induction principles for closed LF objects, which can be constructed over a given signature. We illustrate our technique through several examples, the most extensive of which is an interpretation of classical logic in minimal logic through a continuation-passing-style transformation on proofs. 1 Introduction Formal deductive systems have become an important tool in computer science. They are used to specify logics, type systems, operational semantics and other aspects of languages. The role of such specifications is three-fold. Firstly, inference rules serve as a high-level notation w...

We study the type inference problem for a system with type classes as in the functional programming language Haskell. Type classes are an extension of ML-style polymorphism with overloading. We generalize Milner's work on polymorphism by introducing a separate context constraining the type variables in a typing judgement. This leads to simple type inference systems and algorithms which closely resemble those for ML. In particular we present a new unification algorithm which is an extension of syntactic unification with constraint solving. The existence of principal types follows from an analysis of this unification algorithm.

Abstract not found

Despite their vast deployment, distributed memory multiprocessors (DMM) still remain dicult to program, this is why portable and ecient languages are denitely needed. For the time being, parallelization tools like PVM provides a widely portable solution for low-level (explicit communications) programming. But PVM programs (C or Fortran with send and receive for communications) are hard to write and debug because of their undeterministic behaviors and rudimentary communication support. We propose an intermediate-level functional language called Caml Flight, which integrate a programming technique used by PVM programmers and featured in MPI. Right now, Caml Flight allows to write deterministic SPMD programs more easily. A long term goal is to be act as a target language for compilers of high-level languages. 1

Safely adding computational eects to a multi-stage language has been an open problem. In previous work, a closed type constructor was used to provide a safe mechanism for executing dynamically generated code. This paper proposes a general notion of closed type as a simple approach to safely introducing computational eects into multistage languages. We demonstrate this approach formally in a core language called Mini-ML BN ref . This core language combines safely multi-stage constructs and ML-style references. In addition to incorporating state, Mini-ML BN ref also embodies a number of technical improvements over previously proposed core languages for multi-stage programming.

We demonstrate an equivalence between the rank 2 fragments of the polymorphic lambda calculus (System F) and the intersection type discipline: exactly the same terms are typable in each system. An immediate consequence is that typability in the rank 2 intersection system is DEXPTIME-complete. We introduce a rank 2 system combining intersections and polymorphism, and prove that it types exactly the same terms as the other rank 2 systems. The combined system suggests a new rule for typing recursive definitions. The result is a rank 2 type system with decidable type inference that can type some interesting examples of polymorphic recursion. Finally,we discuss some applications of the type system in data representation optimizations such as unboxing and overloading.