# Shapeless: polymorphic functions

Time ago, our friend Javier Fuentes illustrated us with an introduction to Shapeless.
Some months after that, at Scala Madrid meetup, he offered a pretty interesting speech about structural induction with Shapeless and HLists. We couldn’t avoid it and we got the enthusiasm flu 😛

## What we want to achieve

Let’s set as our study case what I think more than one has thought before: how can I compose in the same for-comprehension different types. Something like:

```import scala.util.Try

for {
v1 <- List(1,2,3)
v2 <- Try("hi, person ")
} yield s"\$v2 \$v1"
```

which usually comes from the hand of the following frustrating error:

```<console>:15: error: type mismatch;
found   : scala.util.Try[String]
required: scala.collection.GenTraversableOnce[?]
v2 <- Try("hi, person ")
^
```

Therefore we need a way to transform these data types (`Future`, `Try`) into iterable ‘stuff’ (`GenTraversable[T]` might work). In our example we won’t have in mind the information that we loose about the error that might happen, for example, if certain `Try` or `Future` expression has failed. For have a better understanding about the problem we present, let’s talk about some theory.

## Monomorphism vs polymorphism

We say a method is monomorphic when you can only invoke it with parameters whose concrete type is explicitly declared in the method signature, whilst the polymorphic methods can take parameters of any type while it fits in the signature (in case of Scala language: parameter types). Speaking proper English:

```def monomorphic(parameter: Int): String

def polymorphic[T](parameter: T): String
```

### Polimorphism

It’s also good to know that a method can be polymorphic due to parameter types or just to parameter subtyping. E.g.:

```def parametricallyPolymorphic[T](parameter: T): String

def subtypedPolymorphic(parameter: Animal): String

subtypedPolymorphic(new Cat)
```

If we use parameter types and we have NO information at all about those types, we are in front of a parametric polymorphism case.

If we use parameter types but we need any extra view / context bound for that type (`T <: Whatever` o `T:TypeClass`), then we are talking about ad-hoc polymorphism.

### Problem: Function values

There’s not such a problem when using parametric polymorphism and methods but, what about function values? In Scala, it cannot be achieved and therefore it produces some lack of expressiveness:

```val monomorphic: Int => String = _.toString

val anotherMonomorphic: List[Int] => Set[Int] =
_.toSet

```

Please, notice the definition of the function that trasforms a List into a Set. It could be totally independant of the list element type, but Scala syntax doesn’t allow to define something similar. We could try asigning the method to a `val` (Eta expansion):

```def polymorphic[T](l: List[T]): Set[T] = l.toSet

```

But the compiler (as clever as usual) wil infer that the list contained type is `Nothing`: a special one, but concrete as the most.

## Shapeless parametric polymorphism

How does Shapeless solve this problem? If we had to define a transformation function from `Option` to `List` in Scala, we’d have the previously mentioned limitation for using function values and we could only achieve it by defining a method:

```def toList[T](o: Option[T]): List[T] =
o.toList
```

However, Shapeless, using its alchemy, provides us some ways to do so. In category theory, when talking about type constructors transformations, it’s so called natural transformations. First of them has the following notation:

```import shapeless.poly._

val polyFunction = new (Option ~> List){
def apply[T](f: Option[T]): List[T] = f.toList
}
```

If you have a closer look at it, the parametric polymorphism is moved to the method inside the object. Using this function is as simple as:

```val result: List[Int] = polyFunction(Option(2))
```

The other possible notation consists on defining the function behavior based on cases, in other words, if we want the function to be defined only for Int, String and Boolean, we’ll add a case for each of them.

```import shapeless.Poly1

object polymorphic extends Poly1 {

implicit optionIntCase =
at[Option[Int]](_.toList.map(_ + 1))

implicit optionStringCase =
at[Option[String]](_.toList.map(_ + " mutated"))

implicit optionBooleanCase =
at[Option[Boolean]](_.toList.map(!_))

}
```

As you can see, if we want our function to be defined at the case where the input parameter is an `Option[Int]`, we define that all contained elements in the list are added to 1.

This expression returns a `this.Case[Option[Int]]`, where this refers to `polymorphic` object that we are defining:

```implicit optionIntCase =
at[Option[Int]](_.toList.map(_ + 1))
```

The good part of this? In case we wanted to use the funcion on a input type that doesn’t have a defined case at the function, we’ll get a compile-time error (Awesome, right?):

## The result

Applying this last way (based on cases), we get the expected result that we mentioned in the introductory section: to be able to use a for-comprehension for composing different typed values: iterables, Try, Future…

The proposed solution can be found in the following file.

In our function we have a case for `GenTraversable`, another for `Try` and `Future` (this last one needs to have its expression evaluated for being able to iterate over it, so we need a timeout for waiting):

```object values extends Poly1 {

implicit def genTraversableCase[T,C[_]](implicit ev: C[T] => GenTraversable[T]) =
at[C[T]](_.toStream)

implicit def tryCase[T,C[_]](implicit ev: C[T] => Try[T]) =
at[C[T]](_.toOption.toStream)

implicit def futureCase[T,C[_]](implicit ev: C[T] => Future[T], atMost: Duration = Duration.Inf) =
at[C[T]](f => Try(Await.result(f,atMost)).toOption.toStream)

}
```

Now we can use it in our controversial code snippet:

```import scala.concurrent.ExecutionContext.Implicits.global

case class User(name: String, age: Int)

val result: Stream[_] = for {
v1 <- values(List(1,2,3))
v2 <- values(Set("hi","bye"))
v3 <- values(Option(true))
v4 <- values(Try(2.0))
v5 <- values(Future(User("john",15)))
} yield (v1,v2,v3,v4,v5)
```

## The sole solution?

At all! you can always implement it using traditional Scala type classes, though it implies defining a trait that represent the ADT iterable. You can take a look at the example at the following gist content.

Peace out!

Anuncios