Gotas de Elixir – 2 dicas para simplificar seu código

Aqui vão 2 dicas simples para deixar seu código Elixir mais idiomático e simples!

Para ilustrar vamos utilizar um exercício do Exercism.io onde precisamos escrever o módulo Acronimo que possui a função abreviar/1 (o /1 ao final do nome indica que a função toma um parâmetro como argumento). Esta função deve receber uma string como parâmetro e vai devolver apenas as primeiras letras em caixa alta, por exemplo Acronimo.abreviar(“Ruby on Rails”) retornaria “ROR”.

Este é um código que poderia resolver esse problema:

defmodule Acronimo do
  def abreviar(nome) do
    nomes_separados = String.split(nome)
    primeiras_letras = Enum.map(nomes_separados, fn(n) ->
      primeira_letra = String.first(n)
      String.capitalize(primeira_letra)
    end)
    Enum.join(primeiras_letras)
  end
end

Esse código funciona perfeitamente, mas não parece idiomático. Vamos refatorá-lo operadores que vão diminuir a quantidade de código e deixá-lo com mais cara de código Elixir 😉

1. O operador pipe |>

Escrever funções pequenas permite agrupá-las de maneira que nem precisamos criar uma variável que apenas guarda o valor de retorno e passa para a próxima função.

No código inicial criamos várias variáveis com esse propósito, mas utilizando o operador |> podemos encadear as chamadas e evitar a criação de variáveis.

defmodule Acronimo do
  def abreviar(nome) do
    String.split(nome)
    |> Enum.map(fn(n) ->
      String.first(n)
      |> String.capitalize
    end)
    |> Enum.join
  end
end

O operador pipe permite omitir o primeiro parâmetro do método, como por exemplo a chamada a Enum.map, que recebe a lista e a função de mapeamento. Outro exemplo mais simples é o código a seguir.

processar_pagamento(encontrar_funcionario(id), bonus_fixo)
# equivale a
encontrar_funcionario(id)
|> processar_pagamento(bonus_fixo)

2. Funções anônimas com o operador &

A segunda dica simplifica um pouco mais a chamada da função anônima dentro do map com o operador &, permitindo omitir a declaração do parâmetro, usando &1 em seu lugar, e diminuindo a quantidade de código.

defmodule Acronimo do
  def abreviar(nome) do
    String.split(nome)
    |> Enum.map(&(String.capitalize(String.first(&1))))
    |> Enum.join
  end
end

Utilizar uma função anônima tem suas vantagens caso o bloco de código dentro dela seja muito grande ou caso ela receba vários parâmetros. Mesmo podendo usar &1 e &2 para o primeiro e segundo parâmetros, o código pode não ficar tão legível.

O código final ficou bem mais conciso e parecido com código Elixir, e os dois operadores são bem simples de utilizar!

Se você curte Elixir, confira os posts da série Gotas de Elixir.

Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s