O operador pipeline e a programação funcional
Tags: javascript, computerscience, functional
Published: 2020-01-05 23:49:26

![Pipeline](https://thepracticaldev.s3.amazonaws.com/i/q2xkwatax5rgawftrz13.jpeg)

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:
```javascript
'%21' |> decodeURI
```
ao invés de 
```javascript
decodeURI('%21')
```
Essa é a definição dada pela [MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/Pipeline_operator) 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:
```javascript 
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:
```javascript
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
![Babel](https://thepracticaldev.s3.amazonaws.com/i/r1hm5q1pl3yygh3db24u.png)
Já é possível utilizar o pipeline operator através do [babel](https://babeljs.io/), 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:
```javascript
// 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](https://github.com/lucassouzamatos/pipeline-experimental).

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