Red-black trees with types

Kahrs, Stefan

doi:10.1017/s0956796801004026

Cited by 26 publications

(18 citation statements)

References 9 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For example, one can use features of the specific encoding used to further constrain operations [ 13]. One can also capture programming invariants associated with user-defined datatypes [7]. An interesting direction for future work is formalizing these additional applications of the phantom types technique.…”

Section: Resultsmentioning

confidence: 99%

Phantom Types and Subtyping

Fluet

Pucella

2002

Foundations of Information Technology in the Era of Network and Mobile Computing

View full text Add to dashboard Cite

We investigate a technique from the literature, called the phantom types technique, that uses parametric polymorphism, type constraints, and unification of polymorphic types to model a subtyping hierarchy. Hindley-Milner type systems, such as the one found in ML, can be used to enforce the subtyping relation. We show that this technique can be used to encode any finite subtyping hierarchy (including hierarchies arising from multiple interface inheritance). We then formally demonstrate the suitability of the phantom types technique for capturing subtyping by exhibiting a type-preserving translation from a simple calculus with bounded polymorphism to a calculus embodying the type system of ML. IntroductionIt is well known that traditional type systems, such as the one found in Standard ML [10], with parametric polymorphism and type constructors can be used to capture program properties beyond those naturally associated with a Hindley-Milner type system [9]. For concreteness, let us review a simple example, due to Leijen and Meijer [8]. Consider a type of atoms, either booleans or integers, that can be easily represented as an algebraic datatype: datatype atom = I of int I B of bool There are a number of operations that we may perform on such atoms (see Figure 1 (a)). When the domain of an operation is restricted to only one kind of atom, as with conj and double, a run-time check must be made and an error or exception reported if the check fails.One aim of static type checking is to reduce the number of run-time checks by catching type errors at compile time. Of course, in the example above, the ML type system does not consider conj (mki 3, mkB true) to be ill-typed; evaluating this expression will simply raise a run-time exception.If we were working in a language with subtyping, we would like to consider integer atoms and boolean atoms as distinct subtypes of the general type of atoms and use these subtypes to refine the types of the operations. Then the type system would report a type error in the expression double (mkB false) at compile time. Fortunately, we can write the operations in a way that utilizes the ML type system to do just this. We

show abstract

Section: Resultsmentioning

confidence: 99%

Phantom Types and Subtyping

Fluet

Pucella

2002

Foundations of Information Technology in the Era of Network and Mobile Computing

View full text Add to dashboard Cite

show abstract

“…Red-Black trees have several non-trivial invariants that are ideal for illustrating the effectiveness of refinement types, and contrasting with existing approaches based on GADTs [19]. The structure can be defined via the following Haskell type: However, a Tree is a valid Red-Black tree only if it satisfies three crucial invariants:…”

Section: Red-black Treesmentioning

confidence: 99%

LiquidHaskell

Vazou

Seidel

Jhala

2014

Proceedings of the 2014 ACM SIGPLAN Symposium on Haskell

View full text Add to dashboard Cite

Haskell has many delightful features. Perhaps the one most beloved by its users is its type system that allows developers to specify and verify a variety of program properties at compile time. However, many properties, typically those that depend on relationships between program values are impossible, or at the very least, cumbersome to encode within the existing type system. Many such properties can be verified using a combination of Refinement Types and external SMT solvers. We describe the refinement type checker LIQUIDHASKELL, which we have used to specify and verify a variety of properties of over 10,000 lines of Haskell code from various popular libraries, including containers, hscolour, bytestring, text, vector-algorithms and xmonad. First, we present a high-level overview of LIQUIDHASKELL, through a tour of its features. Second, we present a qualitative discussion of the kinds of properties that can be checked -ranging from generic application independent criteria like totality and termination, to application specific concerns like memory safety and data structure correctness invariants. Finally, we present a quantitative evaluation of the approach, with a view towards measuring the efficiency and programmer effort required for verification, and discuss the limitations of the approach.

show abstract

“…We may readily encode these 2-3 trees and give pattern synonyms for the three kinds of structure. This approach is much like that of red-black (effectively, 2-3-4) trees, for which typesafe balancing has a tradition going back to Hongwei Xi and Stefan Kahrs [9,19].…”

Section: Balanced 2-3 Treesmentioning

confidence: 99%

How to keep your neighbours in order

McBride

2014

SIGPLAN Not.

View full text Add to dashboard Cite

I present a datatype-generic treatment of recursive container types whose elements are guaranteed to be stored in increasing order, with the ordering invariant rolled out systematically. Intervals, lists and binary search trees are instances of the generic treatment. On the journey to this treatment, I report a variety of failed experiments and the transferable learning experiences they triggered. I demonstrate that a total element ordering is enough to deliver insertion and flattening algorithms, and show that (with care about the formulation of the types) the implementations remain as usual. Agda's instance arguments and pattern synonyms maximize the proof search done by the typechecker and minimize the appearance of proofs in program text, often eradicating them entirely. Generalizing to indexed recursive container types, invariants such as size and balance can be expressed in addition to ordering. By way of example, I implement insertion and deletion for 2-3 trees, ensuring both order and balance by the discipline of type checking.

show abstract

Red-black trees with types

Cited by 26 publications

References 9 publications

Phantom Types and Subtyping

Phantom Types and Subtyping

LiquidHaskell

How to keep your neighbours in order

Contact Info

Product

Resources

About