Si Future no es referencialmente transparente, tal vez deberíamos buscar otro tipo de datos similar que lo sea. Deberías reconocer a este...
Functions (?!)
Resulta que las funciones de un solo argumento también son funtores. Para ver esto, tenemos que modificar un poco los tipos. Una función A => B tiene dos parámetros de tipo:
el tipo de parámetro A y el tipo de resultado B. Para forzarlos a la forma correcta, podemos fijar el tipo de parámetro y dejar que el tipo de resultado varíe:
• empezar con X => A ;
• proporcionar una función A => B;
• recuperar X => B.
Si hacemos un alias X => A como MyFunc[A], vemos el mismo patrón de tipos que vimos con los otros ejemplos :
• empezar con MyFunc[A];
• proporcionar una función A => B;
• recuperar MyFunc[B].
En otras palabras, "mapear" sobre una Función1 es la composición de funciones:
import cats.instances.function._ // for Functor
import cats.syntax.functor._
// for map
val func1: Int => Double = (x: Int) => x.toDouble
val func2: Double => Double = (y: Double) => y * 2
(func1 map func2)(1)
// composition using map
// res3: Double = 2.0
// composition using map
(func1 andThen func2)(1) // composition using andThen
// res4: Double = 2.0 // composition using andThen
func2(func1(1))
// composition written out by hand
// res5: Double = 2.0
¿Cómo se relaciona esto con nuestro patrón general de secuenciación de operaciones? Si lo pensamos bien, la composición de funciones es secuenciación. Comenzamos con una función que realiza una sola operación y cada vez que usamos map agregamos otra operación a la cadena. Llamar a map en realidad no ejecuta ninguna de las operaciones, pero si podemos pasar un argumento a la función final, todas las operaciones se ejecutan en secuencia. Podemos pensar en esto como operaciones de cola perezosas similares a Future:
val func =
((x: Int) => x.toDouble).
map(x => x + 1).
map(x => x * 2).
map(x => s"${x}!")
func(123)
// res6: String = "248.0!"
