amelia
/
blag


								---

								title: Dependent types in Haskell - Sort of

								date: August 23, 2016

								synopsys: 2

								---


								**Warning**: An intermediate level of type-fu is necessary for understanding

								*this post.


								The glorious Glasgow Haskell Compilation system, since around version 6.10 has

								had support for indexed type familes, which let us represent functional

								relationships between types. Since around version 7, it has also supported

								datatype-kind promotion, which lifts arbitrary data declarations to types. Since

								version 8, it has supported an extension called `TypeInType`, which unifies the

								kind and type level.


								With this in mind, we can implement the classical dependently-typed example:

								Length-indexed lists, also called `Vectors`{.haskell}.


								----


								> {-# LANGUAGE TypeInType #-}


								`TypeInType` also implies `DataKinds`, which enables datatype promotion, and

								`PolyKinds`, which enables kind polymorphism.


								`TypeOperators` is needed for expressing type-level relationships infixly, and

								`TypeFamilies` actually lets us define these type-level functions.


								> {-# LANGUAGE TypeOperators #-}

								> {-# LANGUAGE TypeFamilies #-}


								Since these are not simple-kinded types, we'll need a way to set their kind

								signatures[^kind] explicitly. We'll also need Generalized Algebraic Data Types

								(or GADTs, for short) for defining these types.


								> {-# LANGUAGE KindSignatures #-}

								> {-# LANGUAGE GADTs #-}


								Since GADTs which couldn't normally be defined with regular ADT syntax can't

								have deriving clauses, we also need `StandaloneDeriving`.


								> {-# LANGUAGE StandaloneDeriving #-}


								> module Vector where

								> import Data.Kind


								----


								Natural numbers

								===============


								We could use the natural numbers (and singletons) implemented in `GHC.TypeLits`,

								but since those are not defined inductively, they're painful to use for our

								purposes.


								Recall the definition of natural numbers proposed by Giuseppe Peano in his

								axioms: **Z**ero is a natural number, and the **s**uccessor of a natural number

								is also a natural number.


								If you noticed the bold characters at the start of the words _zero_ and

								_successor_, you might have already assumed the definition of naturals to be

								given by the following GADT:


								< data Nat where

								<   Z :: Nat

								<   S :: Nat -> Nat


								This is fine if all you need are natural numbers at the _value_ level, but since

								we'll be parametrising the Vector type with these, they have to exist at the

								type level. The beauty of datatype promotion is that any promoted type will

								exist at both levels: A kind with constructors as its inhabitant types, and a

								type with constructors as its... constructors.


								Since we have TypeInType, this declaration was automatically lifted, but we'll

								use explicit kind signatures for clarity.


								> data Nat :: Type where

								>   Z :: Nat

								>   S :: Nat -> Nat


								The `Type` kind, imported from `Data.Kind`, is a synonym for the `*` (which will

								eventually replace the latter).


								Vectors

								=======


								Vectors, in dependently-typed languages, are lists that apart from their content

								encode their size along with their type.


								If we assume that lists can not have negative length, and an empty vector has

								length 0, this gives us a nice inductive definition using the natural number

								~~type~~ kind[^kinds]


								 > 1. An empty vector of `a` has size `Z`{.haskell}.

								 > 2. Adding an element to the front of a vector of `a` and length `n` makes it

								 > have length `S n`{.haskell}.


								We'll represent this in Haskell as a datatype with a kind signature of `Nat ->

								Type -> Type` - That is, it takes a natural number (remember, these were

								automatically lifted to kinds), a regular type, and produces a regular type.

								Note that, `->` still means a function at the kind level.


								> data Vector :: Nat -> Type -> Type where


								Or, without use of `Type`,


								< data Vector :: Nat -> * -> * where


								We'll call the empty vector `Nil`{.haskell}. Remember, it has size

								`Z`{.haskell}.


								>  Nil :: Vector Z a


								Also note that type variables are implicit in the presence of kind signatures:

								They are assigned names in order of appearance.


								Consing onto a vector, represented by the infix constructor `:|`, sets its

								length to the successor of the existing length, and keeps the type of elements

								intact.


								>  (:|) :: a -> Vector x a -> Vector (S x) a


								Since this constructor is infix, we also need a fixidity declaration. For

								consistency with `(:)`, cons for regular lists, we'll make it right-associative

								with a precedence of `5`.


								> infixr 5 :|


								We'll use derived `Show`{.haskell} and `Eq`{.haskell} instances for

								`Vector`{.haskell}, for clarity reasons. While the derived `Eq`{.haskell} is

								fine, one would prefer a nicer `Show`{.haskell} instance for a

								production-quality library.


								> deriving instance Show a => Show (Vector n a)

								> deriving instance   Eq a =>   Eq (Vector n a)


								Slicing up Vectors {#slicing}

								==================


								Now that we have a vector type, we'll start out by implementing the 4 basic

								operations for slicing up lists: `head`, `tail`, `init` and `last`.


								Since we're working with complicated types here, it's best to always use type

								signatures.


								Head and Tail {#head-and-tail}

								-------------


								Head is easy - It takes a vector with length `>1`, and returns its first

								element. This could be represented in two ways.


								< head :: (S Z >= x) ~ True => Vector x a -> a


								This type signature means that, if the type-expression `S Z >= x`{.haskell}

								unifies with the type `True` (remember - datakind promotion at work), then head

								takes a `Vector x a` and returns an `a`.


								There is, however, a much simpler way of doing the above.


								> head :: Vector (S x) a -> a


								That is, head takes a vector whose length is the successor of a natural number

								`x` and returns its first element.


								The implementation is just as concise as the one for lists:


								> head (x :| _) = x


								That's it. That'll type-check and compile.


								Trying, however, to use that function on an empty vector will result in a big

								scary type error:


								```plain

								Vector> Vector.head Nil


								<interactive>:1:13: error:

								    • Couldn't match type ‘'Z’ with ‘'S x0’

								      Expected type: Vector ('S x0) a

								        Actual type: Vector 'Z a

								    • In the first argument of ‘Vector.head’, namely ‘Nil’

								      In the expression: Vector.head Nil

								      In an equation for ‘it’: it = Vector.head Nil

								```


								Simplified, it means that while it was expecting the successor of a natural

								number, it got zero instead. This function is total, unlike the one in

								`Data.List`{.haskell}, which fails on the empty list.


								< head []    = error "Prelude.head: empty list"

								< head (x:_) = x


								Tail is just as easy, except in this case, instead of discarding the predecessor

								of the vector's length, we'll use it as the length of the resulting vector.


								This makes sense, as, logically, getting the tail of a vector removes its first

								length, thus "unwrapping" a level of `S`.


								> tail :: Vector (S x) a -> Vector x a

								> tail (_ :| xs) = xs


								Notice how neither of these have a base case for empty vectors. In fact, adding

								one will not typecheck (with the same type of error - Can't unify `Z`{.haskell}

								with `S x`{.haskell}, no matter how hard you try.)


								Init {#init}

								----


								What does it mean to take the initial of an empty vector? That's obviously

								undefined, much like taking the tail of an empty vector. That is, `init` and

								`tail` have the same type signature.


								> init :: Vector (S x) a -> Vector x a


								The `init` of a singleton list is nil. This type-checks, as the list would have

								had length `S Z` (that is - 1), and now has length `Z`.


								> init (x :| Nil) = Nil


								To take the init of a vector with more than one element, all we do is recur on

								the tail of the list.


								> init (x :| y :| ys) = x :| Vector.init (y :| ys)


								That pattern is a bit weird - it's logically equivalent to `(x :|

								xs)`{.haskell}. But, for some reason, that doesn't make the typechecker happy,

								so we use the long form.


								Last {#last}

								----


								Last can, much like the list version, be implemented in terms of a left fold.

								The type signature is like the one for head, and the fold is the same as that

								for lists. The foldable instance for vectors is given [here](#Foldable).


								> last :: Vector (S x) a -> a

								> last = foldl (\_ x -> x) impossible where


								Wait - what's `impossible`? Since this is a fold, we do still need an initial

								element - We could use a pointful fold with the head as the starting point, but

								I feel like this helps us to understand the power of dependently-typed vectors:

								That error will _never_ happen. Ever. That's why it's `impossible`!


								>   impossible = error "Type checker, you have failed me!"


								That's it for the basic vector operations. We can now slice a vector anywhere

								that makes sense - Though, there's one thing missing: `uncons`.


								Uncons {#uncons}

								------


								Uncons splits a list (here, a vector) into a pair of first element and rest.

								With lists, this is generally implemented as returning a `Maybe`{.haskell} type,

								but since we can encode the type of a vector in it's type, there's no need for

								that here.


								> uncons :: Vector (S x) a -> (a, Vector x a)

								> uncons (x :| xs) = (x, xs)


								Mapping over Vectors {#functor}

								====================


								We'd like a `map` function that, much like the list equivalent, applies a

								function to all elements of a vector, and returns a vector with the same length.

								This operation should hopefully be homomorphic: That is, it keeps the structure

								of the list intact.


								The `base` package has a typeclass for this kind of morphism, can you guess what

								it is? If you guessed Functor, then you're right! If you didn't, you might

								aswell close the article now - Heavy type-fu inbound, though not right now.


								The functor instance is as simple as can be:


								> instance Functor (Vector x) where


								The fact that functor expects something of kind `* -> *`, we need to give the

								length in the instance head - And since we do that, the type checker guarantees

								that this is, in fact, a homomorphic relationship.


								Mapping over `Nil` just returns `Nil`.


								>  f `fmap` Nil = Nil


								Mapping over a list is equivalent to applying the function to the first element,

								then recurring over the tail of the vector.


								>  f `fmap` (x :| xs) = f x :| (fmap f xs)


								We didn't really need an instance of Functor, but I think standalone map is

								silly.


								Folding Vectors {#foldable}

								===============


								The Foldable class head has the same kind signature as the Functor class head:

								`(* -> *) -> Constraint` (where `Constraint` is the kind of type classes), that

								is, it's defined by the class head


								< class Foldable (t :: Type -> Type) where


								So, again, the length is given in the instance head.


								> instance Foldable (Vector x) where

								>    foldr f z Nil = z

								>    foldr f z (x :| xs) = f x $ foldr f z xs


								This is _exactly_ the Foldable instance for `[a]`, except the constructors are

								different. Hopefully, by now you've noticed that Vectors have the same

								expressive power as lists, but with more safety enforced by the type checker.


								Conclusion

								==========


								Two thousand words in, we have an implementation of functorial, foldable vectors

								with implementations of `head`, `tail`, `init`, `last` and `uncons`.  Since

								going further (implementing `++`, since a Monoid instance is impossible) would

								require implementing closed type familes, we'll leave that for next time.


								Next time, we'll tackle the implementation of `drop`, `take`, `index` (`!!`, but

								for vectors), `append`, `length`, and many other useful list functions.

								Eventually, you'd want an implementation of all functions in `Data.List`. We

								shall tackle `filter` in a later issue.


								[^kind]: You can read about [Kind polymorphism and

								Type-in-Type](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#kind-polymorphism-and-type-in-type)

								in the GHC manual.


								[^kinds]: The TypeInType extension unifies the type and kind level, but this

								article still uses the word `kind` throughout. This is because it's easier to

								reason about types, datatype promotion and type familes if you have separate

								type and kind levels.