(A more complete treatment of type classes and higer kinds.)

## A simple Type Class

Take the following

trait Mapping[A, B]{ def map(a: A): B }

and an instance for it

val mapping: Mapping[List[Int], List[String]] = new Mapping[List[Int], List[String]]{ override def map(a: List[Int]): List[String] = a.map(_.toString) }

This instance is super restrictive. It only works for taking **Int **into **String**. We want to map a **List** of any type. Since we know what our type parameters are, we can achieve our goal by passing in a function

trait ListMapping[A, B]{ def map(list: List[A])(f: A => B): List[B] }

So, given a **List[A] **and a function, **A => B**, we can get a **List[B]**. And by taking the type parameters from the trait definition and placing them onto the function definition, we can squeeze out a bit more freedom.

trait ListMapping{ def map[A, B](list: List[A])(f: A => B): List[B] } val mapping: ListMapping = new ListMapping{ override def map[A, B](a: List[A])(f: A => B): List[B] = a.map(f) }

Now, why would anyone ever do this? The **List **type provides a map function which does exactly this. With this approach one may provide any number of methods for mapping a list. Take this alternative:

val reverseMapping: ListMapping =

new ListMapping{

override def map[A, B](a: List[A])(f: A => B): List[B] =

a.reverse.map(f)

}

Through type classes, we can define new functionality for old data structures on the fly. Similar code can be written for sort order, string formatting or just about anything else.

## Making things even more general

While, the ability to map Lists of any type in any number of ways is fairly abstract it is not abstract enough for our purposes. What if we want to map a different data structure such as an Option or a Stream or a spark Dataset?

Luckily, Scala has a language feature which can help us out here.

trait WithMap[F[_]]{ def map[A, B](m: F[A])(f: A => B): F[B] }

The type parameter, **F[_]**, has a type parameter of **_**, this tells the compiler that our type parameter itself requires a type parameter. Notice in our definition all mention of **List **has been replaced by our parameter, **F**. This just says that given a type, F, which itself takes a type parameter, we can change the inner type or F without changing F. We can do this with any parameterized type of arity 1.

implicit val listWithMap = new WithMap[List]{ override def map[A, B](m: List[A])(f: A => B): List[B] = m.map(f) } implicit val optionWithMap = new WithMap[Option]{ override def map[A, B](m: Option[A])(f: A => B): Option[B] = m.map(f) } implicit val streamWithMap = new WithMap[Stream]{ override def map[A, B](m: Stream[A])(f: A => B): Stream[B] = m.map(f) } val reverseListWithMap = new WithMap[List]{ override def map[A, B](m: List[A])(f: A => B): List[B] = m.reverse.map(f) }

With these techniques we can define super polymorphic functions. Take this pretty strinfigy function

def prettyString[F[_]: WithMap, A](m: F[A])(f: A => String): String = { implicitly[WithMap[F]].map(m)(f).toString }

This takes two type parameters, **F[_]: WithMap **and **A**. The `:` character in the first type parameter tells the compiler that it needs an implicit instance of **WithMap **defined for our type **F**.

And here is a data processor defined in the same way

def processData[F[_]: WithMap, A, B, C, D]( m1: F[A])(f1: A => B)(f2: B => C)(f3: C => D): F[D] = { val F = implicitly[WithMap[F]] val m2 = F.map(m1)(f1) val m3 = F.map(m2)(f2) F.map(m3)(f3) }

We have taken an implementation detail (the **map** function on List, Option, etc...) and brought it outside the type. This has given us the ability to talk about data which has a sensible map function without knowing what that data necessarily looks like.

Next we'll learn how to read some of the Type Level functions that exist in the shapeless library.