Azure Function en Python

La plataforma cloud de Azure ofrece un servicio para definir funciones, el servicio se llama “Function App”. Las funciones permiten definir funciones para la construcción de arquitecturas Serverless. Las funciones pueden ser definidas en distintos lenguajes, como pueden ser: Java, Python, F#, C#,… En la presente entrada, Azure Function en Python, me centraré en cómo crear funciones Python y su despliegue en Azure.

La estructura de la entrada es la siguiente:

  1. Instalación de Azure Functions Tools
    • Creación del proyecto
    • Creación de una función
    • Ficheros de configuración
  2. Función Functionbase
  3. Función Functionstore
  4. Ejecución de las funciones en local
  5. Publicación en Azure

Azure no proporciona un intarfaz en donde se puede desarrollar una función, es necesario  crear un entorno con unas herramientas determinadas, desarrollar la función y, una vez creada, se realiza el despliegue a la plataforma.

Para definir funciones en Azure es necesario realizar las siguientes tareas en un entorno local:

  1. Instalar el paquete Azure Functions Tools.
  2. Desarrollar en local la función.
  3. Desplegar el código en Azure.

1.- Instalación de Azure Functions Tools.

Azure Functions Tools es un conjunto de herramientas para el desarrollo de funciones en Python. En mi caso, al ser un entorno Linux, necesito ejecutar la siguiente secuencia de comandos:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-$(lsb_release -cs)-prod $(lsb_release -cs) main" > /etc/apt/sources.list.d/dotnetdev.list'
sudo apt-get update
sudo apt-get install azure-functions-core-tools
sudo apt-get install python3-venv

La versión de Python es la versión 3.6 y, para asegurar la creación de entornos virtuales, he ejecutado el comando de instalación del paquete python3-venv.

Para asegurar que el paquete se ha instalado correctamente, podemos ejecutar en la línea de comandos el comando func -h; el resultado, es la visualización de la ayuda del comando.

Creación del proyecto

La creación de un proyecto consiste en la creación de una estructura de directorios con los elementos necesarios para poder trabajar. El comando de creación del proyecto es el
siguiente:

func init MyFunctionProj

Una vez ejecutado, se tendrá que seleccionar el lenguaje del proyecto, en nuestro caso, opción 3 Python y se creará un directorio con nombre MyFunctionProj con los elementos necesarios para poder trabajar. El contenido de la carpeta será el siguiente:

  • host.json.- Fichero JSON de configuración de extensiones y confuguración.
  • local.settings.json.- Fichero con la configuración de acceso a los servicios Azure.
  • requirements.txt.- Fichero con las dependencias de Python.

Creación de una función

Para realizar la creación de una función, desde la línea de comandos, nos ubicaremos en la carpeta raíz del proyecto; y, una vez allí, ejecutamos el siguiente comando:

func new

El comando nos obliga a seleccionar una plantilla de función entre las nueve existentes las cuáles son:

Select a template:
1. Azure Blob Storage trigger
2. Azure Cosmos DB trigger
3. Azure Event Grid trigger
4. Azure Event Hub trigger
5. HTTP trigger
6. Azure Queue Storage trigger
7. Azure Service Bus Queue trigger
8. Azure Service Bus Topic trigger
9. Timer trigger
Choose option:

Llegado a este punto es necesario realizar una parada para definir el significado del concepto de trigger. Un trigger es aquel elemento que permite desencadenar el funcionamiento de una función; un ejemplo de trigger, es una petición HTTP, es decir, cuando se realiza una petición HTTP se inicia la ejecución de una función; otro tipo de trigger puede ser Blob Storage Trigger, es aquel desencadenador que ejecuta una función por la existencia de un fichero en un blob determinado. De los posibles desencadenadores tenemos los siguiente tipos: HTTP, Cosmos DB, Blob Storage, un Timer, Event Grid, Event Hub, Service Bus Queue, Service Bus topic y Queue Storage. Una vez seleccionado el tipo, se deberá de informar del nombre de la función.

Los ejemplos que describiré son dos funciones:

  1. FunctionBase.- Función sencilla con desencadenador HTTP
  2. FunctionStore.- Función con desencadenador HTTP, un Blob Storage de entrada y otro de salida para realizar lecturas y escrituras en un Store de Azure.

La creación de cada función realiza la creación de un directorio con dos ficheros los cuáles son los siguientes:

  • __init__.py.- Fichero con el código Python de la función.
  • function.json.- Fichero con la configuración de la función: definición del desencadenador binding, route, nombre de la función a ejecutar en el fichero __init__.py

La estructura del proyecto con las dos funciones y los ficheros de configuración tiene un aspecto como el siguiente:

__app__
| - FunctionBase
| | - __init__.py
| | - function.json
| - FunctionStore
| | - __init__.py
| | - function.json
| - host.json
| - local.settings.json
| - requirements.txt
tests

Ficheros de configuración

  • host.json.- Fichero con la configuración de las funciones. El contenido es el siguiente:
{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[1.*, 2.0.0)"
  }
}
  • local.settings.json.- Fichero con las conexiones a los servicios de Azure.
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "AzureWebJobsStorage": "<CONNECTION_STRING>",
    "FUNCTIONS_EXTENSION_VERSION": "~2",
    "APPINSIGHTS_INSTRUMENTATIONKEY": "a66ab777-1fa1-222c-3333-4e44d4c4444f"
  },
  "ConnectionStrings": {}
}
  • requirements.txt.- Definición de las dependencias de las librerías Python.
azure-functions
azure-functions-worker
azure-storage-blob
azure-cosmos
azure-storage
azure-storage-blob
pillow>=6.2.0

Para ejecutar el entorno virtual local desde la carpeta del proyecto en una consola, ejecutamos la siguiente secuencia de comandos:

virtualenv .venv -p python3
source .venv/bin/activate
pip install -r requirements.txt

2.- Función Functionbase

La función FunctionBase es una función sencilla que realiza la definición de un desencadenador de tipo HTTP y, su salida, es una respuesta HTTP. Realiza la lectura de petición HTTP y responde en función de los parámetros de entrada.

El contenido del fichero function.json es el siguiente:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}

Del snippet anterior hay que destacar lo siguiente:

  • El elemento “scriptFile” define el fichero con el código de la función.
  • El elemento “type” define el tipo de elemento, en nuestro caso, trigger de tipo HTTP o HTTP.
  • El elemento “direction” determina si es de entrada o de salida.
  • El elemento “name” identifica la referencia en el código.
  • El elemento “methods” identifica los métodos HTTP que define la función, en nuestro caso, GET o POST.

El contenido del fichero __init__.py es el siguiente:

import logging
import azure.functions as func
from datetime import datetime
def main(req: func.HttpRequest) -> func.HttpResponse:
  """
  + curl -v -w '\n' -d '{"name":"pp"}' -H 'DateData: 2019/11/26' -H 'Content-Type: application/json' -X POST http://localhost:7071/api/FunctionBase
  + curl -v -w '\n' -d '{"name":"pp"}' -H 'DateData: 2019/11/26' -H 'Content-Type: application/json' -X POST https://<URL-AZURE>.net/api/FunctionBase?code=<FUNCTION_KEY>
  """
  logging.info('Python HTTP trigger function processed a request.')
  datetime_object = datetime.strptime(req.headers.get('DateData'), '%Y/%m/%d')
  name = req.params.get('name')
  if not name:
    try:
      req_body = req.get_json()
    except ValueError:
      pass
  else:
    name = req_body.get('name')
  if name:
    return func.HttpResponse('{ "test": "' + name + '", "date": "' + str(datetime_object) + '"}')
  else:
    return func.HttpResponse(
      "Please pass a name on the query string or in the request body", status_code=400)

El código define una función main que recibe la referencia de la petición HTTP, realiza un procesamiento conforme a los parámetros de entrada y, por último, crea la respuesta.

3.- Función  Functionstore

La función FunctioStore realiza el copiado de un fichero en un Store de Azure cuyo nombre es pasado en una petición HTTP.

El contenido del fichero function.json es el siguiente:

{
  "disabled": false,
  "scriptFile": "__init__.py",
  "bindings": [
  {
    "authLevel": "function",
    "type": "httpTrigger",
    "direction": "in",
    "name": "request",
    "methods": [
      "get",
      "post"
    ],
    "route": "FunctionStore/{name:alpha?}"
  },
  {
    "name": "inputblob",
    "type": "blob",
    "path": "staging/{name}.png",
    "connection": "AzureWebJobsStorage",
    "direction": "in"
  },
  {
    "name": "blobout",
    "type": "blob",
    "direction": "out",
    "path": "staging/{name}-copy.txt",
    "connection": "AzureWebJobsStorage"
  },
  {
    "type": "http",
    "direction": "out",
    "name": "$return"
  }
 ]
}

En el código anterior y partiendo de la primera función, se añaden los dos blob de lectura y escritura, respectivamente, inputblob y outputblob. El elemento “path”, corresponde con el path de la ubicación de los ficheros; el elemento “type”, corresponde con el tipo blob; el elemento “connection”, corresponde con la referencia a la conexión del blob; y, un detalle importante es el elemento “route”, define el nombre del fichero pasado en la URL de la petición y dicho parámetro es usado en los blob de entrada y salida para referenciar el nombre del fichero de lectura y  de escritura.

El contenido del fichero con el código Python es el siguiente:

import logging
import azure.functions as func
from datetime import datetime
def main(request: func.HttpRequest, inputblob: func.InputStream, blobout: func.Out[func.InputStream], context: func.Context) -> func.HttpResponse:
  """
  curl -v -w '\n' -H 'DateData: 2019/11/26' -d '{ "param1": "value1", "param2": "value2" }' -X GET http://localhost:7071/api/FunctionStore/watermark?name=11
  """
  logging.info('Python HTTP trigger function processed a request.')
  logging.info(f'context.function_directory={context.function_directory}.')
  logging.info(f'context.function_name={context.function_name}.')
  logging.info(f'context.invocation_id={context.invocation_id}.')
  logging.info(f"Params: {request.params}")
  logging.info(f"Route Params: {request.route_params}")
  logging.info(f"Body: {request.get_body()}")
  logging.info(f"Headers: {request.headers}")
  logging.info(f"Headers: {request.headers.get('DateData')}")
  datetime_object = datetime.strptime(request.headers.get('DateData'), '%Y/%m/%d')
  logging.info(f"Fecha: {datetime_object}")
  name = datetime_object
  if not name:
    try:
      req_body = request.get_json()
    except ValueError:
      pass
  else:
    name = req_body.get('name')
  blobout.set(inputblob)
  if name:
    return func.HttpResponse(f"Hello {name}!")
  else:
    return func.HttpResponse(
      "Please pass a name on the query string or in the request body",status_code=400)

Del código anterior, destaca la siguiente línea: blobout.set(inputblob) ; ésta línea, realiza la lectura del fichero definido en inputblob y su copiado en blobout. El resto del código es la visualización de los parámetros de la petición HTTP y su tratamiento.

4.- Ejecución de las funciones en local

Para ejecutar las funciones en un entorno local es necesario ejecutar desde la carpeta del proyecto el siguiente comando:

func host start

Para ejecutar las funciones ejecutamos el comando curl desde la línea de comandos. Respectivamente, para la función base y Store, ejecutamos los siguientes comandos:

curl -v -w '\n' -d '{"name":"pp"}' -H 'DateData: 2019/11/26' -H 'Content-Type: application/json' -X POST http://localhost:7071/api/FunctionBase
curl -v -w '\n' -H 'DateData: 2019/11/26' -d '{ "param1": "value1", "param2": "value2" }' -X GET http://localhost:7071/api/FunctionStore/watermark?name=11

5.- Publicación en Azure

Para realizar el despliegue, es necesario crear una función en Azure. El código Python será el código del proyecto. El proceso de creación es sencillo desde el portal de Azure,  simplemente, hay que seleccionar el grupo de recurso, lenguaje, nombre,…

Una vez que la tengamos creada, desde la línea de comando realizaremos la operación de login con el comando “az login” y, una vez logueado, ejecutamos el comando de despliegue el cuál es el siguiente:func azure functionapp publish <APP_NAME>. Para nuestro caso, si la Function App tiene nombre MyFunctionProj el comando es el siguiente:

func azure functionapp publish MyFunctionProj

Para realizar las pruebas, se puede utilizar el comando curl, Postman o el propio interfaz de pruebas que proporciona Azure.

En la siguiente imagen, realizo un resumen de la entrada de los apartados anteriores representados como un sketchnoting.

 

Si el lector está interesado en el código, lo puede encontrar en el siguiente enlace.

Inyección de dependencias en programación funcional III. Mónada Reader

Llegamos a la la última entrada de la sería de inyección de dependencias con la entrada, Inyección de dependencias en programación funcional III. Mónada Reader. El objetivo de la misma es mostrar al lector cómo se realiza la inyección de dependencias con la mónada Reader en lenguaje Scala. Para el lector interesado, las entradas de la serie son las siguientes:

La diferencia conceptual respecto a las otras dos es el uso de la mónada Reader. La mónada Reader es aquella mónada la cual puede leer un determinado componente; en dicho  componente, es donde definimos los elementos con las referencias de las funciones a inyectar. Así, necesitamos definir un elemento, en nuestro caso una case class, con las referencias a las funciones las cuáles están definidas en los componentes. Por otro lado, el servicio de negocio lo definimos a partir de un trait con un constructor de tipos.

Desde un punto de vista gráfico, la vista estática de los componentes queda definida como sigue:

Los tipos utilizados son los siguientes:

import cats.data.Reader
import cats.syntax.either._
import scala.language.higherKinds
object typesEjem3{
  type MensajeError = String
  type GetComponent1 = (String) => Either[MensajeError, String]
  type GetComponent2 = (Int) => Either[MensajeError, Int]
  type ResponseService = Either[MensajeError, String]
  type ParameterString = String
  type ParameterInt = Int
  type ServiceOperation[A] = Reader[ServiceContext, A]
  case class ServiceContext( funcComponent1: GetComponent1, funcComponent2: GetComponent2 )
}

La definición de los componentes de negocio del ejemplo son los representados por el objeto Component1Ejem3 y Component2Ejem3. El snippet del código de los componentes es el siguiente:

object Component1Ejem3{
  import typesEjem3._
  val response1: MensajeError = "Error en Response1"
  val doSomething: GetComponent1 = (elem: String) => {
    elem.length match {
      case lengthElem: Int if lengthElem > 0 => (elem + " modificado").asRight
      case _ => response1.asLeft
    }
  }
}
object Component2Ejem3{
  import typesEjem3._
  val response2: MensajeError = "Error en Response2"
  val doSomething: GetComponent2 = (num: Int) => {
    num match {
      case elem: Int if elem > 0 => elem.asRight
      case _ => response2.asLeft
    }
  }
}

La definición del servicio de negocio se realiza con un type class empleando un trait Service3 y el objeto ServiceImpl. Para el lector interesado en conocer lo que es un Type Class en los siguientes enlaces describo cómo se define y describe dicho patrón. Los enlaces son los siguientes:

El snippet del código del servicio es el siguiente:

trait Service3[ F[_] ]{
  def doBusiness(msg: typesEjem3.ParameterString): F[ Either[typesEjem3.MensajeError, String] ]
}
object ServiceImpl extends Service3[typesEjem3.ServiceOperation]{
  override def doBusiness(msg: typesEjem3.ParameterString): typesEjem3.ServiceOperation[Either[typesEjem3.MensajeError, String]] = Reader{ ctx =>
    for{
      response1 <- ctx.funcComponent1(msg).right
      response2 <- ctx.funcComponent2(msg.length).right
    }yield{
      response1 + "-" + response2
    }
  }
}

Como se muestra en el snippet anterior la función doBusiness del objeto ServiceImpl define la funcionalidad del servicio y es donde se utiliza la mónada Reader. La Mónada Reader se define de la siguiente manera : Reader[ServiceContext, A]; siendo la entrada de tipo ServiceContext; y, como salida, el tipo A el cual en nuestro caso es de tipo Either. Analizando la función, el objeto de entrada es de tipo ServiceContext con las referencias a los componentes que se inyectan y, como resultado, se retorna un elemento de tipo Either.

La aplicación que usa los anteriores elementos es la siguiente:

object Ejem3DependencyInyector extends App{
  import typesEjem3._
  def ejemplo1(): Unit = {
    val context = ServiceContext(Component1Ejem3.doSomething, Component2Ejem3.doSomething)
    val message1 = "Mensaje de prueba"
    ServiceImpl.doBusiness(message1).run(context) match {
      case Right(msg) => println(s"Test1=${msg}")
      case Left(error) => println(error)
    }
    println
  }
  ejemplo1()
}

En la aplicación anterior, se muestra cómo usar un servicio con una mónada Reader: lo primero, es definir una clase ServiceContext con las funciones de los componentes; segunda, crear e invocar la clase con la mónada usando la función run; y, para finalizar, tratar el resultado con un pattern matching.

La salida por consola es la siguiente:

Test1=Mensaje de prueba modificado-17

La definición de los test del servicio de negocio descrito en el ejemplo es el siguiente:

import cats.syntax.all._
import es.ams.dependencyinyector.typesEjem3.{ GetComponent1, GetComponent2, ServiceContext} //
import org.scalatest.{Matchers, WordSpec}
class Ejem3DependecyInyectorTest extends WordSpec with Matchers {
  "Example Mock" should {
    "Example OK" in {
      val context = ServiceContext(Component1Ejem3.doSomething, Component2Ejem3.doSomething)
      val msg: String = "prueba"
      val result: String = ServiceImpl.doBusiness(msg).run(context) match {
        case Right(msg) => { println(msg); msg}
        case Left(error) => error
      }
      result shouldBe(msg + " modificado-6")
    }
    "Example OK: mock component1" in {
      val funcGetResponse1Mock: GetComponent1 = (num: String) => "mock".asRight
      val context = ServiceContext(funcGetResponse1Mock, Component2Ejem3.doSomething)
      val msg: String = "prueba"
      val result: String = ServiceImpl.doBusiness(msg).run(context) match {
        case Right(msg) => { println(msg); msg}
        case Left(error) => error
      }
      assert(result.length > 0)
      assert(result.equals("mock-6"))
    }
    "Example OK: mock component2" in {
      val funcComponent2: GetComponent2 = (num: Int) => 0.asRight
      val context = ServiceContext(Component1Ejem3.doSomething,funcComponent2)
      val msg: String = "prueba"
      val result: String = ServiceImpl.doBusiness(msg).run(context) match {
        case Right(msg) => { println(msg); msg}
        case Left(error) => error
      }
      assert(result.length > 0)
    }
    "Example OK: mock component1 and mock component2" in {
      val funcGetResponse1Mock: GetComponent1 = (num: String) => "mock".asRight
      val funcGetResponse2Mock: GetComponent2 = (num: Int) => 0.asRight
      val context = ServiceContext(funcGetResponse1Mock, funcGetResponse2Mock)
      val msg: String = "prueba"
      val result: String = ServiceImpl.doBusiness(msg).run(context) match {
        case Right(msg) => { println(msg); msg}
        case Left(error) => error
      }
      assert(result.length > 0)
      assert(result.equals("mock-0"))
    }
  }
}

La inyección de dependencias desde un punto de vista funcional sigue la misma filosofía que la inyección de dependencias de objetos. La primera consecuencia es la desaparición de la utilización de framework de Mock necesarios en otros paradigmas como el utilizado en los lenguajes Java o Python. La utilización del paradigma funcional permite la composición de elementos más intuitiva aunque, evidentemente, la curva de aprendizaje es mayor.

Inyección de dependencias en programación funcional II

En la entrada anterior, Inyección de dependencias en programación funcional I, realicé la descripción de cómo se realizaba la inyección de funciones en programación funcional en lenguaje Scala; en la presente entrada, Inyección de dependencias en programación funcional II, modularizaré el código existente en la primera entrada organizando el código con una perspectiva orientada a objetos sin perder el aspecto funcional.

La vista estática del problema es la definida en el diagrama de clases de la siguiente imagen:

 

Los tipos utilizados en el ejemplo son los siguientes:

import cats.syntax.either._
object typesEjem2{
  type MensajeError = String
  type GetComponent1 = (String) => Either[MensajeError, String]
  type GetComponent2 = (Int) => Either[MensajeError, Int]
  type ResponseService = Either[MensajeError, String]
  type ParameterString = String
  type ParameterInt = Int
  type BusinessService = (GetComponent1, GetComponent2) => ParameterString => ResponseService
}

La definición de los componentes de negocio del ejemplo son los representados por los objetos Component1 y Component2. Respecto al ejemplo de la entrada anterior, se han definido las funciones dentro de un objeto con lo cual modularizamos la funcionalidad. El snippet del código de los componentes es el siguiente:

object Component1{
  import typesEjem2._
  val response1: MensajeError = "Error en Response1"
  val doSomething: GetComponent1 = (elem: String) => {
    elem.length match {
      case lengthElem: Int if lengthElem > 0 => (elem + " modificado").asRight
      case _ => response1.asLeft
    }
  }
}
object Component2{
  import typesEjem2._
  val response2: MensajeError = "Error en Response2"
  val doSomething: GetComponent2 = (num: Int) => {
    num match {
      case elem: Int if elem > 0 => elem.asRight
      case _ => response2.asLeft
    }
  }
}

La definición del servicio de negocio del ejemplo es el definido por el objeto Service. La estrategia de modularización es la misma que con los componentes. El snippet del código del servicio es el siguiente:

object Service{
  import typesEjem2._
  val doBusinessActivity: BusinessService = (objComp1, objComp2) => (msg) => {
    for {
      respon1 <- objComp1 (msg)
      respon2 <- objComp2(msg.length)
    } yield {
      respon1 + "-" + respon2
    }
  }
}

La aplicación de ejemplo que usa los anteriores elementos es la siguiente:

object Ejem2DependencyInyectorApp extends App {
  def ejemplo1(): Unit = {
    val message1 = "Mensaje de prueba"
    Service.doBusinessActivity(Component1.doSomething, Component2.doSomething)(message1) match {
      case Right(msg) => println(s"Test1=${msg}")
      case Left(error) => println(error)
    }
    val message2 = ""
    Service.doBusinessActivity(Component1.doSomething, Component2.doSomething)(message2) match {
      case Right(msg) => println(s"Test2=${msg}")
      case Left(error) => println(error)
    }
  }
  ejemplo1()
}

La salida por consola es la siguiente:

Test1=Mensaje de prueba modificado-17
Error en Response1

La definición de los test del servicio de negocio descrito en el ejemplo es el siguiente:

import org.scalatest.{Matchers, WordSpec}
import es.ams.dependencyinyector.typesEjem2.{GetComponent1, GetComponent2}
import cats.syntax.all._
class Ejem2DependecyInyectorTest extends WordSpec with Matchers {
  "Example Mock" should {
    "Example OK" in {
      val msg: String = "prueba"
      val result: String = Service.doBusinessActivity(Component1.doSomething, Component2.doSomething)(msg) match {
        case Right(msg) => { println(msg); msg}
        case Left(error) => error
      }
      result shouldBe(msg + " modificado-6")
    }
  "Example OK: mock component1" in {
    val funcGetResponse1Mock: GetComponent1 = (num: String) => "mock".asRight
    val msg: String = "prueba"
    val result: String = Service.doBusinessActivity(funcGetResponse1Mock, Component2.doSomething)(msg) match {
      case Right(msg) => { println(msg); msg}
      case Left(error) => error
    }
    assert(result.length > 0)
    assert(result.equals("mock-6"))
  }
  "Example OK: mock component2" in {
    val funcComponent2: GetComponent2 = (num: Int) => 0.asRight
    val msg: String = "prueba"
    val result: String = Service.doBusinessActivity(Component1.doSomething, funcComponent2)(msg) match {
      case Right(msg) => { println(msg); msg}
      case Left(error) => error
    }
    assert(result.length > 0)
  }
  "Example OK: mock component1 and mock component2" in {
    val funcGetResponse1Mock: GetComponent1 = (num: String) => "mock".asRight
    val funcGetResponse2Mock: GetComponent2 = (num: Int) => 0.asRight
    val msg: String = "prueba"
    val result: String =Service.doBusinessActivity(funcGetResponse1Mock, funcGetResponse2Mock)(msg) match {
      case Right(msg) => { println(msg); msg}
      case Left(error) => error
    }
    assert(result.length > 0)
    assert(result.equals("mock-0"))
    }
  }
}

En esta entrada he realizado la modularización del código definido en la entrada, Inyección de dependencias en programación funcional I; en la siguiente entrada, subiré el nivel de abstracción y describiré el mismo problema utilizando la mónada Reader.

Inyección de dependencias en programación funcional I

La inyección de dependencias es un patrón que en otros paradigmas y lenguajes es un patrón muy utilizado; por ejemplo en Java, el framework Spring, se basa en el patrón de inyección de dependencias de objetos. En la programación funcional, la inyección de dependencias se realiza inyectando funciones, no objetos. En la presente entrada, Inyección de dependencias en programación funcional I, describiré la forma de inyectar funciones en lenguja Scala.

Supongamos que tenemos dos funciones que implementan la siguiente funcionalidad: la primera, dada un valor de tipo String de entrada, realiza la transformación de dicho parámetro concatenándole el valor “modificado”; la segunda función, dado un valor entero de entrada si es mayor a cero retorna dicho valor; en otro caso para las dos funciones, retorna un mensaje de error. El valor de retorno es un contenedor binario de tipo Either.

Por otro lado, definimos una función servicio que realiza una operación de negocio la cual utiliza las dos funciones anteriores descritas previamente. A esta función, para realizar su funcionalidad, necesitará que se le inyecten las funciones.

El objetivo del ejemplo es entender la inyección, no en definir una solución a un problema complejo.

Definición de tipos

Los tipos GetComponent1 y GetComponent2 definen las funciones básicas; el tipo Service, define la función de negocio; ResponseService, define el contenedor binario de respuesta del servicio; y, los tipos Parameter y MensajeError, otros tipos básicos necesarios.

En el siguiente snippet se define la definición en lenguaje Scala.

type MensajeError = String
type GetComponent1 = (String) => Either[MensajeError, String]
type GetComponent2 = (Int) => Either[MensajeError, Int]
type ResponseService = Either[MensajeError, String]
type Parameter = String
type Service = (GetComponent1, GetComponent2) => (Parameter) => (ResponseService)

Definición de componentes

Teniendo la definición de tipos, necesitamos la implementación de las funciones. La primera función, definida con el tipo GetComponent1, define una función cuyo parámetro de entrada es de tipo String, si el parámetro de entrada es un string cuya longitud es mayor a 0, retorna un elemento Right del tipo Either con la concatenación de la propia cadena de entrada y la palabra ” modificado”.

La segunda función, definida con el tipo GetComponent2, define una función cuyo parámetro de entrada es de tipo entero, si el valor de entrada es mayor a cero, retorna el mismo valor,en otro caso, retorno un elemento Right de tipo entero con el valor de entrada.

El código con la definición de las funciones es la siguiente:

val response1: MensajeError = "Error en Response1"
val funcGetResponse1: GetComponent1 = (elem: String) => {
  elem.length match {
    case lengthElem: Int if lengthElem > 0 => (elem + " modificado").asRight
    case _ => response1.asLeft
  }
}
val response2: MensajeError = "Error en Response2"
val funcGetResponse2: GetComponent2 = (num: Int) => {
  num match {
    case elem: Int if elem > 0 => elem.asRight
    case _ => response2.asLeft
  }
}

Definición del servicio

La definición de la función de servicio tiene un formado tipo Curry. Los primeros parámetros corresponde con las funciones de los tipo GetComponent1 y 2; el segundo grupo, corresponde con el parámetro que se empleará en las función; y, por último, se define la funcionalidad propiamente de negocio; en esta última parte, es donde se define la funcionalidad de negocio con las funciones inyectadas y los parámetros, así como, el resultado parcial, si fuera necesario, de las funciones.

El código con la definición de la función de servicio es la siguiente:

val funcService: Service = (getComponent1, getComponent2) => (msg) => {
  for {
    respon1 <- getComponent1(msg)
    respon2 <- getComponent2(msg.length)
  } yield {
    respon1 + "-" + respon2
  }
}

La función del servicio, funcService, recibe por parámetro aquellas funciones que le son necesarias, es decir, se le inyecta los elementos necesarios para realizar su operativa.

Dados las descripciones de las funciones de los apartados anteriores, una ejemplo básico de uso de la función servicio con la inyección de funciones es el siguiente:

object Ejem1DependecyInyectorApp extends App {
  import Ejem1DependecyInyector._
  def ejemplo1(): Unit = {
    val message1 = "Mensaje de prueba"
    funcService(funcGetResponse1, funcGetResponse2)(message1) match {
      case Right(msg) => println(s"Test1=${msg}")
      case Left(error) => println(error)
    }
    val message2 = ""
    funcService(funcGetResponse1, funcGetResponse2)(message2) match {
      case Right(msg) => println(s"Test2=${msg}")
      case Left(error) => println(error)
    }
  }
  ejemplo1()
}

La salida por consola es la siguiente:

Test1=Mensaje de prueba modificado-17
Error en Response1

Test

Una tarea fundamental en el desarrollo del software es la realización de pruebas unitarias de aquellos componentes realizados. En nuestro caso, las pruebas unitarias de la función servicio dependerán de los resultado de las funciones inyectadas;y, para sus pruebas, es necesario moquear aquellas funciones inyectadas. En programación función con el patrón que presento, las pruebas se simplifican porque no hay que utilizar un framework específico, simplemente, necesitamos definir una función con un determinado valor la cual se inyecta a la función servicio.

Los test unitarios de la función servicio presentada son los siguientes:

class Ejem1DependecyInyectorTest extends WordSpec with Matchers {
  "Example Mock" should {
    "Example OK" in {
      val msg: String = "prueba"
      val result: String = funcService(funcGetResponse1, funcGetResponse2)(msg) match {
         case Right(msg) => { println(msg); msg}
         case Left(error) => error
      }
      result shouldBe(msg + " modificado-6")
    }
    "Example OK: mock component1" in {
       val funcGetResponse2Mock: GetComponent2 = (num: Int) => 0.asRight
       val msg: String = "prueba"
       val result: String = funcService(funcGetResponse1, funcGetResponse2Mock )(msg) match {
          case Right(msg) => { println(msg); msg}
          case Left(error) => error
       }
       assert(result.length > 0)
    }
    "Example OK: mock component2" in {
       val funcGetResponse1Mock: GetComponent1 = (num: String) => "mock".asRight
       val msg: String = "prueba"
       val result: String = funcService(funcGetResponse1Mock, funcGetResponse2 )(msg) match {
          case Right(msg) => { println(msg); msg}
          case Left(error) => error
       }
       assert(result.length > 0)
       assert(result.equals("mock-6"))
    }
    "Example OK: mock component1 and mock component2" in {
       val funcGetResponse1Mock: GetComponent1 = (num: String) => "mock".asRight
       val funcGetResponse2Mock: GetComponent2 = (num: Int) => 0.asRight
       val msg: String = "prueba"
       val result: String = funcService(funcGetResponse1Mock, funcGetResponse2Mock )(msg) match {
          case Right(msg) => { println(msg); msg}
          case Left(error) => error
       }
       assert(result.length > 0)
       assert(result.equals("mock-0"))
    }
  }
}

En las próximas entregas, continuaré profundizando en la inyección de dependencias.

Patrón Traverse en cats

En la entrada anterior, Patrón Fodable en Cats, realicé una descripción de cómo se realizaban morfismos con tipos de datos algebraicos (ADT) utilizando la implementación del tipo Foldable de la librería cats. En la presente entrada, Patrón Traverse en Cats, me centraré en el tipo Traverse.

El tipo Traverse tiene dos funciones: traverse y sequence; en los siguientes apartados, realizaré la descripción de cada una.

1.- Traverse

El tipo Traverse define la función traverse la cual permite realizar lo siguiente: dado un tipo de entrada y dada una función de transformación; la función traverse permite: la iteración sobre el tipo de entrada, aplica la función a cada elemento de la entrada, acumular el resultado y retornar su resultado. Un ejemplo de una definición de función traverse puede ser el siguiente:

import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._
import cats.syntax.applicative._
import cats.syntax.apply._
def getFutureTest(msg: String): Future[Int] = 
   Future{msg.length * 10 }
def myTraverse[A,B](list: List[A])(f: A => Future[B]): Future[List[B]] =
  list.foldLeft(Future(List.empty[B])){ (acc, elem) => {
      val resultElem = f(elem)
      for{
         acc <- acc
         elem <- resultElem
      }yield{ acc :+ elem }
    }
  }
val listExample1 = List ("a", "aa", "aaa")
val resultExample1 = myTraverse(listExample1)(getFutureTest)
println(s"myTraverse(List ('a', 'aa', 'aaa'))-->${Await.result( resultExample1, 5.seconds )}")

La salida por consola es la siguiente:

myTraverse(List ('a', 'aa', 'aaa'))-->List(10, 20, 30)

El snippet anterior define lo siguiente: getFutureTest, función que retorna un Future de enteros que retorna la longitud del string pasado por parámetro multiplicado por 10; myTraverse, función traverse implementado con foldLeft la cual opera con una lista y una función f que retorna un Futuro del tipo B a partir del tipo A; listExample1, una lista de pruebas; y, por último, el mensaje con la función traverse y su visualización por pantalla.

1.1.- Traverse con Applicative

La función traverse podemos simplificarla utilizando tipos que cumplan el patrón Applicative la cual contiene operaciones del patrón Semigroupal como la función mapN; así, la función traverse, se puede redefinir de la siguiente manera:

def myTraverse2[F[_]: Applicative, A,B](list: List[A])(f: A => F[B]): F[List[B]] =
  list.foldLeft( List.empty[B].pure[F] ){
      (acc, elem) => (acc, f(elem)).mapN(_ :+ _)
  }
import cats.instances.option._
def process(list: List[Int]) = {
   myTraverse2(list)(n => if(n%2==0) Some(n) else None)
}
println(s"--Ejemplo3--")
println(s"process(List(2,4,6))==>>${process(List(2,4,6))}")
println(s"process(List(1,2,3))==>>${process(List(1,2,3))}")

La salida por consola es la siguiente:

process(List(2,4,6))==>>Some(List(2, 4, 6))
process(List(1,2,3))==>>None

1.2.- Traverse con Validated

El siguiente ejemplo, permite la validación de los elementos de una lista en función de un criterio: los elementos pares son válidos y, los impares, son inválidos. El snippet con la solución es la siguiente:

import cats.data.Validated
import cats.instances.list._
type ErrorOn[A] = Validated[ List[String] ,A]
def myTraverse2[F[_]: Applicative, A,B](list: List[A])(f: A => F[B]): F[List[B]] =
   list.foldLeft( List.empty[B].pure[F] ){
      (acc, elem) => (acc, f(elem)).mapN(_ :+ _)
    }
def process(list: List[Int]): ErrorOn[List[Int]] = {
   myTraverse2(list){ n =>
     if(n%2==0){
        Validated.valid(n)
     }else{
        Validated.invalid(List(s"$n no está incluido."))
     }
   }
}
println(s"process(List(2,4,6))==>>${process(List(2,4,6))}")
println(s"process(List(1,2,3))==>>${process(List(1,2,3))}")
println(s"process(List(2,4,5,6))==>>${process(List(2,4,5,6))}")

La salida por consola es la siguiente:

process(List(2,4,6))==>>Valid(List(2, 4, 6))
process(List(1,2,3))==>>Invalid(List(1 no está incluido., 3 no está incluido.))
process(List(2,4,5,6))==>>Invalid(List(5 no está incluido.))

1.3.- Función traverse con el tipo traverse

En los apartados anteriores, me he centrado en mostrar ejemplos de la función traverse con una implementación propia. En el siguiente ejemplo, muestro un ejemplo con la función traverse del tipo Traverse. La funcionalidad del ejemplo consiste en procesar una lista de futuros, el snippet es el siguiente:

import cats.Traverse
import cats.instances.all._
val listExample1 = List ("a", "aa", "aaa")
def getFutureTest(msg: String): Future[Int] = 
  Future{msg.length * 10}
val result1:Future[List[Int]] = Traverse[List].traverse(listExample1)(getFutureTest)
println(s"Traverse1=${Await.result( result1, 2.seconds )}")
val listExampleSequence1 = List( Future(1), Future(2), Future(3))
val result2: Future[List[Int]] = Traverse[List].sequence(listExampleSequence1)
println(s"Sequence1=${Await.result( result2, 2.seconds )}")

La salida por consola es la siguiente:

Traverse1=List(10, 20, 30)
Sequence1=List(1, 2, 3)

2.- Sequence

Por otro lado, el tipo Traverse define la función sequence la cual permite recorrer los elementos de un tipo de entrada y realizar los cambios de tipos. Un ejemplo de una función sequence puede ser la siguiente:

import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._
import cats.syntax.applicative._
import cats.syntax.apply._
def getFutureTest(msg: String): Future[Int] = 
    Future{msg.length * 10 }
def mySequence[B](list:List[Future[B]]): Future[List[B]] =
    myTraverse(list)(identity)
val listExampleSequence1 = List( getFutureTest("a"), getFutureTest("aa"), getFutureTest("aaa"))
val resultExample2 = mySequence(listExampleSequence1)
println(s"myTraverse(List (Future('a'), Future('aa'), Future('aaa'))-->${Await.result( resultExample2, 5.seconds )}")

La salida por consola es la siguiente:

myTraverse(List (Future('a'), Future('aa'), Future('aaa'))-->List(10, 20, 30)

El snippet anterir define lo siguiente: getFutureTest, función que retorna un Future de enteros que retorna la longitud del string pasado por parámetro multiplicado por 10; mySequence,  función que emplea la función traverse para realizar la transformación; listExampleSequence1, lista con los datos de prueba; y, por último, el mensaje con la función sequence y su visualización.

La funcionalidad del ejemplo anterior implemantado con la función sequence de Traverse queda descrito en el siguiente enjemplo:

import cats.Traverse
import cats.instances.all._
val listExampleSequence1 = List( getFutureTest("a"), getFutureTest("aa"), getFutureTest("aaa"))
val result1:Future[List[Int]] = Traverse[List].sequence(listExampleSequence1)
println(s"myTraverse(List (Future('a'), Future('aa'), Future('aaa'))-->${Await.result( result1, 5.seconds )}")

La salida por consola es la siguiente:

myTraverse(List (Future('a'), Future('aa'), Future('aaa'))-->List(10, 20, 30)

3.- Definición formal de Traverse

La definición formal del trait con la funcionalidad Traverse es la siguiente:

package cats
trait Traverse[F[_]] {
  def traverse[G[_]: Applicative, A, B] (inputs: F[A])(func: A => G[B]): G[F[B]]
  def sequence[G[_]: Applicative, B] (inputs: F[G[B]]): G[F[B]] = 
traverse(inputs)(identity)
}

Para finalizar la entrada y como conclusión final, el tipo Traverse es un patrón conseguido y comprensible a partir del patrón Foldable y la función fold. Traverse permite realizar la iteración y operación sobre colecciones de tipos y, además, realizar acumuladores de resultados de dichas colecciones.

Patrón Fodable en Cats

En la programación funcional uno de los conceptos base son los tipos de datos algebráicos (ADT) Los ADT son estructuras de datos basadas en las matemáticas cuyas operaciones se realizan mediante morfismos; y, los mosfirmos, se realizan mediante la función fold y sus derivados: foldRight y foldLeft. En la entrada de hoy, Patrón Foldable en Cats, realizaré la descripción de los morfismos utilizando la type class Foldable de la librería Cats.

1.- Definición de un ADT de tipo List

Un ADT es aquel tipo de dato con el que podemos realizar unas operaciones, como por ejemplo: la operación suma y producto; y, además, cumple unas propiedades  matemáticas como pueden ser la propiedad asociativa, distributiva, o bien, de identidad.

En el siguiente ejemplo, se muestra la definición del ADT de tipo MyList, el cual equivale al ADT de tipo List.

sealed trait MyList[+A]
case object Nil extends MyList[Nothing]
case class Cons[+A](elem: A, lista: MyList[A]) extends MyList[A]

La operación suma es aquella operación que, a nivel de programación, se corresponde con las relaciones de herencia entre la clase Cons y el objeto Nil con el trait MyList. La operación producto es aquella operación que, a nivel de programación, se corresponde con los parámetros de la clase Cons: elem y lista.

Una vez definido el ADT una de las formas de manipular dicha estructura es utilizando morfismos, función fold y sus derivados. La función fold equivale a la función foldRight. La definición de la función foldRight y foldLeft con el ADT MyList son los siguientes:

  • Morfismo foldRight para el ADT MyList.
def foldRight[A, B](lista: MyList[A], elem: B)(f: (A, B) => B): B = lista match {
  case Nil => elem
  case Cons(head, tail) => f(head, foldRight(tail, elem)(f))
}
  • Morfismo foldLeft para el ADT MyList.
@annotation.tailrec
def foldLeft[A, B](lista: MyList[A], elem: B)(f: (B, A) => B): B = lista match {
  case Nil => elem
  case Cons(head, tail) => foldLeft(tail, f(elem, head))(f)
}

fold, foldRight, foldLeft

En los siguientes apartados, realizaremos la descripción de ejemplos de uso de las operaciones fold con el type class que proporciona la librería Cats y con la librería estándar.

2.- Ejemplos de morfismos con el tipo List

En el presente apartado, realizaré la descripción de ejemplos con la función fold del ADT List de la librería estándar.

  • Ejemplos básicos de morfismo foldRight.- Definición de una construcción de una lista y suma de sus elementos con una lista de tipos de enteros y foldRight.
println(s"1.- foldRight=${ List(1,2,3).foldRight(List.empty[Int])( (e, acc) => e :: acc) }")
println(s"2.- foldRight=${ List(1,2,3).foldRight(0)( (e, acc) => e + acc ) }")
println(s"Suma con foldRight=${List(1, 2, 3, 4).foldRight(0)(_ + _)}")

La salida por consola es la siguiente:

1.- foldRight=List(1, 2, 3)
2.- foldRight=6
Suma con foldRight=10
  • Ejemplos básicos de morfismo foldLeft.- Definición de una construcción de una lista y suma de sus elementos con una lista de tipos de enteros y foldLeft.
println(s"1.- foldLeft=${ List(1,2,3).foldLeft(List.empty[Int])((acc, e) => e :: acc) }")
println(s"2.- foldLeft=${ List(1,2,3).foldLeft(0)( (acc, e) => acc + e ) }")

La salida por consola es la siguiente:

1.- foldLeft=List(3, 2, 1)
2.- foldLeft=6
  • FoldRight y el tipo Numeric.- Definición de una función suma empleando una lista de enteros y el tipo Numeric.
import scala.math.Numeric
def sumaConNumeric[A](list:List[A])(implicit numeric: Numeric[A]): A =
list.foldRight(numeric.zero)(numeric.plus)
println(s"Suma con Numeric=${sumaConNumeric(List(1, 2, 3, 4))}")
println

La salida por consola es la siguiente:

Suma con Numeric=10
  • FoldRight y monoides.- Definición de la operación suma sobre una lista de enteros empleando monoides.
import cats.Monoid
import cats.instances.int._ // for Monoid
def sumaConMonoid[A](list:List[A])(implicit monoid: Monoid[A]): A =
list.foldRight(monoid.empty)(monoid.combine)
println(s"Suma con Momoid=${sumaConMonoid(List(1, 2, 3, 4))}")

La salida por consola es la siguiente:

Suma con Momoid=10
  • FoldRight y definición de filtros.- Definición de unos filtros sobre una lista de enteros
val elemFilter1: Int = 3
println(s"List(1, 2, 3, 4) existe el 3?=${List(1, 2, 3, 4).foldRight(false)( (elem, resul) => resul || elem.equals(elemFilter1))}")
val elemFilter2: Int = 5
println(s"List(1, 2, 3, 4) existe el 5?=${List(1, 2, 3, 4).foldRight(false)( (elem, resul) => resul || elem.equals(elemFilter2))}")
def myfilter[A](list: List[A])(func: A => Boolean): List[A] =
list.foldRight(List.empty[A]) { (item, accum) => if(func(item)) item :: accum else accum }
println(s"List(1, 2, 3, 4) filtra los pares.=${ myfilter(List(1, 2, 3, 4))(_%2==0) }")

La salida por consola es la siguiente:

List(1, 2, 3, 4) existe el 3?=true
List(1, 2, 3, 4) existe el 5?=false
List(1, 2, 3, 4) filtra los pares.=List(2, 4)
  • FoldRight y definición de función map.- Definición de una función map con foldRight.
def myMap[A,B](list: List[A])(f: A => B): List[B] = list.foldRight(List.empty[B])( (elem, result) => f(elem) :: result )
println(s"List(1, 2, 3) map to String=${List(1, 2, 3).foldRight(List.empty[String])( (elem, resul) => s"-${elem.toString}-" :: resul)}")
println(s"List(1, 2, 3) map to String=${ myMap(List(1, 2, 3))( (elem:Int) => s"*${elem.toString}*" ) }")
println

La salida pos consola es la siguiente:

List(1, 2, 3) map to String=List(-1-, -2-, -3-)
List(1, 2, 3) map to String=List(*1*, *2*, *3*)
  • FoldRight y definición de función flatMap.- Definición de una función flatMap con foldRight.
def flatMap[A, B](list: List[A])(func: A => List[B]): List[B] =
list.foldRight(List.empty[B]) { (item, accum) => func(item) ::: accum }
println(s"-->>${flatMap(List(1, 2, 3))(a => List(a, a * 10, a * 100))}")
println

La salida por consola es la siguiente:

-->>List(1, 10, 100, 2, 20, 200, 3, 30, 300)

3.- Ejemplos con Foldable de cats.

Para poder operar con el tipo Foldable es necesario, al menos, realizar la importación de los siguientes tipos:

import cats.Foldable
import cats.instances.all._
  • Ejemplo de Foldable con función foldLeft con los tipos List, Vector, Stream y Option.
println(s"Suma List(1, 2, 3)=${Foldable[List].foldLeft(List(1, 2, 3), 0)( _ + _ )}")
println(s"Suma Vector(1, 2, 3)=${Foldable[Vector].foldLeft(Vector(1, 2, 3), 0)( _ + _ )}")
println(s"Suma Stream(1, 2, 3)=${Foldable[Stream].foldLeft(Stream(1, 2, 3), 0)( _ + _ )}")
println(s"Suma Option(10) + 5=${Foldable[Option].foldLeft(Option(10), 0)( (acc, elem) => elem + 5 )}")

La salida por consola es la siguiente:

Suma List(1, 2, 3)=6
Suma Vector(1, 2, 3)=6
Suma Stream(1, 2, 3)=6
Suma Option(10) + 5=15
  • StackOverflowError con función foldRight.

Supongamos que queramos realizar la suma de una estructura de tipo Stream de 100000 elementos, la definición de la solución sería la siguiente:

val lista = (1 to 100000).toStream
println(s"Suma (1 to 100000).toStream->${ lista.foldRight(0L)(_ + _) }")

El resultado de la ejecución del snippet anterior es errónea porque se produce un desbordamiento de la pila del sistema y nos aparece en consola un error de tipo StackOverflowError. Una solución a este problema utilizando la función foldRight es utilizando la mónada Eval. Si el lector está interesado en la mónada Eval, pude ir a las siguientes enlace.El snippet es el siguiente:

import cats.Eval
val resultEvalStream = Foldable[Stream].foldRight(lista, Eval.now(0L)) ((num, acc) => acc.map( _ + num))
println(s"Suma (1 to 100000).toStream->${ resultEvalStream.value }")

La salida por consola es la siguiente:

Suma (1 to 100000).toStream->5000050000
  • Ejemplos de funciones básicos de Foldable con tipo Option.
println(s"Foldable[Option].nonEmpty(Option(42))=${Foldable[Option].nonEmpty(Option(42))}" )
println(s"Foldable[Option].isEmpty(Option(42))=${Foldable[Option].isEmpty(Option(42))}" )
println(s"Foldable[Option].size(Option(42))=${Foldable[Option].size(Option(42))}" )
println(s"Foldable[Option].get(Option(42))(0)=${Foldable[Option].get(Option(42))(0) }" )
println(s"Foldable[Option].find(Option(42))( elem => elem>30)=${Foldable[Option].find(Option(42))( elem => elem>30) }" )
println

La salida por consola es la siguiente:

Foldable[Option].nonEmpty(Option(42))=true
Foldable[Option].isEmpty(Option(42))=false
Foldable[Option].size(Option(42))=1
Foldable[Option].get(Option(42))(0)=Some(42)
Foldable[Option].find(Option(42))( elem => elem>30)=Some(42)
  • Ejemplos de funciones básicas de Foldable con tipo List.
println(s"Foldable[Option].nonEmpty(List(1, 2, 3)=${Foldable[List].nonEmpty(List(1, 2, 3))}" )
println(s"Foldable[Option].isEmpty(List(1, 2, 3))=${Foldable[List].isEmpty(List(1, 2, 3))}" )
println(s"Foldable[Option].size(List(1, 2, 3)=${Foldable[List].size(List(1, 2, 3))}" )
println(s"Foldable[Option].get(List(1, 2, 3)(0)=${Foldable[List].get(List(1, 2, 3))(0)}" )
println(s"Foldable[Option].get(List(1, 2, 3)(1)=${Foldable[List].get(List(1, 2, 3))(1)}" )
println(s"Foldable[Option].get(List(1, 2, 3)(4)=${Foldable[List].get(List(1, 2, 3))(4)}" )
println(s"Foldable[Option].find(List(1, 2, 3)(4)=${Foldable[List].find(List(1, 2, 3))( elem => (elem%2==0) )}" )
println(s"Foldable[Option].find(List(1, 2, 3)(4)=${Foldable[List].find(List(1, 2, 3))( elem => (elem%2!=0) )}" )
println

La salida por consola es la siguiente:

Foldable[Option].nonEmpty(List(1, 2, 3)=true
Foldable[Option].isEmpty(List(1, 2, 3))=false
Foldable[Option].size(List(1, 2, 3)=3
Foldable[Option].get(List(1, 2, 3)(0)=Some(1)
Foldable[Option].get(List(1, 2, 3)(1)=Some(2)
Foldable[Option].get(List(1, 2, 3)(4)=None
Foldable[Option].find(List(1, 2, 3)(4)=Some(2)
Foldable[Option].find(List(1, 2, 3)(4)=Some(1)
  • Ejemplo de Foldable con monoides. El tipo Foldable define operaciones con monoides.
import cats.instances.all._
println(s"Foldable[Option].combineAll(List(1, 2, 3))=${Foldable[List].combineAll(List(1, 2, 3))}" )
println

La salida por consola es la siguiente:

Foldable[Option].combineAll(List(1, 2, 3))=6
  • Ejemplo de Foldable con función map. El tipo Foldable define la función foldMap para definir funciones con la funcionalidad de fold y la función map.
import cats.instances.all._
println(s"Foldable[List].foldMap(List(1, 2, 3))( elem => elem + 20) =${Foldable[List].foldMap(List(1, 2, 3))( elem => elem + 20) }")
println

La salida por consola es la siguiente:

Foldable[List].foldMap(List(1, 2, 3))( elem => elem + 20) =66

El entendimiento y el uso de los  morfismos facilita y simplifica el código; y, la utilización de Foldable, permite una versatilidad para cualquier operación.

Scala Future con Ejemplos, continuación

En la entrada anterior, “Scala Future con Ejemplos”, realicé una descripción de cómo utilizar la entidad Future en Scala con ejemplos. En la presente entrada, “Scala Future con Ejemplos, continuación”, realizaré una ampliación de Future y, además, describiré ejemplos de utilización de Future con Actores.

El modelo de actores, segun wikepedia, es un modelo matemático de computación simultánea que trata a los actores como los primitivos universales de la computación concurrete. La implementación que utilizaremos es la que proporciona Akka y voy a suponer que el lector tiene unos conocimientos mínimos del modelo de actores y de Akka. La definición de dependencia de la librería Akka en sbt es la siguiente:

libraryDependencies += "com.typesafe.akka" %% "akka-actor" % akkaVersion,

Para la realización de los siguientes ejemplos, es necesario definir un actor con una mínima funcionalidad. La funcionalidad es la siguiente: si el actor recibe un mensaje de tipo String (msg), el actor responde con la concatenación del contenido de msg con el texto “Recibido en Actor”; si el actor recibe cualquier otro mensaje, el actor responde con el mensaje “Hola Mundo.” La implementación del actor es la siguiente:

import akka.actor.{Actor, Props}
import scala.concurrent.Future
object ActorEjemplo {
  def props() = Props(new ActorEjemplo())
}
class ActorEjemplo extends Actor {
  import context.dispatcher
  def receive = {
    case msg:String =>{
      val respuesta = msg + " Recibido en Actor"
      println(respuesta)
      sender() ! respuesta
    }
    case _ => {
      val respuesta = "Hola Mundo"
      println(respuesta)
      sender() ! respuesta
    }
  }
}

La lista de ejemplos que se muestran son los siguientes:

  • Ejemplo 1: ejemplo de Futures con tratamiento funcional
  • Ejemplo 2: ejemplo de Futures con tratamiento funcional
  • Ejemplo 3: ejemplo de Futures con tratamiento funcional.
  • Ejemplo 4: ejecución de un Actor con tiempo de espera.
  • Ejemplo 5: ejecución de un Actor sin tiempo de espera.
  • Ejemplo 6: composición de Futures.
  • Ejemplo 7: composición de Furures con for comprehension.
  • Ejemplo 8: conversión de List[Future[A]] -> Future[List[A]]
  • Ejemplo 9: conversión de Future[List[A]] -> List[Future[A]]
  • Ejemplo 10: morfismos con Future, función fold.
  • Ejemplo 11: morfismos con Future, función reduce
  • Ejemplo 12: el primero que termine, se ejecuta; función firstCompletedOf

Ejemplo 1: ejemplo de Futures con tratamiento funcional

Sea un Future future1 cuyo resultado sea el texto “Hello world!”; sea el Future future2 cuyo resultado es el valor entero 3; y, por último, sea el Future future3 que define una secuencia de operaciones con futuro1 y future2 para realizar un cálculo numérico a partir de la ejecución secuencial de future1 y future2.

El snippet del código con las ejecución de las tres futuros  la solución es la siguiente:

def ejemplo(): Unit = {
  val future1 = Future {
    "Hello world!"
  }
  val future2 = Future.successful(3)
  val future3 = future1 map { elemf1 =>
    future2 map { elemf2 =>
      elemf1.length * elemf2
    }
  }
  future3 onComplete {
    case Success(resultado) => println(s"resultado ejemplo3=${resultado}")
    case Failure(error) => println(s"error ejemplo3=${error}")
  }
}

La salida por consola de la ejecución del código anterior es la siguiente:

resultado ejemplo3=Success(36)

Ejemplo 2: ejemplo de Futures con tratamiento funcional

El siguiente ejemplo es el mismo que el caso anterior pero empleando la función foreach.

def ejemplo(): Unit = {
  val future1 = Future {
    "Hello world!"
  }
  val future2 = Future.successful(3)
  val future3 = future1 flatMap { elemf1 =>
    future2 map { elemf2 =>
      elemf1.length * elemf2
    }
  }
  future3 foreach { elem => println(s"Resultado ejemplo4=${elem}") }
}

La salida por consola de la ejecución del código anterior es la siguiente:

Resultado ejemplo4=36

Ejemplo 3: ejemplo de Futures con tratamiento funcional

Sean tres Futures cuyo resultado individual son tres operaciones matemáticas simples y, el último Future, define un filtro. El resultado será la multiplicación del segundo por el tercero.

El snippet del código con la solución es la siguiente:

def ejemplo5(): Unit = {
  val resultado = for {
    a <- Future(10 / 2)
    b <- Future(a + 1)
    c <- Future(a - 1)
    if c > 3
  } yield {
    b * c
  }
  resultado foreach { elem => println(s"Resultado ejemplo5=${elem}") }
}

La salida por consola de la ejecución del código anterior es la siguiente:

Resultado ejemplo5=24

Ejemplo 4: ejecución de un Actor con tiempo de espera

El ejemplo siguiente realizará la creación de un actor, envío de un mensaje y el tratamiento de la respuesta del actor con un tiempo de espera; para finalizar, se realizará la eliminación del actor del ejemplo enviándole el mensaje “PoisonPill”. La definición del actor es la definida al principio de la entrada y el sistema de actores es el identificado con el identificador “Ejem”.

El código del ejemplo es el siguiente:

import scala.concurrent._
import ExecutionContext.Implicits.global
implicit val system = ActorSystem("Ejem")
implicit val timeout = Timeout(2 seconds)
def ejemplo1(): Unit = {
  val actorEjemplo1 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo1")
  val future: Future[Any] = actorEjemplo1 ? "Mensaje"
  val result: String = Await.result(future, timeout.duration).asInstanceOf[String]
  println(s"\nresultado ejemplo1=${result}")
  actorEjemplo1 ! PoisonPill
}

La salida por consola de la ejecución del código anterior es la siguiente:

Mensaje Recibido en Actor
resultado ejemplo1=Mensaje Recibido en Actor

La creación del actor se realiza con la función actorOf del sistema de actores identificado  como system; el envío de un mensaje a un actor se utiliza la función “?”; y, su resultado, es gestionado por el componente Await el cual opera con la respuesta de tipos Future que retorna el actor.

Ejemplo 5: ejecución de un Actor sin tiempo de espera

El siguiente ejemplo es idéntico que el anterior pero se espera la respuesta del actor de tipo Future sin tiempo de espera. La lógica es la misma que el ejemplo anterior pero se emplea la función onComplete para gestionar el resultado de ejecución. El código del ejemplo es el siguiente:

def ejemplo2(): Unit = {
  val actorEjemplo2 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo2")
  // La función mapTo retorna un nuevo Future con la respuesta si es Success; en otro caso, ClassCastException.
  val future: Future[String] = ask(actorEjemplo2, "mensaje").mapTo[String]
  future onComplete {
    case Success(resultado) => println(s"\nresultado ejemplo2=${resultado}\n")
    case Failure(error) => println(s"\nerror ejemplo2=${error}\n")
  }
  actorEjemplo2 ! PoisonPill
}

Ejemplo 6: composición de Futures.

Supongamos que necesitamos ejecutar dos futuros y, su resultado, es la entrada de un tercer futuro. Una posible solución con un tiempo de espera determinado es la siguiente:

def ejemplo6(): Unit = {
  val actorEjemplo6_1 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo6-1")
  val actorEjemplo6_2 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo6-2")
  val actorEjemplo6_3 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo6-3")

  val future1 = actorEjemplo6_1 ask ("Mensaje a Actor6_1")
  val future2 = actorEjemplo6_2 ask ("Mensaje a Actor6_2")

  val respuestaFuture1 = Await.result(future1, 3 seconds).asInstanceOf[String]
  val respuestaFuture2 = Await.result(future2, 3 seconds).asInstanceOf[String]
  val future3 = actorEjemplo6_3 ask ("##" + respuestaFuture1 + "&" + respuestaFuture2 + "##")
  val respuestaFuture3 = Await.result(future3, 3 seconds).asInstanceOf[String]
  println(s"resultado ejemplo6=${respuestaFuture3}")
}

La salida por consola de la ejecución del código anterior es la siguiente:

Mensaje a Actor6_1 Recibido en Actor
Mensaje a Actor6_2 Recibido en Actor
##Mensaje a Actor6_1 Recibido en Actor&Mensaje a Actor6_2 Recibido en Actor## Recibido en Actor
resultado ejemplo6=##Mensaje a Actor6_1 Recibido en Actor&Mensaje a Actor6_2 Recibido en Actor## Recibido en Actor

Ejemplo 7: composición de Furures con for comprehension

El siguiente ejemplo es el mismo que el caso anterior pero se emplea for comprehensión.

def ejemplo7(): Unit = {
  val actorEjemplo7_1 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo7-1")
  val actorEjemplo7_2 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo7-2")
  val actorEjemplo7_3 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo7-3")
  val future1 = actorEjemplo7_1 ask ("Mensaje a Actor7_1")
  val future2 = actorEjemplo7_2 ask ("Mensaje a Actor7_2")
  val future3 = for {
    f1 <- future1.mapTo[String]
    f2 <- future2.mapTo[String]
    c <- ask(actorEjemplo7_3, "##" + f1 + "&" + f2 + "##").mapTo[String]
  } yield {
    c
  }
  future3 foreach { resultado => println(s"Resultado ejemplo7=${resultado}") }
}

La salida por consola de la ejecución del código anterior es la siguiente:

Mensaje a Actor7_2 Recibido en Actor
Mensaje a Actor7_1 Recibido en Actor
##Mensaje a Actor7_1 Recibido en Actor&Mensaje a Actor7_2 Recibido en Actor## Recibido en Actor
Resultado ejemplo7=##Mensaje a Actor7_1 Recibido en Actor&Mensaje a Actor7_2 Recibido en Actor## Recibido en Actor

Ejemplo 8: conversión de List[Future[A]] -> Future[List[A]]

Supongamos que tenemos una lista de operaciones Futuras del mismo tipo, en nuestro caso, Futuros cuya respuesta son números enteros; y, su procesamiento, puede ser transformado un un único Future. La solución consiste en emplear la función sequence la cual es la encargada de transformar muchos Future en uno único. Así, la solución se define de la siguiente forma:

def ejemplo8(): Unit = {
  val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
  // Convertimos un List[Future[Int]] en Future[List[Int]] para trabajar con el Future.
  // Así, podemos trabajar con la List[Int]
  val futureList: Future[List[Int]] = Future.sequence(listaFutures)
  println(s"futureList=${futureList}")
  val suma: Future[Int] = futureList.map(_.sum)
  suma foreach{elem => println(s"Resultado ejemplo8=${suma}")}
}

La salida por consola de la ejecución del código anterior es la siguiente:

Resultado ejemplo8=Success(16)

Ejemplo 9: conversión de Future[List[A]] -> List[Future[A]]

Supongamos que tenemos un único Future y una lista de datos de un determinado tipo  que procesar y, su procesamiento, puede ser ejecutado por N Futuros. La solución consiste en emplear la función traverse. El código del ejemplo es el siguiente:

def ejemplo9(): Unit = {
  // Convertimos un Future[List[Int]] en List[Future[Int]] para trabajar con el Future.
  val futureList1 = Future.traverse((1 to 10).toList)(x => Future(x * 2 - 1))
  val resultadoFutureList1 = futureList1.map(_.sum)
  resultadoFutureList1 foreach {elem => println(s"Resultado1 de ejemplo9=${elem}")}
  val futureList2 = Future.traverse(List(1,3,5))(x => Future(x * 2 - 1))
  val resultadoFutureList2 = futureList2.map(_.sum)
  resultadoFutureList2 foreach {elem => println(s"Resultado2 de ejemplo9=${elem}")}
}

La salida por consola de la ejecución del código anterior es la siguiente:

Resultado2 de ejemplo9=15
Resultado1 de ejemplo9=100

Ejemplo 10: morfismos con Future, función fold

Supongamos que tenemos un ADT de tipo lista de futuros no bloqueantes y queremos realizar un morfismo sobre dicho ADT; el mecanismos para realizarlo, es utilizar la función fold. El siguiente snippet muestra un ejemplo representativo:

def ejemplo10(): Unit = {
  val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
  val sumaListaFutures = Future.fold(listaFutures)(0)(_+_)
  sumaListaFutures onComplete{
    case Success(resultado) => println(s"Resultado ejemplo10=${resultado}")
    case Failure(error) => println(s"Error ejemplo10=${error}")
  }
}

Ejemplo 11: morfismos con Future, función reduce

La función reduce es como la función fold pero sin valor inicial.

def ejemplo11(): Unit = {
  val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
  val futureSum: Future[Int] = Future.reduce(listaFutures)(_ + _)
  futureSum foreach { elem => println(s"Resultado ejemplo11=${futureSum}") }
}

La salida por consola de la ejecución del código anterior es la siguiente:

Resultado ejemplo11=Success(16)

Ejemplo 12: el primero que termine, se ejecuta; función firstCompletedOf

Supongamos que tenemos una lista de futuros en un ADT de tipo lista; y, a nivel de negocio, solo nos interesa el resultado del primer future que termina; en estos casos,  se emplea la función firstCompletedOf. El siguiente ejemplo muestra un ejemplo representativo.

def ejemplo12(): Unit = {
  val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
  val futureFirst: Future[Int] = Future.firstCompletedOf(listaFutures)
  futureFirst foreach { elem => println(s"Resultado ejemplo12=${futureFirst} elem=${elem}") }
}

Una de las posibles salidas por consola de la ejecución del código anterior es la siguiente:

Resultado ejemplo12=Success(3) elem=3

Estos son los ejemplos que presento, si al lector interesado se le ocurre plantear otro ejemplo, o bien, plantear cualquier otra alternativa, estaré encantado de compartirlo.