01/10/2024

Tipos Básicos

  1340

"Felipe Costa"

3.36666666

10 / 3

:age

Tipos básicos:

• Números inteiros
• Strings
• Números de ponto flutuante
• Átomos

Tipos complexos

[]

[1, 2, 3, 4, 5]

["elixir", :atom, 1, 2, 2.5]

{1, "José Valim"}

{2.7, "teste", []}

%{"Felipe" => 10, "Costa" => 5}

Map.keys(%{"Felipe" => 10, "Costa" => 5})

Map.values(%{"Felipe" => 10, "Costa" => 5})

Operadores

10/3

10 - 3

10 + 3 * 10

10 + 11

20 * 2

"AFRICA " <> "DO " <> "SUL"

Funções

String.upcase("brasil")

"BRASIL" == String.upcase("brasil")

String.capitalize("brasil")

String.at("Brasil", 2)

Criar suas próprias funções

defmodule Urna do
  def vota(nome_pessoa_candidata) do
    "Você votou em #{nome_pessoa_candidata}!"
  end

  def vota(numero, nome) do
    "Você votou em #{numero} - #{nome}!"
  end

  def vota(urna, numero, nome) do
    [{numero, nome} | urna] 
  end

  def resultado(urna) do
    urna
    |> Enum.map(fn {_numero, pessoa} -> pessoa end)
    |> Enum.frequencies()
    |> Map.to_list()
  end

  def mostra_vencedor(lista) do
    {nome_do_vencedor, votos} = Enum.max_by(lista, fn {_nome, votos} -> votos end)
    "A pessoa vencedora da eleição foi #{nome_do_vencedor} com #{votos} votos"
  end
end

Urna.vota("José Valim")

Urna.vota("Joe Armstrong")

Urna.vota(26, "Robert Virding")

urna = []

urna = Urna.vota(urna, 1, "José Valim")
urna = Urna.vota(urna, 2, "Robert Virding")
urna = Urna.vota(urna, 2, "Robert Virding")
urna = Urna.vota(urna, 3, "Joe Armstrong")
urna = Urna.vota(urna, 1, "José Valim")
urna = Urna.vota(urna, 4, "Mike Williams")

[]
 |> Urna.vota(1, "José Valim")
 |> Urna.vota(2, "Robert Virding")
 |> Urna.vota(2, "Robert Virding")
 |> Urna.vota(3, "Joe Armstrong")
 |> Urna.vota(1, "José Valim")
 |> Urna.vota(4, "Mike Williams")

[]
 |> Urna.vota(1, "José Valim")
 |> Urna.vota(2, "Robert Virding")
 |> Urna.vota(2, "Robert Virding")
 |> Urna.vota(3, "Joe Armstrong")
 |> Urna.vota(1, "José Valim")
 |> Urna.vota(4, "Mike Williams")
 |> Urna.vota(1, "José Valim")
 |> dbg()

Calculando quem ganhou (Depois que a eleição termina)

[]
 |> Urna.vota(1, "José Valim")
 |> Urna.vota(2, "Robert Virding")
 |> Urna.vota(2, "Robert Virding")
 |> Urna.vota(3, "Joe Armstrong")
 |> Urna.vota(1, "José Valim")
 |> Urna.vota(4, "Mike Williams")
 |> Urna.vota(1, "José Valim")
 |> Urna.vota(1, "José Valim")
 |> Urna.resultado()
 |> Urna.mostra_vencedor()
 |> dbg()

Funções do Módulo Enum

defmodule Math do
  def double(x) do
    x * 2
  end
end

Enum.map([10, 4, 3], &Math.double/1)

Enum.map([10, 5, 7], fn x -> x * 2 end)

Enum.map([1, 2, 3], &(&1 * 2))

  lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Enum.filter(lista, fn x -> rem(x, 2) == 0 end)

lista 
|> Enum.filter(&(rem(&1, 2) == 0)) 

Enum.map(lista, fn x -> x * x end)

lista = [10, 20, 30, 40, 50]

Enum.reduce(lista, 0, fn x, acc -> x + acc end)

lista 
|> Enum.reduce(0, &(&1 + &2))

lista = ["a", "b", "c", "d", "e"]

Enum.count(lista)

lista = [1, 3, 5, 7, 9]

Enum.find(lista, fn x -> x > 5 end)

lista
|> Enum.filter(fn x -> x > 5 end) 
|> Enum.map(fn x -> x end)  

lista = [-1, 2, 3, 4, 5]

Enum.any?(lista, fn x -> x < 0 end)

tuplas = [{1, "a"}, {2, "b"}, {1, "c"}, {2, "d"}]

Enum.group_by(tuplas, fn {key, _} -> key end)

lista = [5, 3, 8, 1, 4]

Enum.sort(lista)

lista = [1, 2, 2, 3, 4, 4, 5]

Enum.uniq(lista)

lista = [[1, 2], [3, 4], [5, 6]]

Enum.zip_with(lista, fn [x, y, z] -> x + y + z end)

lista = [1, 2, 3, 4, 5, 6]

Enum.chunk_every(lista, 2)

lista = [1, 2, 3, 4, 5]

Enum.sum(lista)

lista = [1, 2, 3, 4]

Enum.reduce(lista, 1, fn x, produto -> x * produto end)

lista = [10, 20, 30, 40]

defmodule CalcularMedia do
  def calcular_media(lista) do
    soma = Enum.sum(lista)
    contagem = Enum.count(lista)

    if contagem > 0 do
      soma / contagem
    else
      0
    end
  end
end

media = CalcularMedia.calcular_media(lista)
IO.puts(media)

lista  = [1, 2, 3, 4]

Enum.all?(lista, fn x -> x > 0 end)

lista1 = [1, 2, 3] 
lista2 = [4, 5, 6]

Enum.concat(lista1, lista2)

lista = ["a", "b", "c", "d"]

Enum.each(lista, fn x -> IO.puts(x) end)

lista = ["hello", "world"]

  Enum.reduce(lista, "", fn elemento, conc -> 
    if conc == "" do
       elemento
    else
       conc <> " " <> elemento
    end
  end)

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Enum.filter(lista, fn x -> rem(x, 3) == 0 end)

lista = [:apple, :banana, :apple, :orange, :banana, :banana]

Enum.frequencies(lista)

lista = ["apple", "banana", "cherry", "date", "fig"]

Enum.filter(lista, fn x -> String.length(x) > 4 end)

lista = [1, 2, 3, 4, 5]

Enum.map(lista, fn x -> x * 2 end)

lista = [7, 3, 1, 5, 9]

Enum.min(lista)

lista = [12, 4, 18, 7, 5]

Enum.max(lista)

lista = ["cat", "dog", "elephant", "tiger", "one"]

Enum.count(lista, fn x -> 
  String.length(x) < 5
  end)

lista = [2, 4, 6, 8, 10]

Enum.any?(lista, fn x -> rem(x, 2) == 0 end)

 lista = ["apple", "pear", "fig", "banana"]

Enum.group_by(lista, fn x -> String.length(x) end)

tuplas = [{1, "one"}, {2, "two"}, {3, "three"}]

Enum.map(tuplas, fn x -> 
  x
    |> Tuple.to_list()
    |> Enum.join(" - ")
  end)

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

lista 
   |> Enum.filter(fn x -> rem(x, 2) == 1 end)
   |> Enum.sum() 

lista = ["Hello", "World", "From", "Elixir"]

Enum.join(lista, " ")

lista = [1, 2, 3, 1, 2, 4, 5]

Enum.uniq(lista)

lista = ["a", "b", "a", "c", "b", "a"]

Enum.frequencies(lista)

lista = ["apple", "banana", "kiwi", "grape"]

Enum.filter(lista, fn word -> String.length(word) == 5 end)

lista = [1, 2, 3, 4, 5]

Enum.map(lista, fn x ->
  if rem(x, 2) == 1 do
    x * 2
  else
    nil
  end
  end) |> Enum.filter(& &1)

Structs

map = %{a: 1, b: 2}

map[:a]

map2 = %{map | b: 5}

map

map2

Exemplo de Struct Pessoa.

defmodule Pessoa do
  defstruct nome: "Henrique", idade: 25
end

%Pessoa{}

%Pessoa{nome: "João"}

%Pessoa{peso: 100}

Atribuindo uma Struct a uma variável

joao = %Pessoa{nome: "João"}

Acessando um campo de uma struct

joao.nome

joao.idade

“Modificando” uma struct com |

maria = %{joao | nome: "Maria"}

maria = %{joao | peso: 45}

Uso de Structs no casamento de padrões

%Pessoa{nome: nome_do_maria} = maria

nome_do_maria

Structs são bare maps (mapas simples)

is_map(joao)

O campo especial Struct:

joao.__struct__

jane = Map.put(%Pessoa{}, :nome, "Jane")

Map.merge(jane, %Pessoa{nome: "John"})

Map.keys(jane)

Valores padrões

defmodule Produto do
  defstruct [:nome]
end

%Produto{}

Você pode combinar valores padrão explícito com valor ‘nil’ implícito

defmodule Usuario do
  defstruct [:email, nome: "João", idade: 23]
end

%Usuario{}

Definindo chaves obrigatórias

defmodule Car do
  @enforce_keys [:make]
  defstruct [:model, :make]
end

%Car{}

%Car{make: "toyota"}

%Car{make: "toyota", model: "HILUX"}

Construtores, Redutores e Conversores

defmodule JogoDaVelha do
  defstruct [:tabuleiro, :jogadores, :jogador_da_vez, :vencedor]

  def new(jogador1, jogador2) do
    %__MODULE__{
      tabuleiro: ["", "", "", "", "", "", "", "", ""],
      jogadores: [jogador1, jogador2],
      jogador_da_vez: jogador1
    }
  end

  def joga(jogo, simbolo, x, y) do
    novo_tabuleiro = List.insert_at(jogo.tabuleiro, x - 1 + (y - 1) * 3, simbolo)
    [novo_jogador_da_vez] = jogo.jogadores -- [jogo.jogador_da_vez]
    %{jogo | tabuleiro: novo_tabuleiro, jogador_da_vez: novo_jogador_da_vez}
  end

  def jogador_da_vez(jogo) do
    jogo.jogador_da_vez
  end
  
end

Structs

defmodule Estudante do
  
  defstruct [:id, :nome, :idade, :matricula, :curso]

  def new(nome, idade, matricula, curso) do
    case verificar_idade(idade) do
      {:ok, idade} -> 
        %Estudante{
            id: :erlang.unique_integer([:positive]),
           nome: nome,
           idade: idade,
            matricula: matricula,
           curso: curso
        }
      {:error, _} -> "idade menor"
      _ -> "não tem idade"
    end
    
  end

  def add_estudante(estudantes, estudante) do
    [estudante | estudantes]
  end

  def delete_estudante(estudantes, matricula) do
    Enum.filter(estudantes, fn estudante -> estudante.matricula != matricula end)
  end

  def update_estudante(estudantes, matricula, novos_dados) do
    Enum.map(estudantes, fn estudante 
      when estudante.matricula == matricula ->
      Map.merge(estudante, novos_dados)
    estudante -> 
      estudante
      end)    
  end

  def imprimir_estudantes_cadastrados(estudantes) do
    Enum.map(estudantes, fn estudante -> estudante.nome end)
  end

  def listar_estudantes_por_curso(estudantes, curso) do
    Enum.filter(estudantes, fn estudante -> estudante.curso == curso end)
  end

  defp verificar_idade(idade) do
    if idade > 18 do
      {:ok, idade}
    else
      {:error, "digite uma idade maior que 18"}
    end
  end
end

estudantes = []

estudante1 = Estudante.new("Marcus", 19, 11111, "Engenharia de software")

estudante2 = Estudante.new("Sarah", 25, 12352, "Engenharia de software")

estudantes = Estudante.add_estudante(estudantes, estudante1)
estudantes = Estudante.add_estudante(estudantes, estudante2)

IO.inspect(estudantes, label: "Estudantes cadastrados")

estudantes = Estudante.delete_estudante(estudantes, 12352)

Estudante.imprimir_estudantes_cadastrados(estudantes)

IO.inspect(estudantes)

estudantes = Estudante.add_estudante(estudantes, estudante2)

Estudante.listar_estudantes_por_curso(estudantes, "Engenharia de software")