Elixir - Funções

Uma função é um conjunto de instruções organizadas em conjunto para realizar uma tarefa específica. Funções em programação funcionam principalmente como funções em matemática. Você dá às funções alguma entrada, elas geram saída com base na entrada fornecida.

Existem 2 tipos de funções no Elixir -

Função anônima

Funções definidas usando o fn..end constructsão funções anônimas. Essas funções às vezes também são chamadas de lambdas. Eles são usados ​​atribuindo-os a nomes de variáveis.

Função nomeada

Funções definidas usando o def keywordsão funções nomeadas. Estas são funções nativas fornecidas no Elixir.

Funções anônimas

Assim como o nome indica, uma função anônima não tem nome. Freqüentemente, eles são passados ​​para outras funções. Para definir uma função anônima no Elixir, precisamos dofn e endpalavras-chave. Dentro deles, podemos definir qualquer número de parâmetros e corpos de função separados por->. Por exemplo,

sum = fn (a, b) -> a + b end
IO.puts(sum.(1, 5))

Ao executar o programa acima, é executado, ele gera o seguinte resultado -

6

Observe que essas funções não são chamadas como as funções nomeadas. Nós temos uma '.'entre o nome da função e seus argumentos.

Usando o operador de captura

Também podemos definir essas funções usando o operador de captura. Este é um método mais fácil de criar funções. Agora vamos definir a função de soma acima usando o operador de captura,

sum = &(&1 + &2) 
IO.puts(sum.(1, 2))

Quando o programa acima é executado, ele gera o seguinte resultado -

3

Na versão abreviada, nossos parâmetros não são nomeados, mas estão disponíveis para nós como & 1, & 2, & 3 e assim por diante.

Funções de correspondência de padrões

A correspondência de padrões não se limita apenas a variáveis ​​e estruturas de dados. Podemos usar a correspondência de padrões para tornar nossas funções polimórficas. Por exemplo, vamos declarar uma função que pode pegar 1 ou 2 entradas (dentro de uma tupla) e imprimi-las no console,

handle_result = fn
   {var1} -> IO.puts("#{var1} found in a tuple!")
   {var_2, var_3} -> IO.puts("#{var_2} and #{var_3} found!")
end
handle_result.({"Hey people"})
handle_result.({"Hello", "World"})

Quando o programa acima é executado, ele produz o seguinte resultado -

Hey people found in a tuple!
Hello and World found!

Funções Nomeadas

Podemos definir funções com nomes para que possamos nos referir facilmente a eles mais tarde. As funções nomeadas são definidas dentro de um módulo usando a palavra-chave def. As funções nomeadas são sempre definidas em um módulo. Para chamar funções nomeadas, precisamos referenciá-las usando seu nome de módulo.

A seguir está a sintaxe para funções nomeadas -

def function_name(argument_1, argument_2) do
   #code to be executed when function is called
end

Vamos agora definir nossa soma de função nomeada dentro do módulo Math.

defmodule Math do
   def sum(a, b) do
      a + b
   end
end

IO.puts(Math.sum(5, 6))

Ao executar o programa acima, ele produz o seguinte resultado -

11

Para funções de 1 linha, há uma notação abreviada para definir essas funções, usando do:. Por exemplo -

defmodule Math do
   def sum(a, b), do: a + b
end
IO.puts(Math.sum(5, 6))

Ao executar o programa acima, ele produz o seguinte resultado -

11

Funções Privadas

Elixir nos fornece a capacidade de definir funções privadas que podem ser acessadas de dentro do módulo em que estão definidas. Para definir uma função privada, usedefp ao invés de def. Por exemplo,

defmodule Greeter do
   def hello(name), do: phrase <> name
   defp phrase, do: "Hello "
end

Greeter.hello("world")

Quando o programa acima é executado, ele produz o seguinte resultado -

Hello world

Mas se apenas tentarmos chamar explicitamente a função de frase, usando o Greeter.phrase() função, isso gerará um erro.

Argumentos padrão

Se quisermos um valor padrão para um argumento, usamos o argument \\ value sintaxe -

defmodule Greeter do
   def hello(name, country \\ "en") do
      phrase(country) <> name
   end

   defp phrase("en"), do: "Hello, "
   defp phrase("es"), do: "Hola, "
end

Greeter.hello("Ayush", "en")
Greeter.hello("Ayush")
Greeter.hello("Ayush", "es")

Quando o programa acima é executado, ele produz o seguinte resultado -

Hello, Ayush
Hello, Ayush
Hola, Ayush