27 research outputs found
The Essence of Dependent Object Types
Focusing on path-dependent types, the paper develops foundations for Scala from first principles. Starting from a simple calculus D-<: of dependent functions, it adds records, intersections and recursion to arrive at DOT, a calculus for dependent object types. The paper shows an encoding of System F with subtyping in D-<: and demonstrates the expressiveness of DOT by modeling a range of Scala constructs in it
Mixin Composition Synthesis based on Intersection Types
We present a method for synthesizing compositions of mixins using type
inhabitation in intersection types. First, recursively defined classes and
mixins, which are functions over classes, are expressed as terms in a lambda
calculus with records. Intersection types with records and record-merge are
used to assign meaningful types to these terms without resorting to recursive
types. Second, typed terms are translated to a repository of typed combinators.
We show a relation between record types with record-merge and intersection
types with constructors. This relation is used to prove soundness and partial
completeness of the translation with respect to mixin composition synthesis.
Furthermore, we demonstrate how a translated repository and goal type can be
used as input to an existing framework for composition synthesis in bounded
combinatory logic via type inhabitation. The computed result is a class typed
by the goal type and generated by a mixin composition applied to an existing
class
Java and scala's type systems are unsound: the existential crisis of null pointers
We present short programs that demonstrate the unsoundness of Java and Scala's current type systems. In particular, these programs provide parametrically polymorphic functions that can turn any type into any type without (down) casting. Fortunately, parametric polymorphism was not integrated into the Java Virtual Machine (JVM), so these examples do not demonstrate any unsoundness of the JVM. Nonetheless, we discuss broader implications of these findings on the field of programming languages
Revisiting Decidable Bounded Quantification, via Dinaturality
We use a semantic interpretation to investigate the problem of defining an
expressive but decidable type system with bounded quantification. Typechecking
in the widely studied System Fsub is undecidable thanks to an undecidable
subtyping relation, for which the culprit is the rule for subtyping bounded
quantification. Weaker versions of this rule, allowing decidable subtyping,
have been proposed. One of the resulting type systems (Kernel Fsub) lacks
expressiveness, another (System Fsubtop) lacks the minimal typing property and
thus has no evident typechecking algorithm.
We consider these rules as defining distinct forms of bounded quantification,
one for interpreting type variable abstraction, and the other for type
instantiation. By giving a semantic interpretation for both in terms of
unbounded quantification, using the dinaturality of type instantiation with
respect to subsumption, we show that they can coexist within a single type
system. This does have the minimal typing property and thus a simple
typechecking procedure.
We consider the fragments of this unified type system over types which
contain only one form of bounded quantifier. One of these is equivalent to
Kernel Fsub, while the other can type strictly more terms than System Fsubtop
but the same set of beta-normal terms. We show decidability of typechecking for
this fragment, and thus for System Fsubtop typechecking of beta-normal terms.Comment: In Mathematical Semantics of Programming Languages (MFPS) '2
A generic algorithm for checking exhaustivity of pattern matching
Algebraic data types and pattern matching are key features of functional programming languages. Exhaustivity checking of pattern matching is a safety belt that defends against unmatched exceptions at runtime and boosts type safety. However, the presence of language features like inheritance, typecase, traits, GADTs, path-dependent types and union types makes the checking difficult and the algorithm complex. In this paper we propose a generic algorithm that decouples the checking algorithm from specific type theories. The decoupling makes the algorithm simple and enables easy customization for specific type systems