Mônadas e functores são conceitos avançados em programação funcional que fornecem abstrações poderosas para lidar com transformações de dados, efeitos colaterais e composição. Embora tenham origem na teoria das categorias em matemática, eles têm aplicações práticas em linguagens de programação como JavaScript.

O que é um Funtor?

Um functor é um tipo de dados que implementa um método map, que aplica uma função ao valor dentro do functor e retorna um novo functor com o valor transformado. Em essência, os functores permitem aplicar uma função a um valor agrupado sem alterar a estrutura do contêiner.

Exemplo de Funtor

class Box {
  constructor(value) {
    this.value = value;
  }

  map(fn) {
    return new Box(fn(this.value));
  }
}

// Usage
const box = new Box(2);
const result = box.map(x => x   3).map(x => x * 2);
console.log(result); // Box { value: 10 }

Neste exemplo, Box é um functor. O método map aplica a função fn ao valor dentro da caixa e retorna uma nova Caixa com o valor transformado.

O que é uma mônada?

Uma mônada é um tipo de functor que implementa dois métodos adicionais: of (ou return em algumas linguagens) e flatMap (também conhecido como bind ou chain). As mônadas fornecem uma maneira de encadear operações no valor contido, mantendo o contexto da mônada.

Propriedades das Mônadas

1. Unidade (de): Um método que recebe um valor e retorna uma mônada contendo esse valor.
2. Bind (flatMap): Um método que pega uma função que retorna uma mônada e a aplica ao valor contido, nivelando o resultado.

Exemplo de Mônada

class Box {
  constructor(value) {
    this.value = value;
  }

  static of(value) {
    return new Box(value);
  }

  map(fn) {
    return Box.of(fn(this.value));
  }

  flatMap(fn) {
    return fn(this.value);
  }
}

// Usage
const box = Box.of(2);
const result = box
  .flatMap(x => Box.of(x   3))
  .flatMap(x => Box.of(x * 2));
console.log(result); // Box { value: 10 }

Neste exemplo, Box é um functor e uma mônada. O método of envolve um valor em uma Box, e o método flatMap aplica uma função ao valor contido e retorna a mônada resultante.

Casos práticos de uso de mônadas e functores

Mônadas e functores não são apenas construções teóricas; eles têm aplicações práticas em programação do mundo real. Vamos explorar alguns casos de uso comuns.

Tratamento de valores opcionais com Maybe Monad

A mônada Maybe é usada para lidar com valores opcionais, evitando valores nulos ou indefinidos e fornecendo uma maneira segura de encadear operações.

class Maybe {
  constructor(value) {
    this.value = value;
  }

  static of(value) {
    return new Maybe(value);
  }

  isNothing() {
    return this.value === null || this.value === undefined;
  }

  map(fn) {
    return this.isNothing() ? this : Maybe.of(fn(this.value));
  }

  flatMap(fn) {
    return this.isNothing() ? this : fn(this.value);
  }
}

// Usage
const maybeValue = Maybe.of('hello')
  .map(str => str.toUpperCase())
  .flatMap(str => Maybe.of(`${str} WORLD`));
console.log(maybeValue); // Maybe { value: 'HELLO WORLD' }

Neste exemplo, a mônada Maybe manipula com segurança o valor opcional, permitindo transformações apenas se o valor não for nulo ou indefinido.

Lidando com operações assíncronas com Promise Monad

Promessas em JavaScript são mônadas que lidam com operações assíncronas, fornecendo uma maneira de encadear operações e lidar com erros.

const fetchData = url => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(`Data from ${url}`);
    }, 1000);
  });
};

// Usage
fetchData('https://api.example.com')
  .then(data => {
    console.log(data); // 'Data from https://api.example.com'
    return fetchData('https://api.example.com/2');
  })
  .then(data => {
    console.log(data); // 'Data from https://api.example.com/2'
  })
  .catch(error => {
    console.error(error);
  });

As promessas permitem que você lide com operações assíncronas de maneira limpa e combinável, encadeando operações e lidando com erros normalmente.

Mônadas e functores são abstrações poderosas em programação funcional que permitem trabalhar com transformações de dados, efeitos colaterais e composição de uma forma mais estruturada e previsível.

Embora os fundamentos matemáticos de mônadas e functores possam ser complexos, suas aplicações práticas são altamente valiosas na programação do mundo real. Esteja você lidando com valores opcionais com a mônada Maybe ou gerenciando operações assíncronas com Promises, essas técnicas de programação funcional podem ajudá-lo a criar aplicativos mais robustos e confiáveis.