Abstract alge… what? Functors and cucumbers

Category mania! Are we paid for speaking about it? I’m afraid we don’t. Would we like to? Very likely. In previous posts we spoke about monoids and monads, but now it’s functor’s time. Functors are everywhere and we can prove it. Before reviewing its different kinds, let’s focus on key concepts.

What’s a morphism?

It’s just a transformation between two structures, a change between spaces, a mutation.
In Scala? A simple function:

```val f: A => B
```

What’s a functor?

Quick and simple answer: the behavior that defines, for a certain F[A] type constructor, the map method.

```trait Functor[F[_]]{
def map[A, B](fA: F[A])(f: A => B): F[B]
}
```

There are functors for `List`, `Option`, `Future`, `Try`, …

```object ListFunctor extends Functor[List]{
def map[A, B](fA: List[A])(f: A => B): List[B] =
fA match {
case Nil => Nil
}
}
object OptionFunctor extends Functor[Option]{
def map[A, B](fA: Option[A])(f: A => B): Option[B] =
fA match {
case None => None
case Option(a) => Option(f(a))
}
}
//...
```

Actually, apart from the famous `map` method, they should fit into a couple of properties:

• Identity morphism: `F[Id[A]] = Id[F[A]]`. For example, being identity the identity function defined in Scala, `Option(identity(1)) == identity(Option(1))`
• Morphism composition: If we have two morphisms f: A => B and g: B => C, it must be checked that F[f o g] = F[f] o F[g]. It’s not as complicated as it seems:
```val f: Int => String = _.toString
val g: String => Boolean = _.length > 1
val l: List[Int] = List(1,20,3)
l.map(f).map(g) ==
l.map(f andThen g) ==
l.map(n => g(f(n)))
//List(false, true, false)
```

Even though, we can describe functors (in the context of a F[_] production chain) as the instructions for transforming some given A input value into some B output value within the same F[_] production chain, by using a morphism (a transformation function) A => B.

Functor types

Ordinary functors are also known as co-variant functors (in order to differentiate itself from contravariant and invariant functors). Let’s se what makes the difference between these different kinds of functor:

Contravariant Functor

Formal definition says that a F[_] functor is contravariant if, instead of having the `map` method, it has a `contramap` method defined:

```trait Contravariant[F[_]]{
def contramap[A, B](fA: F[A])(f: B => A): F[B]
}
```

That’s it: if it exists a function B => A, the contramap method defines F[A] => F[B].

…ok, let’s stop being so hardcore. We’ll illustrate it with an example.

Imagine a type class that knows how to compare certain type elements:

```type Comparison = Int
val Greater = 1
val Equal = 0
val Lower = -1

trait Comparator[T]{
def compare(t1: T, t2: T): Comparison
}
```

Imagine as well, that I know how to compare integer numbers (and here comes the tricky tip):

if I know how to compare integers and I know how to convert ‘cucumbers’ into integer numbers, I do know how to compare ‘cucumbers’

```object ComparatorF extends Contravariant[Comparator]{
def contramap[A, B]
(fA: Comparator[A])
(f: B => A): Comparator[B] =
new Comparator[B]{
def compare(t1: B, t2: B): Comparison =
fA.compare(f(t1), f(t2))
}
}
```

And now, the so-expected example about how to generate a contravariant functor for cucumbers:

```trait Cucumber
val intC: Comparator[Int] = ???
val cucumberToInt: Cucumber => Int = ???
val cucumberC: Comparator[Cucumber] =
ComparatorF.contramap(intC)(cucumberToInt)

cucumberC.compare(new Cucumber{}, new Cucumber{})
```

…sublime…

Invariant functors

Invariant functors for F[_] are determined by the `imap` method:

```trait Invariant[F[_]] {
def imap[A, B](fA: F[A])(f: A => B)(g: B => A): F[B]
}
```

…once again the doubt is killing you: I know and I beg you for some time to explain properly. Let’s see some example.

Imagine a type class that knows how to store stuff in some database (MongoDB, for example):

```case class ObjectId(hash: String)

trait DataStorage[T]{
def store(t: T): ObjectId
def get(id: ObjectId): T
}
```

If we forget about possible effects (exceptions, timeouts and so) for not messing up the example, we could define an invariant functor for DataStorage that allows storing any-kind elements:

```object DataStorageF extends Invariant[DataStorage]{
def invariant[A, B]
(fA: DataStorage[A])
(f: A => B)
(g: B => A): DataStorage[B] = {

new DataStorage[B]{
def store(b: B): Option[ObjectId] =
fA.store(g(b))
def get(id: ObjectId): B =
f(fA.get(id))
}
}
}
```

So…

If I know how to store integers and I know how to convert integers into cucumbers (and the other way round), I know how to store cucumbers!

```val intDS: DataStorage[Int] = ???
val cucumberToInt: Cucumber => Int = ???
val intToCucumber: Int => Cucumber = ???
val cucumberDS: DataStorage[Cucumber] =
DataStorageF
.imap(intDS)(intToCucumber)(cucumberToInt)

val id = cucumberDS.store(new Cucumber{})
val originalCucumber = cucumberDS.get(id)
```

We couldn’t say this is all, but it may be a good introduction to the wonderful functor world. See you in the next poxt. ‘Like’ and share if you like storing cucumbers.
Peace out!

Teoría de Cate-movidas: Functores y pepinos

Que manía con las categorías. ¿Nos pagan por hablar de ello? No. ¿Nos gustaría que lo hiciesen? Es muy probable. En otras ocasiones hablábamos de monoides y mónadas, pero esta vez le toca el turno a los functores. Los functores están por todas partes y no son los padres: podemos demostrarlo. Antes de detallar sus variantes, centrémonos en los conceptos clave.

¿Qué es un morfismo?

Una transformación entre dos espacios, un cambio, una mutación.
¿En Scala? Una función:

```val f: A => B
```

¿Qué es un functor?

Respuesta corta y simple: el comportamiento que define, para un constructor de tipos F[A], el método ‘map’:

```trait Functor[F[_]]{
def map[A, B](fA: F[A])(f: A => B): F[B]
}
```

Existen functores para `List`, `Option`, `Future`, `Try`, …

```object ListFunctor extends Functor[List]{
def map[A, B](fA: List[A])(f: A => B): List[B] =
fA match {
case Nil => Nil
}
}
object OptionFunctor extends Functor[Option]{
def map[A, B](fA: Option[A])(f: A => B): Option[B] =
fA match {
case None => None
case Option(a) => Option(f(a))
}
}
//...
```

En realidad, a parte del famoso método `map`, deben cumplir un par de propiedades más:

• Morfismo identidad: `F[Id[A]] = Id[F[A]]`. Por poner un ejemplo, siendo identity la función identidad definida en Scala, `Option(identity(1)) == identity(Option(1))`
• Composición de morfismos: Si tenemos dos morfismos f: A => B y g: B => C, se debe cumplir que F[f o g] = F[f] o F[g]. Que no es tan complicado si lo vemos con
```val f: Int => String = _.toString
val g: String => Boolean = _.length > 1
val l: List[Int] = List(1,20,3)
l.map(f).map(g) ==
l.map(f andThen g) ==
l.map(n => g(f(n)))
//List(false, true, false)
```

Pero a grandes rasgos, podemos pensar en los functores ordinarios como la descripción de como, en una cadena de producción o montaje F[_], se permite realizar transformaciones de manera que, para argumento un A, y usando un morfismo (una función de transformación) A => B, obtenemos un B dentro de la misma cadena de producción F[_]

Clasificación de functores

Los functores ordinarios también son denóminados co-variantes (para ser diferenciados de los contravariantes y de los invariantes). Veamos a continuación qué caracteriza a estos otros tipos de functor:

Functor contravariante

La definición formal dice que un functor para F[_] es contravariante si, en vez el método `map`, tiene definida la operación `contramap`:

```trait Contravariant[F[_]]{
def contramap[A, B](fA: F[A])(f: B => A): F[B]
}
```

Esto es, si existe una función B => A, el functor define F[A] => F[B].

…venga va, sin ser hardcore, ponemos un ejemplo.

Imagina una type class que sabe comparar elementos de un cierto tipo:

```type Comparison = Int
val Greater = 1
val Equal = 0
val Lower = -1

trait Comparator[T]{
def compare(t1: T, t2: T): Comparison
}
```

Imagina del mismo modo que yo dispongo de un comparador de números enteros (y aquí viene el quid de la cuestión):

si yo se comparar enteros y se como transformar ‘pepinos’ a enteros, ya se como comparar ‘pepinos’

```object ComparatorF extends Contravariant[Comparator]{
def contramap[A, B]
(fA: Comparator[A])
(f: B => A): Comparator[B] =
new Comparator[B]{
def compare(t1: B, t2: B): Comparison =
fA.compare(f(t1), f(t2))
}
}
```

Y ahora el archi-esperado ejemplo de generar un functor contravariante para pepinos:

```trait Cucumber
val intC: Comparator[Int] = ???
val cucumberToInt: Cucumber => Int = ???
val cucumberC: Comparator[Cucumber] =
ComparatorF.contramap(intC)(cucumberToInt)

cucumberC.compare(new Cucumber{}, new Cucumber{})
```

…sublime…

Functor invariante

Los functores invariantes para F[_] se caracterizan por tener un método denominado `imap` como sigue:

```trait Invariant[F[_]] {
def imap[A, B](fA: F[A])(f: A => B)(g: B => A): F[B]
}
```

…otra vez en el valle de la duda después de esta definición, lo se y pido paciencia. Se ve mucho mejor con otro ejemplo.

Imagina una type class que sabe almacenar objetos en una base de datos (MongoDB, por ejemplo):

```case class ObjectId(hash: String)

trait DataStorage[T]{
def store(t: T): ObjectId
def get(id: ObjectId): T
}
```

Olvidándonos de los posibles efectos (excepciones, timeouts, etc) para no liar el ejemplo, podemos definir un functor invariante para DataStorage que permita almacenar cualquier elemento:

```object DataStorageF extends Invariant[DataStorage]{
def invariant[A, B]
(fA: DataStorage[A])
(f: A => B)
(g: B => A): DataStorage[B] = {

new DataStorage[B]{
def store(b: B): Option[ObjectId] =
fA.store(g(b))
def get(id: ObjectId): B =
f(fA.get(id))
}
}
}
```

Por lo tanto…

Si yo se como almacenar enteros y se transformar pepinos a enteros (y viceversa),
¡se cómo almacenar pepinos!

```val intDS: DataStorage[Int] = ???
val cucumberToInt: Cucumber => Int = ???
val intToCucumber: Int => Cucumber = ???
val cucumberDS: DataStorage[Cucumber] =
DataStorageF
.imap(intDS)(intToCucumber)(cucumberToInt)

val id = cucumberDS.store(new Cucumber{})
val originalCucumber = cucumberDS.get(id)
```

No podemos decir que esto sea todo, pero sí puede ser una buena introducción al maravilloso mundo de los functores. Nos vemos en el próximo post. ‘Like’ y comparte si te gusta almacenar pepinos.
¡Agur de limón!

Monoids are not demode and thursdays are actually the new fridays

No, it’s not the latest Coixet’s movie title. When we talk about cathegories like monoids, we tend to think they just remain on the edge as something merely experimental (even though purely functional) and there’s no direct application at the real world. Something similar happened when you learnt square roots at school and there was no proper moment to start using them at real life…

The use case

This morning, ah naïve me, I tried to make this work:

```type Passengers = Int
type MaxCapacity = Passengers
type Plane = (Passengers, MaxCapacity)

val planes: List[Plane] =
List(1 -> 1, 2 -> 3, 3 -> 3)

val (totalPassengers, totalCapacity) =
planes.sum
//  ERROR: Could not find implicit value
//  for parameter num: Numeric[(Int, Int)]
```

Ok, fair enough, Scala needs something, an evidence, for adding integer tuples.
Before we start fighting with the ‘evidence’, let’s try to make it work in a more mechanical way:

```val sum = ((0,0) /: planes){
case ((totalPas,totalCap), (passengers, capacity)) =>
(totalPas + passengers, totalCap + capacity)
}
```

Okay, it works. But it should be simpler, so let’s get back to the idea of `Numeric[N]` evidence.

Implementing `Numeric[N]`

We need a `Numeric[(A,B)]` but before implementing it (it has a lot of abstract methods) let’s sweep under the rug all those methods we don’t really want to focus on in this example. For doing so, let’s create an intermediate layer that keeps all those method without an implementation (which doesn’t mean ‘abstract’):

```trait LeanNumeric[T] extends Numeric[T] {
override def fromInt(x: Int): T = ???
override def toInt(x: T): Int = ???
override def minus(x: T, y: T): T = ???
override def times(x: T, y: T): T = ???
override def negate(x: T): T = ???
override def toLong(x: T): Long = ???
override def toFloat(x: T): Float = ???
override def toDouble(x: T): Double = ???
override def compare(x: T, y: T): Int = ???
}
```

Let’s call this abomination LeanNumeric (it only contains the essentials to develop our example). And now, we can define the method that generates the evidence for any `Tuple2`:

```implicit def numeric[A, B](
implicit nA: Numeric[A],
nB: Numeric[B]): Numeric[(A, B)] = {
new LeanNumeric[(A, B)]{
override def zero = (nA.zero, nB.zero)
override def plus(x: (A, B), y: (A, B)): (A, B) = {
val (a1, b1) = x
val (a2, b2) = y
(nA.plus(a1, a2), nB.plus(b1, b2))
}
}
}
```

If we put the implicit into scope and we run again `planes.sum`…boom! Magic.

Num…oid

We don’t have to master category theory to realize that `Numeric[N]` may be a thousand of things, but it satisfies at least two properties:

• The append operation: The sum operation – given n1 and n2 of type N, it return a new N element. Only because of this feature(and the closure, associativity, commutative, …) we can consider it a Semigroup.

• And additionally the zero element

Seriously? Isn’t it obvious enough? My dear friends, monoid is back in town!

Implementation with `scalaz.Monoid`

Having in mind that Numeric has (at least) these two properties, let’s re-implement the implicit by using scalaz Monoid. We first define the monoid for integers and the tuple monoid which requires a monoid for each type that compounds the tuple (easy peasy):

```import scalaz._

implicit object IntMonoid extends Monoid[Int]{
override def zero: Int = 0
override def append(f1: Int, f2: => Int): Int = f1 + f2
}

implicit def tupleMonoid[A,B](
implicit mA: Monoid[A],
mB: Monoid[B]): Monoid[(A,B)] = {
new Monoid[(A, B)] {
override def zero: (A, B) = (mA.zero, mB.zero)
override def append(f1: (A, B), f2: => (A, B)): (A, B) = {
val (a1, b1) = f1
lazy val (a2, b2) = f2
(mA.append(a1,a2), mB.append(b1, b2))
}
}
}
```

So good so far, right?

After that, we implement the implicit that will provide a Numeric as long as there’s a Monoid for the type

```implicit def numeric[T](
implicit m: Monoid[T]): Numeric[T] = {
new LeanNumeric[T]{
override def zero = m.zero
override def plus(x: T, y: T): T = m.append(x, y)
}
}

planes.sum //(6,7)
```

And it’s awesomely easy to get abstract of whatever T means (a tuple? a dog? …). As long as it’s a monoid, you can define a LeanNumeric.

You can find here the gist.

See you in the next functional madness.

Peace out!

Los monoides no están demodé y los jueves sí son los nuevos viernes

No, no es el título de la nueva película de Coixet. Cuando hablamos de categorías como los monoides, tendemos a pensar que se quedan en el ámbito de lo experimental (aunque funcionalmente puro) y que no existe aplicación directa sobre el mundo real. Algo parecido a lo que ocurría cuando te enseñaban a hacer raíces cuadradas en el colegio y no veías el momento para usarlo en la vida real…

El caso de uso

Esta misma mañana, ingenuo de mi, intentaba hacer que funcionara lo siguiente:

```type Passengers = Int
type MaxCapacity = Passengers
type Plane = (Passengers, MaxCapacity)

val planes: List[Plane] =
List(1 -> 1, 2 -> 3, 3 -> 3)

val (totalPassengers, totalCapacity) =
planes.sum
//  ERROR: Could not find implicit value
//  for parameter num: Numeric[(Int, Int)]
```

Vale, comprensible, Scala necesita algo, una evidencia, para poder sumar tuplas de enteros.
Antes de pegarnos con la “evidencia”, intentemos hacerlo funcionar de una manera mucho más mecánica:

```val sum = ((0,0) /: planes){
case ((totalPas,totalCap), (passengers, capacity)) =>
(totalPas + passengers, totalCap + capacity)
}
```

Okay, funciona. Pero debería ser algo más simple, por lo que retomemos la idea de la evidencia `Numeric[N]`.

Implementando `Numeric[N]`

Necesitamos un `Numeric[(A,B)]` pero antes de implementarlo (tiene bastantes métodos abstractos) escondamos debajo de la alfombra aquellos métodos en los cuales no queremos centrarnos en este ejemplo. Para ello creamos una capa por encima que deje los métodos sin implementar (que no abstractos):

```trait LeanNumeric[T] extends Numeric[T] {
override def fromInt(x: Int): T = ???
override def toInt(x: T): Int = ???
override def minus(x: T, y: T): T = ???
override def times(x: T, y: T): T = ???
override def negate(x: T): T = ???
override def toLong(x: T): Long = ???
override def toFloat(x: T): Float = ???
override def toDouble(x: T): Double = ???
override def compare(x: T, y: T): Int = ???
}
```

A esta aberración la llamaremos LeanNumeric (solo contiene lo esencial para desarrollar nuestro ejemplo). Y ahora definimos el método que genera la evidencia para cualquier `Tuple2`:

```implicit def numeric[A, B](
implicit nA: Numeric[A],
nB: Numeric[B]): Numeric[(A, B)] = {
new LeanNumeric[(A, B)]{
override def zero = (nA.zero, nB.zero)
override def plus(x: (A, B), y: (A, B)): (A, B) = {
val (a1, b1) = x
val (a2, b2) = y
(nA.plus(a1, a2), nB.plus(b1, b2))
}
}
}
```

Si ponemos el implícito en scope y ejecutamos de nuevo el `planes.sum`…¡boom! Magia.

Num…oide

No hace falta saber mucho de teoría de categorías para centrarse en que `Numeric[N]`, podrá ser mil cosas más, pero cumple dos propiedades:

• La operación append : La operación suma – dados n1 y n2 de tipo N, devuelve otro elemento N. Solo por disponer de esta operación (y el clossure, la asociatividad, la conmutativa, …) ya podemos considerarlo un Semigroup

• Y adicionalmente el elemento zero : genera el elemento neutro de la suma

¿en serio?¿No es evidente?…amigos, ¡el monoide ha vuelto a la ciudad!

Implementación con `scalaz.Monoid`

Viendo que el tipo Numeric tiene al menos esas dos propiedades, re-implementamos el implícito haciendo uso de Monoid. Primero definimos el monoide para enteros y el monoide de las tuplas,
el cual requiere de un monoide para cada tipo que compone la tupla (easy peasy)

```import scalaz._

implicit object IntMonoid extends Monoid[Int]{
override def zero: Int = 0
override def append(f1: Int, f2: => Int): Int = f1 + f2
}

implicit def tupleMonoid[A,B](
implicit mA: Monoid[A],
mB: Monoid[B]): Monoid[(A,B)] = {
new Monoid[(A, B)] {
override def zero: (A, B) = (mA.zero, mB.zero)
override def append(f1: (A, B), f2: => (A, B)): (A, B) = {
val (a1, b1) = f1
lazy val (a2, b2) = f2
(mA.append(a1,a2), mB.append(b1, b2))
}
}
}
```

Hasta aquí bien, ¿correcto?

Implementemos ahora el implícito que nos proporcionará un Numeric siempre que exista un Monoid para el tipo

```implicit def numeric[T](
implicit m: Monoid[T]): Numeric[T] = {
new LeanNumeric[T]{
override def zero = m.zero
override def plus(x: T, y: T): T = m.append(x, y)
}
}

planes.sum //(6,7)
```

Y es increiblemente sencillo abstraerse de lo que demonios sea T (¿una tupla?, ¿un perro?, …).
Mientras sea un monoide, se puede definir un LeanNumeric.

Podéis encontrar aquí el gist resumen

Hasta la próxima locura funcional.

¡Agur de limón!

Scalera tip: Handling sticky implicit contexts

A couple of days ago (translation for the masses: like a month ago) I noticed Viktor Klang was tweeting about removing the annoying implicit evidences from methods. And some things I read seemed so elegant to me that I was forced to share some related ideas with all of you that don’t follow him at Twitter (@viktorklang).

Setting some context

Imagine the typical polymorphic method where we need an execution context for evaluating some Future:

```import scala.concurrent.{ExecutionContext, Future}

def myMethod[T]
(element: T)
(implicit ev: ExecutionContext): Future[Boolean] = ???
```

You could say it’s as typical as disgusting, having to repeat the same exact words in the following 10 method definitions: `(implicit ev: ExecutionContext)`.

Playing with type alias

The happy idea that is being proposed is to define a type alias like the following one:

```type EC[_] = ExecutionContext
```

This way, by adding some syntax sugar, we would re-define the method signature:

```def myMethod[T:EC](element: T): Future[Boolean] = ???
myMethod("hi")
```

Beautiful, isn’t it?

Some other possibilities

Non-polymorphic methods

In case our method isn’t parameterized, we would have to add some boilerplate (by adding a wildcard for the type that parameterizes the method). In essence, it should be working the same principle:

```def myMethod[_:EC](element: Int): Future[Boolean] = ???
myMethod(2)
```

Multiple implicit contexts

The not-so-crazy case in which we needed several implicit parameters of different natures, we would have to define as many type alias as different type parameters we required:

```type EC[_] = ExecutionContext
type MongoDB[_] = MongoDBDatabase

def myMethod[_:EC:MongoDB](element: Int): Future[Boolean] = ???
```

But what if …?

Multiple implicit parameters with same type

In case we have several implicit parameters that share the same type,

```def myMethod
(element: Int)
(implicit ev1: ExecutionContext, ev2: ExecutionContext): Future[Boolean] = ???
```

it turns out that …

Well, by definition that’s impossible given that it would incur in some ambiguity issue when resolving implicits. It’s true that Scala allows having these kind of signatures, but we could only invoke them by making explicit the arguments contained in the second parameter group.:

```myMethod(2)(ec1,ec2)
```

which is kind of…

Type-constructor implicit contexts

When we have implicit parameters that are also type constructors like `List[T], Future[T], Option[T]`

…well, it actually depends.

Case 1

If the type that parameterizes the method and the one that parameterizes the evidence are not related, there’s no big deal: we define another type alias and move on:

```type EC[_] = ExecutionContext
type MongoDB[_] = MongoDBDatabase
type IntOpt[_] = Option[Int]
type StrList[_] = List[String]

def myMethod[_:EC:MongoDB:IntOpt:StrList](
element: Int): Future[Boolean] = ???
```

Which would be equivalent to:

```def myMethod(
element: Int)(
implicit ev1: ExecutionContext,
ev2: MongoDBDatabase,
ev3: Option[Int],
ev4: List[String]): Future[Boolean] = ???
```

Case 2

If the type that parameterizes the method and the one that parameterizes the evidence have to match …

Well, it’s not possible. The syntax sugar we’re using here implies that both types have to match. Maybe it was too pretty for our bodies 🙂

See you in the next post. Peace out!

Scalera tip: contextos implícitos pegajosos

El otro día (para la gente normal: hace cosa de 1 mes) vi que el gran Viktor Klang twiteaba acerca de como quitar las molestas evidencias implícitas en definiciones de métodos. Y me pareció tan elegantes algunas de las cosas que leí, que me vi en la obligación de compartir algunas ideas al hilo de dichos consejos con aquellos de vosotros que no le sigáis aun en Twitter (@viktorklang).

La situación

Imaginad el típico método polimórfico en el cual necesitamos un execution context para ejecutar un futuro:

```import scala.concurrent.{ExecutionContext, Future}

def myMethod[T]
(element: T)
(implicit ev: ExecutionContext): Future[Boolean] = ???
```

Es tan típico como feo, el tener que repetir la coletilla de `(implicit ev: ExecutionContext)` en 10 métodos seguidos…

Jugando con type alias

La idea feliz que se propone es definir un type alias del siguiente tipo:

```type EC[_] = ExecutionContext
```

De esta forma, re-definiríamos la cabecera de nuestro método como sigue:

```def myMethod[T:EC](element: T): Future[Boolean] = ???
myMethod("hi")
```

¿Bello o no?

Métodos no polifórmicos

En el caso en que nuestro método no esté parametrizado, tendríamos que añadir algo de boilerplate (añadiendo un wildcard para el tipo que parametriza el método), pero en esencia debería seguir funcionando el mismo principio:

```def myMethod[_:EC](element: Int): Future[Boolean] = ???
myMethod(2)
```

Múltiples contextos implícitos

En el no-tan-descabellado caso en el que necesitáramos varios parámetros implícitos de distintos tipos, necesitaríamos definir tantos type alias como tipos distintos de parámetros requiriésemos:

```type EC[_] = ExecutionContext
type MongoDB[_] = MongoDBDatabase

def myMethod[_:EC:MongoDB](element: Int): Future[Boolean] = ???
```

Pero, ¿y si…?

Múltiples parámetros implícitos del mismo tipo

En el caso de que tengamos múltiples parámetros implícitos del mismo tipo,

```def myMethod
(element: Int)
(implicit ev1: ExecutionContext, ev2: ExecutionContext): Future[Boolean] = ???
```

ocurriría que …

Bueno, por definición eso es imposible ya que incurriría en un problema de ambigüedad a la hora de resolver implícitos. Es cierto que Scala nos permite este tipo de signaturas, pero sólo podríamos invocar al método haciendo explícitos los argumentos del segundo grupo de parámetros:

```myMethod(2)(ec1,ec2)
```

Lo cual es un tanto…

Contextos implícitos que son constructores de tipos

Cuando tenemos parámetros implícitos que son constructores de tipos como `List[T], Future[T], Option[T]`

Caso1

Si el tipo que parametriza el método y el que parametriza la evidencia no están relacionados, no hay mucho problema: definimos otro type alias y a correr:

```type EC[_] = ExecutionContext
type MongoDB[_] = MongoDBDatabase
type IntOpt[_] = Option[Int]
type StrList[_] = List[String]

def myMethod[_:EC:MongoDB:IntOpt:StrList](
element: Int): Future[Boolean] = ???
```

Lo cual sería el equivalente a:

```def myMethod(
element: Int)(
implicit ev1: ExecutionContext,
ev2: MongoDBDatabase,
ev3: Option[Int],
ev4: List[String]): Future[Boolean] = ???
```

Caso 2

Si el tipo que parametriza el método y el que parametriza la evidencia tienen que concordar …

Bueno no es posible. El syntax sugar implica que el tipo que parametriza el método vaya en concordancia con el tipo que parametriza nuestra evidencia. Quizás era todo demasiado bonito 🙂

Hasta el próximo post. ¡Agur de limón!

Scalera tip: Keep your actor’s state with no VAR at all!

It’s pretty well known that using VARs is, apart from unethical, the evil itself, some kind of hell, it make kitties die and many other stuff you might probably heard before and that could eventually be the cause of a painfull slowly dead.

The essence of functional programming is therefore the immutability: every time I mutate an element, I actually generate a new one.

When we talk about actors, we can define them as stateful computation units that sequentially process a message queue by reacting(or not) to each of these messages.

It’s always been said that, in order to keep state within some actor’s logic, it was ok to use VARs:

It’s impossible that concurrency problems happen: it’s the actor itself and nobody else who access that var and will only process one message at a time.

But maybe, we could renounce to this premise if we look for some way to redefine the actor’s behavior based on a new state.

Mortal approach

If we follow the previously described philosophy, the very first (and more straight forward) approach for keeping some actor’s state would be pretty similar to the following:

```class Foo extends Actor{
var state: Int = 0
case Increase => state += 1
}
}
```

Every time an `Increase` arrives, we modify the state value by adding 1.
So easy so far, right?

Immutable approach

Nevertheless, we could define a `receive` function parameterized by certain state, so when a message arrives, this parameter is the state to take into account.

If the circumstances to mutate the state took place, we would just invoke the `become` method that would modify the actor’s behavior. In our case, that behavior mutation would consist on changing the state value.

If we use the previously defined example:

```class Foo extends Actor{
case Increase =>
context.become(
}
}
```

we can notice that the function defined by `receive` is parameterized by some `state` argument. When some `Increase` message arrives, what we perform is an invocation to `become` for modifying the actor’s behavior, passing as an argument the new state to handle.

If we wanted some extra legibility, we could even get abstract from every updatabe-state actor:

```trait SActor[State] extends Actor {
val initialState: State
context.become(
}
```

this way, we just have to define the initial state of some actor, a new parameterized `receive` function and a new update function that takes care of performing the proper `become` call as explained before.
With all these in mind, we now have some cuter brand new `Foo` actor:

```class Foo extends SActor[Int] {
val initialState = 0
case Increase => update(state +1)
}
}
```

Potential hazardous issues

Please, do notice that in the featuring example, we’ve used a second argument for `become`: `discardOld = true`. This argument settles whether the new behavior should be stashed on the top of the older one, or ‘au contraire’ it should completely substitute the previous behavior.

Let’s suppose we used `discardOld = false`. If every single time a new `Increase` message arrived we had to stash a new behavior, we could obtain a wonderful overflow issue.

See you in the next tip.

Peace out 🙂