O operador experimental pipeline |> (atualmente no estágio 1) permite a criação de chamadas de funções encadeadas de maneira legível. Basicamente, o operador de pipeline fornece açúcar sintático em uma chamada de função com um único argumento, permitindo que você escreva:

'%21' |> decodeURI

ao invés de

decodeURI('%21')

Essa é a definição dada pela MDN ao operador pipeline, que ainda está em fase de aprovação no ECMAScript. Mas por que esse operador seria útil na programação funcional?

Mas, por quê?

Se você já teve algum contato com a programação funcional, pode ter se deparado com os padrões de funções pipe e compose, que basicamente são dois conceitos de composição de funções.

A composição de funções a grosso modo é definida pela execução de diversas funções encadeadas, sendo que cada função pode retornar uma outra função. É muito útil na programação funcional, pois simplifica código, tornando-o mais limpo e mais reutilizável. Um exemplo de composição de funções:

getPair = arr => arr.filter(number => number%2===0)
multiply = arr => arr.map(number => number*2)

getPair([1,2,3,4,5]); // [2, 4]
multiply(getPair([1,2,3,4,5])) // [4, 8]

É um conceito fundamental na programação funcional, mas que não entraremos em detalhes aqui.

O fato é que, o pipeline operator pode ser facilmente utilizado para simplificar a visibilidade na composição de funções. Onde o mesmo caso acima, fica dessa forma:

const getPair = arr => arr.filter(number => number%2===0)
const multiply = arr => arr.map(number => number*2)
[1,2,3,4,5] |> getPair // [2, 4]
[1,2,3,4,5] |> getPair |> multiply // [4,8]

Perceba que a visualização da sequência no qual as funções serão executadas fica muito mais simples, e em funções como o pipe e o compose, onde a ordem é principal diferença do uso, o pipeline acabou facilitando muito.

Babel

Já é possível utilizar o pipeline operator através do babel, caso não conheça o babel, ele é um poderoso compilador javascript capaz de transpilar códigos ainda não aceitos por navegadores em um novo código legível.

Vamos começar:

Em um novo diretório, instale as dependências:

yarn add --dev @babel/core @babel/cli @babel/preset-env
yarn add @babel/polyfill
yarn add --dev @babel/plugin-proposal-pipeline-operator

Crie um novo arquivo, chamado .babelrc:

{
   "presets": [
      "@babel/env"
   ],
   "plugins": [
      [
         "@babel/plugin-proposal-pipeline-operator",
            { "proposal": "minimal" }
      ]
   ]
}

No package.json:

"scripts": {
  "babel": "./node_modules/.bin/babel src --out-dir dist",
  "start": "node dist/index"
},

Agora, vamos começar a utilizar o operador:

// index.js
const getPair = arr => arr.filter(number => number%2===0)
const multiply = arr => arr.map(number => number*2)
const test = [1,2,3,4,5] |> getPair |> multiply
console.log(test);

Agora basta executar os scripts, e seu código será transpilado e executado:

yarn babel
yarn start

Acompanhe o mesmo código no github, aqui.

Encontrou algum erro no conteúdo? Por favor, comente aqui.