Nido.JS | Mónadas -> Lector

Jan 27 2023

La mónada del lector, también conocida como la "mónada del entorno", es un concepto de programación funcional que le permite pasar un entorno, o un contexto compartido, a lo largo de un cálculo. Le permite escribir código que es independiente de los valores específicos de ese contexto, haciéndolo más reutilizable y más fácil de probar.

La mónada Reader se usa a menudo para administrar dependencias y valores de configuración en un lenguaje de programación funcional, como JavaScript. La mónada Reader le permite describir un cálculo que depende de algún contexto externo de una manera pura y componible, lo que facilita el razonamiento y la prueba de su código.

Una mónada de Reader normalmente se implementa como un objeto que tiene un solo método, llamado run, que toma el contexto como entrada y devuelve el resultado del cálculo. La mónada Reader se puede utilizar para encadenar varios cálculos que dependen del mismo contexto y crear cálculos más complejos.

Aquí hay un ejemplo de la mónada Reader en JavaScript:

class Reader {
  constructor(fn) {
    this.run = fn
  }
  map(f) {
    return new Reader(e => f(this.run(e)))
  }
  chain(f) {
    return new Reader(e => f(this.run(e)).run(e))
  }
  // ...
}

Por ejemplo, podría crear un Lector que tome un objeto de configuración y devuelva un valor basado en esa configuración. Luego, podría encadenar varios de estos lectores para crear un cálculo más complejo, sin tener que pasar el objeto de configuración a través de cada paso.

Es importante tener en cuenta que Reader Monad no es un patrón común en JavaScript, se usa principalmente en lenguajes de programación funcionales como Haskell, scala, etc.

Aquí hay un ejemplo de cómo podría usar ReaderMonad en Nest.js:

import { Injectable } from '@nestjs/common';
import { Reader, reader } from 'fp-ts/lib/Reader';

@Injectable()
export class MyService {
  public incrementCounter(counter: number): Reader<number, number> {
    return reader.of(counter + 1);
  }

  public decrementCounter(counter: number): Reader<number, number> {
    return reader.of(counter - 1);
  }

  public getCounter(counter: number): Reader<number, number> {
    return reader.of(counter);
  }
}

La Readermónada se utiliza para abstraer el paso de la configuración, las dependencias o el contexto a lo largo de un programa o un conjunto de funciones.

En este ejemplo, el incrementCounter()método incrementa el contador y devuelve un nuevo valor, el decrementCounter()método decrementa el contador y devuelve un nuevo valor, el getCounter()método devuelve el valor actual del contador.

Puede encadenar varios cálculos utilizando los métodos .map(), .chain(), .ap().

const program: Reader<number, number> = myService
  .incrementCounter(10)
  .chain(counter => myService.decrementCounter(counter))
  .chain(counter => myService.getCounter(counter));

console.log(program.run());

Es importante tener en cuenta que este ejemplo es básico y no demuestra todo el poder de Monads en la programación funcional. Las mónadas se pueden usar para manejar varios casos, como el manejo de errores, el encadenamiento de múltiples cálculos y más. Es mejor comprender el problema y los casos de uso antes de aplicar las mónadas.

Nido.JS | Mónadas -&gt; Lector

Nido.JS | Mónadas -> Lector