Continuação de Elixir para Novatos

O programa exemplo que o Wandbox nos fornece é o seguinte:

defmodule Wandbox do
    def hello() do
        IO.puts "Hello, Wandbox!"
    end
end
 
Wandbox.hello()

Neste programa é definido (usando defmodule) um Módulo (um agrupamento de funções) chamado Wandbox.

Neste módulo é definida uma função (usando def) chamada hello(). Uma função que não recebe nenhum argumento e que escreve na tela (usando o comando IO.puts) a mensagem “Hello, Wandbox!”.

Definir o módulo não é o suficiente para que a função seja executada.

Por isso, após o fim (end) das definições da função e do módulo, o programa chama a função hello() colocando antes o nome do módulo: Wandbox.hello().

Veja o programa também em https://gist.github.com/adolfont/5abe83aa670902bd038b40694f40c455.

defmodule LogicaClassicaProposicional do
  def nao(:v), do: :f
  def nao(:f), do: :v
end

alias LogicaClassicaProposicional, as: LCP

IO.inspect LCP.nao(:f)
IO.inspect LCP.nao(:v)

Neste programa, definimos o módulo LogicaClassicaProposicional.

Em seguida, definimos a função nao que recebe um argumento (usamos a notação nao/1) para representar esta situação. Adiante, veremos a função e/2 que recebe dois argumentos. Aridade é o termo que usamos para chamar a quantidade de argumentos de uma função. A função vista anteriormente, hello/0 tinha aridade zero; nao/1 tem aridade 1.

A função nao/1 é definida em duas clásulas.

Cada clásula é uma definição de função.

Neste exemplo, usamos o formato de definição de função de Elixir em uma linha. Você pode usar os dois. Ou seja, tanto faz escrever a primeira clásula de nao/1 como:

  def nao(:v), do: :f

quanto como:

  def nao(:v) do
   :f
  end

Outra novidade na definição desta função é o uso de constantes (também chamadas de átomos), que em Elixir são representadas colocando o símbolo de “dois pontos” (:) antes de uma cadeia de caracteres (letras, números e símbolos).

As constantes utilizadas são :v e :f, que usamos para representar, respectivamente, os valores-verdade “verdadeiro” e “falso”.

Utilizamos a linha alias LogicaClassicaProposicional, as: LCP para facilitar nossa digitação. O nome do módulo é significativo (isto é bom) mas longo. O comando alias estabelece que, dali em diante, LCP será o mesmo que LogicaClassicaProposicional. Sendo assim, nas linhas seguintes chamamos a função nao/1 apenas com LCP.nao(…).

Quando você clica em “Run” e executa o programa acima, o que aparece?

A primeira linha após o “Start” contém :v, para indicar que LCP.nao(:f) retorna :v. Ou seja, como vemos em Lógica, a negação do valor falso é o valor verdadeiro.

A segunda linha após o “Start” contém :f, para indicar que LCP.nao(:v) retorna :f. Ou seja, como vemos em Lógica, a negação do valor verdadeiro é o valor falso.

Observe também que, em vez do IO.puts/1 do Primeiro Programa Exemplo, aqui usamos IO.inspect/1, pois queremos mostrar constantes.

Veja em https://gist.github.com/adolfont/0017648a1ef12efe68a5b349fd14fcf8

Veja em https://gist.github.com/adolfont/e3c2047674dd6eea95eff828ca1fc51d

Observe a refatoração de e/2 antes da implementação de ou/2. Quando uma definição de uma função tem, em sua definição, um underline _, isto significa que pode receber qualquer valor. Agora talvez seja o momento de você tentar aprender um pouco de Casamento de Padrões (Pattern Matching). Um ótimo texto em inglês são: https://dev.to/flatironschool/pattern-matching-in-elixir-33m1 https://blog.carbonfive.com/2017/10/19/pattern-matching-in-elixir-five-things-to-remember/

Veja em https://gist.github.com/adolfont/69ddc3b76ad73d797fcc67124c74133f