Funções

Mix.install([
  {:kino, "~> 0.10.0"}
])

Funções Nomeadas

Em Elixir você pode usar funções que já vem com Elixir, como String.upcase/1.

String.upcase("adolfo")

defmodule Matematica do
  def incrementa(x) do
    x+1    
  end
  # def soma(x, y) do
  #   x+y
  # end

  # def soma(x) do
  #   x
  # end

  def soma(x, y \\ 0), do: x+y
  
  def potencia(x, y \\ 1) do
    x ** y
  end
end

Matematica.incrementa(2)

Matematica.soma(34, 45)

Matematica.soma(34.5, 45.5)

# Matematica.soma("Adolfo ", "Neto")

"Adolfo" <> "Neto"

Matematica.soma(10)

2 ** 30

Matematica.potencia(2,30)

Matematica.potencia(2)

Matematica.potencia(100)

2 + 3

Kernel.+(2,3)

Kernel.+ 2, 3

Kernel.**(2,3)

Kino.Mermaid.new("""
flowchart TD
    A([Início]) --> B[/Digite as três notas/]
    B --> C[Lê n1, n2, n3]
    C --> D["Calcula média = (n1 + n2 + n3) / 3"]
    D --> E{média >= 6?}
    E -->|Sim| F["Exibe 'Aprovado(a)'"]
    F --> G["Exibe 'Parabéns!!!'"]
    G --> I["Exibe 'Tchau!'"]
    E -->|Não| H["Exibe 'Parabéns!!! Você está em recuperação!'"]
    H --> I
    I --> J([Fim])
""")

Funções anônimas (sem nome)

fn x -> x + 1 end

minha_universidade = "UTFPR"

minha_funcao = fn x, y -> x + y end

minha_universidade

minha_funcao.(2,3)

# :rand.uniform(100)

Minha_Funcao = fun(X,Y) -> X+Y end.

Minha_Funcao(2,3).

Evitem usar &

fn x, y -> x + y end

minha_funcao = &(&1+&2)

minha_funcao.(2,3)

divide = &(&2/&1)

divide.(4,2)

funcao_super_confusa = &(&2/&1*&3**&4+&1)

funcao_super_confusa.(5,2,3,5)

nome_completo = &amp;(&amp;1 <> " " <> &amp;2)
nome_completo.("Adolfo", "Neto")

# fn(x, y \\ 0) -> x+y end

Mais exemplos confusos

defmodule  TestePadrao do
  def f(x \\ 0, y, z \\ 3) do
    x+y*z
  end
end

TestePadrao.f(1,2)

Casamento de Padrões (Pattern Matching)

x = 3

x

y = 4

y

Tupla

{1, 45.5, "Adolfo"}

{nome, idade} = {"Adolfo", 100}

nome

idade

{filme, ano}  = {"Citizen Kane", 1941}

{filme, ano}

{"Citizen Kane", 1941} = {filme, ano} 

{filme, ano}  = {"Marca da Maldade", 1957}

{filme, ano}

# {^filme, ^ano}  = {"O Estranho", 1946}
{^filme, ^ano}  = {"Marca da Maldade", 1957}

{1, 2, 4}

["Adolfo" | [ 6 | [1, 2, 4] ]]

Tuple.to_list {1, 2, 4}

List.to_tuple([])

Casamento de Padrões em Listas

[cabeca | cauda] = ["55", "35", "00", "BRANCO"]

cabeca

cauda

[segunda | _ ] = cauda

segunda

{_nome, _idade, _peso, endereco} = {"Adolfo", 100, 1000, "Rua do Sol, 1000"}

endereco

[_, _, terceiro | _] = [1000, 789, 656, 345, 1, 1, 1, 1]

terceiro

[cabeca | cauda] = [55467]

cabeca

cauda

Casamento de Padrões em Funções

defmodule Urna do

  # def vota(numero) do
  #   if numero == 55 do
  #     "Voto pra Eduardo Pimentel"
  #   else
  #     "Voto pra Cristina Graeml"    
  #   end
  # end
  
  def vota(55), do: "Eduardo Pimentel"
  def vota(35), do: "Cristina Graeml"
  def vota("BRANCO"), do: "Voto em branco"
  def vota(_), do: "Voto nulo"
  
end

Urna.vota(55)

Urna.vota(35)

Urna.vota("BRANCO")

Urna.vota(00)

Urna.vota(78676)

Exemplo de Função com Casamento de Padrões

defmodule Listas do
  def inverte(lista = []) when is_list(lista)  do
    []
  end
  def inverte(lista = [valor]) when is_list(lista)  do
    [valor]
  end
  def inverte(lista = [cabeca | cauda]) when is_list(lista)  do
    inverte(cauda) ++ [cabeca]
  end
end

[1, 45, 900] ++ [56, 78, 44]

Listas.inverte([1, 45, 900, 56, 78, 44])

IO.inspect(Listas.inverte([10]), charlists: :as_lists)

[10, 28, 65, 66, 67]

[10, 65, 66, 67]

Listas.inverte ["a", "c", "x"]

Enum.reverse ["a", "c", "x"]

lista_valores_aleatorios = Enum.shuffle(1..1000000)

Enum.reverse(lista_valores_aleatorios)

Listas.inverte(lista_valores_aleatorios)