Abstract. We present the natural confluence of higher-order hereditary Harrop formulas (HH formulas) as developed concretely in λProlog, Constraint Logic Programming (CLP, [JL87]), and Concurrent Constraint Programming (CCP, [Sar93]) as a fragment of (intuitionistic, higher-order) logic. The combination is motivated by the need for a simple executable, logical presentation for static and dynamic semantics of modern programming languages. The power of HH formulas is needed for higher-order abstract syntax, and the power of constraints is needed to naturally abstract the underlying domain of computation. Underpinning this combination is a sound and complete operational interpretation of a two-sided sequent presentation of (a large fragment of) intuitionistic logic in terms of behavioral testing of concurrent systems. Formulas on the left hand side of a sequent style presentation are viewed as a system of concurrent agents, and formulas on the right hand side as tests against this evolving system. The language permits recursive definitions of agents and tests, allows tests to augment the system being tested and allows agents to be contingent on the success of a test. We present a condition on proofs, operational derivability (OD), and show that the operational semantics generates only operationally derivable proofs. We show that a sequent in this logic has a proof iff it has an operationally derivable proof. 1

Abstract. X10 is a modern object-oriented language designed for productivity and performance in concurrent and distributed systems. In this setting, dependent types offer significant opportunities for detecting design errors statically, documenting design decisions, eliminating costly runtime checks (e.g., for array bounds, null values), and improving the quality of generated code. We present the design and implementation of constrained types, a natural, simple, clean, and expressive extension to object-oriented programming: A type C(:c) names a class or interface C and a constraint c on the immutable state of C and in-scope final variables. Constraints may also be associated with class definitions (representing class invariants) and with method and constructor definitions (representing preconditions). Dynamic casting is permitted. The system is parametric on the underlying constraint system: the compiler supports a simple equalitybased constraint system but, in addition, supports extension with new constraint systems using compiler plugins. 1

We explore the design space for type systems with polymorphic records. We design record systems for extension, concatenation and removal of fields. Furthermore, we design a record system where field labels become first class values. That means, we can now quantify over field lables and pass them around as arguments. All designed record systems enjoy type inference with principal types. Especially, we can combine any features into a new record system retaining type inference with principal types. We also point out some problems which are present in previous record systems. Our designed record systems can be seen as the proper logical formulation of previous approaches with even more expressive power. We base our design on the HM(X) framework. HM(X) is a general framework for Hindley/Milner type systems that are parameterized in the constraint domain X. HM(X) enables us to design record systems in a systematic way retaining type inference with principal types. That means, designing recor...

Abstract. We have extended Wand’s algorithm to include polymorphic let by extending the constraint language and by using a multi-phase unification algorithm in the constraint solving phase. We show the correctness of our approach by extending the Wand’s soundness and completeness results. We have validated our approach against other popular type reconstruction algorithms by implementing OCaml prototypes and running them on non-trivial examples.

O'Haskell is a programming language derived from Haskell by the addition of concurrent reactive objects and subtyping. Because Haskell already encompasses an advanced type system with polymorphism and overloading, the type system of O'Haskell is much richer than what is the norm in almost any widespread object-oriented or functional language. Yet there is strong evidence that O'Haskell is not a complex language to use, and that both Java and Haskell programmers can easily find their way with its polymorphic subtyping system. This paper describes the type system of O'Haskell both formally and from a programmer's point of view; the latter task is accomplished with the aid of an illustrative, real world programming example: a strongly typed interface to the graphical toolkit Tk.

Abstract. This paper details an extension to Wand’s algorithm to handle the polymorphic let (a.k.a. ML-Let) construct. We have extended Wand’s algorithm by extending the constraint language and by using a multi-phase unification algorithm in the constraint solving phase. We show the correctness of our approach by extending the Wand’s soundness and completeness results. We have validated our approach against other popular type reconstruction algorithms by implementing OCaml prototypes and running them on non-trivial examples. 1

this technical report one can find full proofs of soundness and completeness of type inference for the HM(X) type system [SOW97]. In Section 2 we introduce the notion of constraint systems. The HM(X) framework is described in Section 3 where we also show that HM(X) type systems satisfy a type preservation property. Type inference is considered in Section 4. 2 Constraint systems

We propose a conservative extension of HM(X), a generic constraint-based type inference framework, with existential (a.k.a. abstract) and universal (a.k.a. polymorphic) datatypes. In the first part of the article, which remains abstract of the type and constraint language (i.e. the logic X), we introduce the type system, prove its safety and define a type inference algorithm which computes principal typing judgments. In the second part, we propose a realistic constraint solving algorithm for the case of structural subtyping, which handles the non-standard construct of the constraint language generated by type inference: a form of bounded universal quantification.

Most type reconstruction algorithms can be broadly classified into two distinct categories: unification and substitution based and constraint based. This report is a survey of some of the popular type reconstruction algorithms in the above two categories to promote better understanding of these algorithms. We have implemented the above algorithms for a language based on pure lambda calculus extended extended with poylorphic let construct on some non-trivial examples. 1

Constraint--based types provide a formal foundation for many varieties of architectural analysis. A software architecture, typically defined using an Architecture Definition Language (ADL), exposes the overall structure of a complex system in a way that allows validation and computation of overall system properties. We argue that the HM(X) type system can be used to implement many analyses in a simple and elegant way. HM(X) uses an extensible constraint subsystem: given a user-defined syntax and semantics (via a constraint solver) for an analysis domain, the HM(X) type system infers system-wide properties from the architectural definition. The core inference engine is thus extended to different forms of analysis by using different constraint solvers. We demonstrate our ideas by constructing three types of analysis built on top of HM(X): unit verification, security verification, and delay analysis. Finally, we demonstrate the use of HM(X) for analysis of dynamic architectures or higher...