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.