This is shapeless' HList

sealed trait HList extends Product with Serializable final case class ::[+H, +T <: HList](head : H, tail : T) extends HList { override def toString = head match { case _: ::[_, _] => "("+head+") :: "+tail.toString case _ => head+" :: "+tail.toString } } sealed trait HNil extends HList { def ::[H](h : H) = shapeless.::(h, this) override def toString = "HNil" } case object HNil extends HNil

The important thing to note is it is very similar to a standard scala List just at the type level. It has a head and tail as type parameters and the tail is itself an HList. The implementation details are not important for our purposes here. All we need to take from this is an HList is a recursive list (head, tail) which is either empty (HNil) or whose elements can be of different types.

## A Type Level Operation on HList

This is a function defined in shapeless which helps client code work with HLists

trait Mapped[L <: HList, F[_]] extends Serializable { type Out <: HList } object Mapped { … type Aux[L <: HList, F[_], Out0 <: HList] = Mapped[L, F] { type Out = Out0 } implicit def hnilMapped[F[_]]: Aux[HNil, F, HNil] = new Mapped[HNil, F] { type Out = HNil } … implicit def hlistMapped1[ H, T <: HList, F[_], OutM <: HList](implicit mt: Mapped.Aux[T, F, OutM]): Aux[H :: T, F, F[H] :: OutM] = new Mapped[H :: T, F] { type Out = F[H] :: OutM } }

We can see all the parts we mentioned in the first post of this series. Recall:

- Keywords
- Input types
- Output types
- Body

Note there are multiple **implicit ****def **declarations. The modifiers **implicit def** are similar to **case **statements in value function bodies. Let's take this piece by piece.

## The First Case

implicit def hnilMapped[F[_]]: Aux[HNil, F, HNil] = new Mapped[HNil, F] { type Out = HNil }

When focusing on the types, the intent becomes clear

implicit def hnilMapped[]: Aux[HNil, F, HNil] = new Mapped[HNil, F] {F[_]}type Out = HNil

This reads something like: Given a type constructor, yield the empty HList. Simple enough! This stuff is comprehensible afterall!

## The Second Case

implicit def hlistMapped1[ H, T <: HList, F[_], OutM <: HList](implicit mt: Mapped.Aux[T, F, OutM]): Aux[H :: T, F, F[H] :: OutM] = new Mapped[H :: T, F] { type Out = F[H] :: OutM }

This is admittedly more complex. Let's take it in stride again focusing on the types.

implicit def hlistMapped1[,H,T <: HList,F[_]](implicit mt:OutM <: HList): Aux[H :: T, F, F[H] :: OutM] = new Mapped[H :: T, F] {Mapped.Aux[T, F, OutM]}type Out = F[H] :: OutM

- Given a head, a tail which is an HList, a type constructor and another HList
- Also, given proof that this type class holds good for our tail
- We can generate an HList where our type constructor is applied to our head and the tail follows

## A brief Word on Induction

Many of the type level functions encountered in the wild are of this type. Where there is at the very least

- a trivial case which produces some terminal element
- a more complex case where given a type or arity n can produce a type of arity n+1

In other words, recursive types can be generated inductively assuming you have an instance of the recursive type and all the necessary parts to wrap that instance within the target type.

In the next post we'll create some type level code using these methods.