Mónadas en Scala

En Scala, Monads es una construcción que realiza cálculos sucesivos. Es un objeto que cubre al otro objeto. Vale la pena señalar que aquí, la salida de una operación en algún paso es una entrada para otros cálculos, que es el padre del paso reciente del programa indicado. Monad no es ni una clase ni un rasgo, es un concepto. Las colecciones máximas de Scala son Mónadas , pero no todas las Mónadas son colecciones, hay varias Mónadas que son contenedores como Opciones en Scala. En resumen, podemos decir que en Scala los tipos de datos que implementan map así como flatMap() como Opciones, Listas, etc. se llaman comoMónadas .

Los objetos están encerrados con Monads , ya que produce las dos funciones siguientes:

1. unit() : es como void en Java, no devuelve ningún tipo de datos.
2. flatMap() : es similar a map() en Scala pero devuelve una serie en lugar de devolver un solo componente.

Veamos un ejemplo para ilustrarlo de forma explícita.

var x = Seq("Geeks", "For", "Geeks")

Apliquemos map() en la secuencia dada.

// Applying map()
 var y = x.map(_.toUpperCase)
// Output
List(GEEKS, FOR, GEEKS)

Ahora, apliquemos flatMap() en la secuencia dada.

// Applying flatMap()
var z = x.flatMap(_.toUpperCase)
// Output
List(G, E, E, K, S, F, O, R, G, E, E, K, S)

Entonces, cuando se aplica un mapa plano en la Secuencia indicada anteriormente, se devuelve una Lista donde se elimina la agrupación interna y se genera una secuencia.

Nota: Las colecciones que admiten map y flatMap se denominan monádicas . Ahora, veamos algunos ejemplos de Mónadas en Scala.

Ejemplos de mapas compatibles con colecciones , así como mapas planos .
Ejemplo :

// Scala program of Monads
  
// Creating object
object GfG
{ 
  
    // Main method
    def main(args:Array[String])
    {
          
        // Creating list of numbers
        val list1 = List(1, 2, 3, 4)
        val list2 = List(5, 6, 7, 8)
              
        // Applying 'flatMap' and 'map'
        val z = list1 flatMap { q => list2 map {
                r => q + r
        }
        }
          
        // Displays output
        println(z)
          
    }
} 

List(6, 7, 8, 9, 7, 8, 9, 10, 8, 9, 10, 11, 9, 10, 11, 12)

Veamos ahora, cómo se calcula la salida.

// Aplicando map() obtenemos una lista como la siguiente
List(List((1+5), (1+6), (1+7), (1+8)), List((2+5), (2 +6), (2+7), (2+8)),
Lista((3+5), (3+6), (3+7), (3+8)), Lista((4+5 ), (4+6), (4+7), (4+8)))

Después de la evaluación obtenemos,

Lista (Lista (6, 7, 8, 9), Lista (7, 8, 9, 10), Lista (8, 9, 10, 11), Lista (9, 10, 11, 12))

Entonces, obtenemos una Lista de listas y para cada operación tenemos una lista diferente después de aplicar map() , ahora apliquemos flatMap() .

// Aplicando flatMap() obtenemos una lista como la siguiente
List(6, 7, 8, 9, 7, 8, 9, 10, 8, 9, 10, 11, 9, 10, 11, 12)

Entonces, cuando aplicamos flatMap(), se elimina la agrupación interna.

Ejemplo :

// Scala program of Monads
  
// Creating object
object GfG
{ 
  
    // Main method
    def main(args:Array[String])
    {
      
        // Creating list of numbers
        val x = (1 to 3).toList
        val y = (1 to 7 by 2).toList
  
        // Applying 'flatMap'and 'map'
        val z = x flatMap { s => y map { 
                    t => s * t 
      
        }
        }
  
        // Displays output
        println(z)
    }
} 

List(1, 3, 5, 7, 2, 6, 10, 14, 3, 9, 15, 21)

Aquí, List(x) = (1, 2, 3) y List(y) = (1, 3, 5, 7) entonces veamos cómo se calcula la salida.

// Aplicando map() obtenemos una lista como la siguiente
List(List((1*1), (1*3), (1*5), (1*7)), List((2*1), (2 *3), (2*5), (2*7)),
Lista((3*1), (3*3), (3*5), (3*7)))

Y después de la evaluación obtenemos,

Lista (Lista (1, 3, 5, 7), Lista (2, 6, 10, 14), Lista (3, 9, 15, 21))

Ahora, apliquemos flatMap().

// Applying flatMap() we get a list like below
List(1, 3, 5, 7, 2, 6, 10, 14, 3, 9, 15, 21)

Por lo tanto, se elimina la agrupación interna.