Nest.JS | Mônadas -> Estado

Jan 27 2023

A mônada de estado é um conceito de programação funcional que permite gerenciar o estado de maneira funcional e imutável. Ele permite que você escreva um código que atualize o estado de uma computação de uma maneira pura e combinável, o que torna mais fácil raciocinar e testar.

A mônada State é frequentemente usada para gerenciar computações com estado em uma linguagem de programação funcional, como JavaScript. A mônada State permite que você descreva uma computação que atualiza algum estado de uma maneira pura e combinável, o que torna mais fácil raciocinar e testar seu código.

Uma mônada State é normalmente implementada como um objeto que possui um único método, chamado run, que recebe o estado inicial como entrada e retorna o resultado da computação e o estado atualizado. A mônada State pode ser usada para encadear várias computações que atualizam o mesmo estado e criam computações mais complexas.

Aqui está um exemplo da mônada State em 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);
    });
  }
  // ...
}

Por exemplo, você pode criar um estado que pega um número inicial e retorna um novo número incrementado por um, você pode encadear vários desses estados juntos para criar uma computação mais complexa que atualiza o estado várias vezes, sem ter que passar manualmente o estado através de cada etapa.

É importante notar que o State Monad não é um padrão comum em JavaScript, é usado principalmente em linguagens de programação funcionais como Haskell, scala, etc.

Aqui está um exemplo de como você pode usar o StateMonad no 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);
  }
}

A StateMônada é usada para gerenciar o estado de maneira funcional, este exemplo usa um contador simples como estado, mas o estado pode ser qualquer coisa como um objeto ou uma matriz.

O incrementCounter()método incrementa o contador e atualiza o estado, o decrementCounter()método decrementa o contador e atualiza o estado, o getCounter()método retorna o valor atual do contador.

Você pode encadear vários cálculos usando os métodos .map(), .chain(), .ap().

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

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

É importante observar que este exemplo é básico e não demonstra todo o poder das Mônadas na programação funcional. As mônadas podem ser usadas para lidar com vários casos, como tratamento de erros, encadeamento de vários cálculos e muito mais. É melhor entender o problema e os casos de uso antes de aplicar as mônadas.

Nest.JS | Mônadas -&gt; Estado

Nest.JS | Mônadas -> Estado