Nest.JS | Monades -> Lecteur

Jan 27 2023

La monade Reader, également connue sous le nom de « monade d'environnement », est un concept de programmation fonctionnelle qui vous permet de transmettre un environnement, ou un contexte partagé, tout au long d'un calcul. Il vous permet d'écrire du code indépendant des valeurs spécifiques de ce contexte, ce qui le rend plus réutilisable et plus facile à tester.

La monade Reader est souvent utilisée pour gérer les dépendances et les valeurs de configuration dans un langage de programmation fonctionnel, tel que JavaScript. La monade Reader vous permet de décrire un calcul qui dépend d'un contexte externe d'une manière pure et composable, ce qui facilite le raisonnement et le test de votre code.

Une monade Reader est généralement implémentée sous la forme d'un objet doté d'une seule méthode, appelée run, qui prend le contexte en entrée et renvoie le résultat du calcul. La monade Reader peut être utilisée pour enchaîner plusieurs calculs qui dépendent du même contexte et créer des calculs plus complexes.

Voici un exemple de la monade 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))
  }
  // ...
}

Par exemple, vous pouvez créer un lecteur qui prend un objet de configuration et renvoie une valeur basée sur cette configuration. Vous pouvez ensuite enchaîner plusieurs de ces lecteurs pour créer un calcul plus complexe, sans avoir à passer l'objet de configuration à chaque étape.

Il est important de noter que le Reader Monad n'est pas un modèle courant en JavaScript, il est principalement utilisé dans les langages de programmation fonctionnels comme Haskell, scala, etc.

Voici un exemple d'utilisation de ReaderMonad dans 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 Readermonade est utilisée pour résumer le passage de la configuration, des dépendances ou du contexte à travers un programme ou un ensemble de fonctions.

Dans cet exemple, la incrementCounter()méthode incrémente le compteur et renvoie une nouvelle valeur, la decrementCounter()méthode décrémente le compteur et renvoie une nouvelle valeur, la getCounter()méthode renvoie la valeur actuelle du compteur.

Vous pouvez enchaîner plusieurs calculs à l'aide des méthodes .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());

Il est important de noter que cet exemple est basique et ne démontre pas toute la puissance de Monads dans la programmation fonctionnelle. Les monades peuvent être utilisées pour gérer divers cas comme la gestion des erreurs, l'enchaînement de plusieurs calculs et plus encore, il est préférable de comprendre le problème et les cas d'utilisation avant d'appliquer les monades.

Nest.JS | Monades -&gt; Lecteur

Nest.JS | Monades -> Lecteur