Gniazdo.JS | Monady -> Stan

Jan 27 2023

Monada stanu to funkcjonalna koncepcja programowania, która pozwala zarządzać stanem w funkcjonalny, niezmienny sposób. Umożliwia pisanie kodu, który aktualizuje stan obliczeń w czysty, komponowalny sposób, co ułatwia wnioskowanie i testowanie.

Monada stanu jest często używana do zarządzania obliczeniami stanowymi w funkcjonalnym języku programowania, takim jak JavaScript. Monada stanu umożliwia opisanie obliczeń, które aktualizują pewien stan w czysty, komponowalny sposób, co ułatwia rozumowanie i testowanie kodu.

Monada stanu jest zwykle implementowana jako obiekt, który ma pojedynczą metodę, zwaną run, która przyjmuje stan początkowy jako dane wejściowe i zwraca wynik obliczeń oraz zaktualizowany stan. Monada stanu może służyć do łączenia wielu obliczeń, które aktualizują ten sam stan i tworzą bardziej złożone obliczenia.

Oto przykład monady stanu w 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);
    });
  }
  // ...
}

Na przykład, można utworzyć stan, który przyjmuje liczbę początkową i zwraca nową liczbę powiększoną o jeden, a następnie można połączyć wiele takich stanów, aby utworzyć bardziej złożone obliczenia, które wielokrotnie aktualizują stan, bez konieczności ręcznego przekazywania stan na każdym kroku.

Należy zauważyć, że Monada stanu nie jest powszechnym wzorcem w JavaScript, jest używana głównie w funkcjonalnych językach programowania, takich jak Haskell, scala itp.

Oto przykład, jak możesz użyć StateMonady w 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);
  }
}

Monada Statesłuży do zarządzania stanem w sposób funkcjonalny, w tym przykładzie jako stanu użyto prostego licznika, ale stan może być czymkolwiek, na przykład obiektem lub tablicą.

Metoda incrementCounter()inkrementuje licznik i aktualizuje stan, decrementCounter()metoda zmniejsza licznik i aktualizuje stan, getCounter()metoda zwraca aktualną wartość licznika.

Możesz połączyć wiele obliczeń za pomocą metod .map(), .chain(), .ap().

const program: State<StateType, number> = myService
  .incrementCounter()
  .chain(() => myService.incrementCounter())
  .chain(() => myService.getCounter());

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

Należy zauważyć, że ten przykład jest prosty i nie pokazuje pełnej mocy monad w programowaniu funkcjonalnym. Monad można używać do obsługi różnych przypadków, takich jak obsługa błędów, łączenie wielu obliczeń i nie tylko. Najlepiej zrozumieć problem i przypadki użycia przed zastosowaniem monad.

Gniazdo.JS | Monady -&gt; Stan

Gniazdo.JS | Monady -> Stan