Fundamentos de Programação Funcional com JavaScript

Bom para podermos aprender os Fundamentos de Programação Funcional com JavaScript primeiro é preciso saber o que é programação funcional, ou o que é o paradigma funcional.

Como vimos no nosso outro post “Entenda os paradigmas de programação“, nesse paradigma o uso de funções é o foco.

Ou em bom português, tudo são funções.

Se você já programa usando JavaScript deve estar pensando que eu estou louco em pensar em programação funcional usando JavaScript, mas não se esqueça o JavaScript é multi paradigma.

Certamente existem linguagens mais apropriadas para aprender sobre programação funcional.

Como Haskell e Clojure ou até mesmo F# por exemplo.

Mas por outro lado o JavaScript é uma linguagem muito conhecida.

O que diminui muito a barreira inicial de aprendizagem.

Bom sem mais delongas, vamos aos principais conceitos e como usa-los no JavaScript.

Funções Puras

O primeiro princípio que precisamos saber para entender programação funcional são as Funções Puras.

Mas o que isso significa?

O que torna uma função pura?

Bom, para uma função ser considerada pura é preciso que a função satisfaça duas regras.

A função retorna sempre retorna o mesmo resultado para uma determinada entrada.
A função não pode causar nenhum efeito colateral.

Ambas as regras são muitos simples, mas pode não ser tão fácil entender elas na prática.

Vamos entender melhor cada uma delas.

A função retorna sempre retorna o mesmo resultado para uma determinada entrada

Vamos supor que você criou uma função que calcula a área de um círculo.

Para isso então você adiciona o raio como parâmetro e o PI seria previamente declarado.

let PI = 3.14;

const calculateArea = (radius) => radius * radius * PI;

calculateArea(10); // returns 314.0

Essa função por sua vez seria impura, pois se o PI mudar no contexto então mesmo passando duas vezes o mesmo valor do raio teremos resultados diferentes.

Por outro lado, se passarmos o valor de PI como parâmetro para a função então a mesma se torna pura.

Já que assim a função cumpriria as duas regras.

Refatorando o código e transformando a função em uma função pura temos o código abaixo.

let PI = 3.14;

const calculateArea = (radius, pi) => radius * radius * pi;

calculateArea(10, PI); // returns 314.0

Veja que agora a função dada uma entrada sempre vai ter a mesma saída.

Sendo assim uma função determinística.

A função não pode causar nenhum efeito colateral

Antes de tudo vamos entender o que seria um efeito colateral.

É considerado um efeito colateral qualquer mudança que ocorrer fora do escopo interno da função.

Como por exemplo.

Alterar uma variável global
Alterar uma variável passada como parâmetro

Para entendermos melhor vamos supor que você desenvolveu uma função simples que dado um valor, incrementa ele em 1.

let counter = 1;

function increaseCounter(value) {
  counter = value + 1;
}

increaseCounter(counter);
console.log(counter); // 2

Veja que a função é impura.

Uma vez que altera o valor da variável counter.

Para tornar a função pura é simples.

Basta remover a associação da variável counter.

let counter = 1;

const increaseCounter = (value) => value + 1;

increaseCounter(counter); // 2
console.log(counter); // 1

Sendo assim a função não cria nenhum efeito colateral.

Já que nada fora do escopo da função é alterado.

Imutabilidade

Uma característica muito importante do paradigma funcional é que os dados são imutáveis.

Isso significa que um dado não pode ser alterado depois de ser criado.

O dado pode ser manipulado em uma função.

Ou até mesmo atribuído a outra variável.

Mas não pode ser mudado.

Vamos a um exemplo simples usando um for.

var values = [1, 2, 3, 4, 5];
var sumOfValues = 0;

for (var i = 0; i < values.length; i++) {
  sumOfValues += values[i];
}

sumOfValues // 15

Veja que em cada uma das iterações do loop duas variáveis sofrem alteração.

Mas como iterar um valor sem usar a mutabilidade?

Para isso vamos usar a recursão.

Então vamos escrever o código acima.

Mas dessa vez usando recursão.

let list = [1, 2, 3, 4, 5];
let accumulator = 0;

function sum(list, accumulator) {
  if (list.length == 0) {
    return accumulator;
  }

  return sum(list.slice(1), accumulator + list[0]);
}

sum(list, accumulator); // 15
list; // [1, 2, 3, 4, 5]
accumulator; // 0

Veja que agora nenhum dado sofre alteração.

Então o código é imutável.