Nest.JS | Monades -> État

Jan 27 2023

La monade d'état est un concept de programmation fonctionnelle qui permet de gérer l'état de manière fonctionnelle et immuable. Il vous permet d'écrire du code qui met à jour l'état d'un calcul de manière pure et composable, ce qui facilite le raisonnement et les tests.

La monade State est souvent utilisée pour gérer des calculs avec état dans un langage de programmation fonctionnel, tel que JavaScript. La monade d'état vous permet de décrire un calcul qui met à jour un état d'une manière pure et composable, ce qui facilite le raisonnement et le test de votre code.

Une monade d'état est généralement implémentée en tant qu'objet doté d'une seule méthode, appelée run, qui prend l'état initial en entrée et renvoie le résultat du calcul et l'état mis à jour. La monade d'état peut être utilisée pour enchaîner plusieurs calculs qui mettent à jour le même état et créent des calculs plus complexes.

Voici un exemple de la monade State en JavaScript :

class State {
  constructor(fn) {
    this.run = fn
  }
  map(f) {
    return new State((state) => {
        const [result, updatedState] = this.run(state);
        return [f(result), updatedState];
    });
  }
  chain(f) {
    return new State((state) => {
        const [result, updatedState] = this.run(state);
        return f(result).run(updatedState);
    });
  }
  // ...
}

Par exemple, vous pouvez créer un état qui prend un nombre initial et renvoie un nouveau nombre incrémenté de un, vous pouvez ensuite enchaîner plusieurs de ces états pour créer un calcul plus complexe qui met à jour l'état plusieurs fois, sans avoir à passer manuellement le état à chaque étape.

Il est important de noter que la monade d'état n'est pas un modèle courant en JavaScript, elle est principalement utilisée dans les langages de programmation fonctionnels comme Haskell, scala, etc.

Voici un exemple d'utilisation de StateMonad dans Nest.js :

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

interface StateType {
  counter: number;
}

@Injectable()
export class MyService {
  public incrementCounter(): State<StateType, number> {
    return state.get().map(s => s.counter + 1).put({ counter: s.counter + 1 });
  }

  public decrementCounter(): State<StateType, number> {
    return state.get().map(s => s.counter - 1).put({ counter: s.counter - 1 });
  }

  public getCounter(): State<StateType, number> {
    return state.get().map(s => s.counter);
  }
}

La Statemonade est utilisée pour gérer l'état de manière fonctionnelle, cet exemple utilise un simple compteur comme état, mais l'état peut être n'importe quoi comme un objet ou un tableau.

La incrementCounter()méthode incrémente le compteur et met à jour l'état, la decrementCounter()méthode décrémente le compteur et met à jour l'état, 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: State<StateType, number> = myService
  .incrementCounter()
  .chain(() => myService.incrementCounter())
  .chain(() => myService.getCounter());

console.log(program.run({ counter: 0 }).value);

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.

De plus, la run()méthode doit être appelée pour exécuter la monade d'état et obtenir les résultats, elle prend un état initial comme argument.

Nest.JS | Monades -&gt; État

Nest.JS | Monades -> État