PauloRB.dev

Programação Funcional no Elixir: Fundamentos e Exemplos

Por Paulo RB em 08/06/2024

A programação funcional está se tornando cada vez mais popular devido à sua simplicidade e capacidade de lidar com paralelismo e concorrência de forma eficiente. Este post explora os conceitos básicos da programação funcional, exemplificando com a linguagem Elixir.

Conceitos Importantes da Programação Funcional

• Composição de Funções: Combinação de pequenas funções para formar operações mais complexas.
• Funções de Alta Ordem: Funções que recebem outras funções como argumento ou retornam uma função.
• Imutabilidade: Dados não podem ser alterados após a sua criação.
• Funções Puras: Funções que, dada a mesma entrada, sempre retornam o mesmo resultado e não causam efeitos colaterais.

Para iniciarmos uma projeto em Elixir basta abrir o terminal e digitar o comando

mix new nome_do_projeto

Para rodar o projeto, utilize:

$ iex -S mix

Após toda alteração é necessário recopilar o projeto e para isso basta digitar no terminal o comando “recompile” e após esse comando basta novamente escrever on terminal o nome do módulo seguido da função. Por exemplo: Modulo.funcao_hello_world().

Antes de avaçarmos no conteúdo para uma melhor compreensão vamos fazer uma comparação entre uma linguagem POO(programação orientada e objetos) e o paradigma funcional proposto pelo elixir.

No Python, para converter uma string para letras minúsculas, usamos um método de um objeto:

string = "HELLO"
print(string.lower()) # Saída: hello

Em Elixir, a abordagem é diferente, focando em funções puras:

string = "HELLO"
IO.puts String.downcase(string) # Saída: hello

Em um primeiro momento momento a sintaxe é muito parecida mas em Elixir fazemos uso o módulo String e depois de uma função chamado downcase.

Imutabilidade

Imutabilidade garante que os dados não podem ser alterados após a sua criação, permitindo um uso mais eficiente de recursos como paralelismo e threads.

Exemplo de Imutabilidade em Elixir

defmodule Functional do
  def hello do
    user_data = %{name: "John", age: 30, email: "john.doe@gmail.com"}
    user_data = Map.put(user_data, :name, "Jane")
    IO.inspect(user_data)
  end
end

Functional.hello()

Composição de Funções

O operador |> é utilizado para encadear funções, facilitando a composição de operações complexas.

# Exemplo de composição de função
defmodule Functional do
  @moduledoc """
  Documentation for `Functional`.
  """

  @doc """
  Hello world.

  ## Examples

      iex> Functional.hello()
      :world

  """
  def hello do
    # Composição de Função. |>  pipe operator
    %{ name: "John", age: 30,email: "jhon.doe@gmail.com"} # cria uma variável com um mapa
    |> put_map(:name, "John Doe") # altera o valor de uma chave
    |> IO.inspect() # imprime o valor do mapa
    |> put_map(:age, 31) # adiciona uma chave
    |> delete_map_value(:age) # deleta uma chave

  end

  # defp é privado
  defp put_map(map, key, value) do
    Map.put(map, key, value)
  end

  defp delete_map_value(map, key) do
    Map.delete(map, key)
  end

end

Exemplo de Composição de Funções

Funções de Alta Ordem

Funções de alta ordem recebem outras funções como argumento ou retornam funções como resultado. Em Elixir, podemos usar o módulo Enum para manipular coleções.

Exemplo de Função de Alta Ordem

defmodule Functional do
  def hello do
    %{name: "John", age: 30, email: "john.doe@gmail.com"}
    |> put_map(:name, "John Doe")
    |> put_map(:age, 31)
    |> Enum.map(fn {key, value} -> IO.puts("#{key}: #{value}") end)
  end

  defp put_map(map, key, value) do
    Map.put(map, key, value)
  end
end

Functional.hello()

Função Pura

Uma função pura é aquela que, para a mesma entrada, sempre retorna o mesmo resultado e não altera nenhum estado externo.

Exemplo de Função Pura em Elixir

defmodule Functional do
  def add(a, b) do
    a + b
  end
end

IO.puts Functional.add(2, 3) # Saída: 5

Função de Primeira Classe

Na programação funcional, funções podem ser atribuídas a variáveis e passadas como argumentos.

Exemplo de Função de Primeira Classe em Elixir

add = fn (a, b) -> a + b end
IO.puts add.(2, 3) # Saída: 5

Conclusão

A programação funcional proporciona uma abordagem poderosa e flexível para o desenvolvimento de software. Com Elixir, podemos escrever código que é ao mesmo tempo eficiente e fácil de manter. Ao adotar práticas como funções puras, composição de funções, imutabilidade e funções de alta ordem, conseguimos criar aplicações mais robustas, compreensíveis e menos propensas a erros.

Elixir se destaca por sua capacidade de lidar com concorrência e paralelismo de forma eficiente, aproveitando o modelo de atores do Erlang. Isso o torna ideal para sistemas distribuídos e aplicações de alta performance.

Se você está acostumado com a programação orientada a objetos, experimentar a programação funcional pode abrir novas perspectivas sobre como estruturar e organizar seu código. A simplicidade e a clareza proporcionadas pela programação funcional podem levar a um desenvolvimento mais rápido e a um código mais fácil de testar e manter.

Para aprofundar seu conhecimento em Elixir e programação funcional, recomendo explorar a documentação oficial de Elixir e praticar com exemplos reais. A adoção dessas técnicas pode transformar significativamente a maneira como você aborda a resolução de problemas no desenvolvimento de software.