Refinement kinds: type-safe programming with practical type-level computation

Abstract

This work introduces the novel concept of kind refinement, which we develop in the context of an explicitly polymorphic ML-like language with type-level computation. Just as type refinements embed rich specifications by means of comprehension principles expressed by predicates over values in the type domain, kind refinements provide rich kind specifications by means of predicates over types in the kind domain. By leveraging our powerful refinement kind discipline, types in our language are not just used to statically classify program expressions and values, but also conveniently manipulated as tree-like data structures, with their kinds refined by logical constraints on such structures. Remarkably, the resulting typing and kinding disciplines allow for powerful forms of type reflection, ad-hoc polymorphism and type meta-programming, which are often found in modern software development, but not typically expressible in a type-safe manner in general purpose languages. We validate our approach both formally and pragmatically by establishing the standard meta-theoretical results of type safety and via a prototype implementation of a kind checker, type checker and interpreter for our language. = x @ The addField function takes a label l, a type t, a record type r that does not contain label l, and values of types t and r , respectively, returning a record of type addFieldType l t r .The type-level and term-level functions addFieldType and addField respectively illustrate some of the key insights of our type theory, namely the use of types and their refined kinds as specifications that can be manipulated as tree-like structures by programs in a fully type-safe way. For instance, the following judgment, expressing the correspondence between the term-level computation addField l t r x and the type-level computation addFieldType l t r , is derivable: l:Nm, t:Type, r :{s::Rec | l lab(s)}, x:t, :r ⊢ addField l t r x : addFieldType l t r An instance of this judgement yields:⊢ addField name String a e : Int "jack" a e = 20 : addFieldType name String a e : Int Noting that age : Int :: {s::Rec | name lab(s)} is derivable since name lab( age : Int ) is provable in the refinement logic, we have the following term and type-level evaluations:(addField name String a e : Int "jack" a e = 20 ) → * name = "jack"; age = 20 (addFieldType name String a e : Int ) ≡ name : String; age : Int

Going beyond templates: composition and evolution in nested OSTRICH

“…To support the algorithmic construction of programs at compile time, multistage programming has been for several mainstream functional programming languages, notably MetaML [39], MetaOCaml [21], and Template Haskell [36]. Our approach is inspired by richer type-level computations that reason about the structure of types and produce custom code constructions [3,7]. The innovation of our work is the integration of multistage programming with MetaDepth [11] is related to our approach to defining a DSL with a "generic" layer supporting nested templates.…”

“…Abstraction and parametrization are among the most significant mechanisms in programming languages to promote modularisation and code reuse [22]. They are present in programming languages from basic function definitions to sophisticated type systems [2] or type-level computations in metaprogramming mechanisms [3,7].…”