Introdução ao Elixir Lang

Publicados: 2015-02-27

Uma introdução à linguagem de programação Elixir (e por que eu a amo)

Eu escrevi um artigo há alguns meses apresentando Golang a você e por que eu amei tanto. Embora eu ainda ame, ultimamente tenho brincado com uma nova linguagem; Elixir. Comprei o livro Programming Elixir e estou acompanhando. Eu já passei a amar Elixir e espero mostrar o porquê neste artigo.

Enquanto eu trabalhava para o Couchbase alguns anos atrás, eu me interessei muito por Erlang e sistemas distribuídos. Para mim, Erlang é confuso. Quando vi Elixir, imediatamente soube que estava em algo bom. Elixir é detalhado como uma linguagem funcional e concorrente que roda sobre a VM Erlang.

Eu ouvi muitas vezes, pessoas dizendo que Elixir é 'Ruby para Erlang' etc. muitas das mesmas construções de programação. É, obviamente, semelhante em alguns aspectos ao Erlang, sendo construído sobre a Erlang VM e nos dando acesso direto às primitivas Erlang nativamente.

De qualquer forma, sem mais hesitação, vamos mergulhar e continuar com um pouco de Elixir.

Instalação

Se você estiver executando no OSX, a instalação é tão fácil quanto usar o Homebrew:
~ brew update
~ brew install erlang
~ brew install elixir

Depois de fazer isso, você deve ser capaz de executar:

~ elixir -v
> Elixir 1.0.2

Agora que o Elixir está instalado corretamente, podemos abrir um Elixir Interativo e brincar com alguns tipos básicos comuns.

Tipos de Elixir

Inicie um Interactive Elixir REPL digitando
> iex

Variáveis:

iex(1)> name = "rbin"
#=> "rbin"

Átomos:

No Elixir, um Atom é uma constante em que seu nome é seu próprio valor.
iex(2)> :this_is_an_atom
#=> :this_is_an_atom
iex(3)> :my_atom == :atom
#=> false

Tuplas:

Usamos a notação Curly Brace para definir Tuplas. No Elixir, as Tuplas são armazenadas imediatamente na memória, o que significa que obter o tamanho de uma Tupla ou acessar um elemento de Tupla é rápido, mas atualizar ou adicionar elementos é caro, pois requer a cópia de toda a tupla na memória.

iex(4)> tuple = {:hello, "world"}
#=> {:hello, "world"}
iex(5)> elem(tuple, 1)
#=> "world"

Listas:

No Elixir, as listas são armazenadas na memória, como listas vinculadas. Podemos atualizar listas trivialmente acrescentando elementos, mas anexar elementos é mais caro, pois precisamos percorrer toda a lista para descobrir seu tamanho.

iex(8)> list = [1, 2, :atom]
#=> [1, 2, :atom]
iex(9)> ["string"] ++ list
#=> ["string", 1, 2, :atom]
iex(10)> list ++ [31]
#=> [1, 2, :atom, 31]

Existem funções embutidas muito úteis para serem usadas com listas, incluindo obter o Head & Tail de uma lista.

iex(11)> hd(list)
#=> 1
iex(12)> tl(list)
#=> [2, :atom]

Funções anônimas:

No Elixir, as funções são cidadãos de primeira classe, o que significa que podemos passar funções como argumentos para outras funções. Abaixo, definiremos uma variável chamada add que contém uma função, que passaremos como argumento para a função is_function/1 .

iex(14)> add = fn a, b -> a + b end
#Function<12.90072148/2 in :erl_eval.expr/5>

iex(15)> add.(13, 31)
#=> 44

iex(16)> is_function(add)
#=> true

Organizando Nossos Projetos (Mix)

Elixir vem com uma ferramenta super útil chamada Mix. Mix é uma ferramenta de construção que nos permite gerar, organizar, compilar e testar nossos projetos com muita facilidade. Também facilita o gerenciamento de dependências. (Sempre um assunto delicado!) Para criar um novo projeto com o Mix, basta fazer o seguinte:
~ mix new myapp --module MyApp
Isso criará um diretório chamado myapp com alguns arquivos dentro. Ele também definirá um módulo MyApp dentro de lib/myapp.ex .
* creating README.md
* creating .gitignore
* creating mix.exs
* creating config
* creating config/config.exs
* creating lib
* creating lib/myapp.ex
* creating test
* creating test/test_helper.exs
* creating test/myapp_test.exs


Your mix project was created successfully.
You can use mix to compile it, test it, and more:
cd myapp
mix test
Como podemos ver, obtemos todos os arquivos necessários para uma estrutura básica do projeto. Eu acho que este é um dos recursos mais agradáveis ​​disponíveis que acompanham o Elixir. Ter ferramentas de gerenciamento de projetos é super útil e economiza muito tempo.

O arquivo mix.exs é o arquivo principal usado para configurar nosso projeto, e gerenciar dependências etc. Obtemos um test/folder , no qual podemos escrever testes muito parecidos com ruby ​​para nosso projeto. É claro que obtemos uma lib/folder , que contém os arquivos de origem do nosso projeto. Se executarmos o teste de mistura em nosso aplicativo, obteremos o seguinte:
$ mix test
Compiled lib/myapp.ex
Generated myapp.app
.
Finished in 0.04 seconds (0.04s on load, 0.00s on tests)
1 tests, 0 failures
Randomized with seed 543313

Simultaneidade

Assim como Erlang, Elixir usa o modelo 'Actor' para simultaneidade. Todo o nosso código é executado dentro de Processes e esses processos são isolados uns dos outros. Podemos fazer programas totalmente simultâneos no Elixir gerando Processos e enviando e recebendo mensagens entre eles.

No Elixir, iniciamos os processos usando a função spawn , que recebe outra função como argumento.

iex(1)> spawn(fn -> IO.puts 1 + 1 end)
#=> 2
#PID<0.55.0>

Como você pode ver, geramos um processo que gerou 1 + 1 e também retornou o ID do processo. Retornar esse ID do processo é útil, pois podemos atribuí-lo a uma variável e usá-lo para enviar mensagens ao processo. Antes de fazermos isso, precisamos criar um mecanismo de recebimento para obter as mensagens que enviamos para o processo. (Podemos ir em frente e fazer isso em nossa sessão de Elixir Interativo , linha por linha.)

Depois de fazer isso, podemos criar um processo que avalia area_loop e atribuí-lo a pid .

pid = spawn(fn -> Geometry.area_loop() end)
#=> #PID<0.40.0>

Podemos então enviar mensagens para o pid que nosso código predefinido irá corresponder, dependendo se ele recebe o átomo :rectangle ou o átomo :circle .

send pid, {:rectangle, 2, 3}
#=> Area = 6
# {:rectangle,2,3}

send pid, {:circle, 2}
#=> Area = 12.56000000000000049738
# {:circle,2}

Podemos verificar se os processos ainda estão em execução usando o método Process.alive? função.

Process.alive?(pid)
#=> false

Conclusão

Nós nem arranhamos a superfície neste blog. Há tantos recursos incríveis no Elixir, espero que você vá conferir por si mesmo. Listei alguns recursos de aprendizado abaixo para ajudá-lo ao longo do caminho, mas antes de sair e mergulhar, aqui estão algumas das minhas coisas favoritas sobre o Elixir:

  • Era fácil de entender, com uma sintaxe semelhante a Ruby e primitivos semelhantes a Erlang
  • Tem uma comunidade fantástica por trás disso
  • Seu modelo de simultaneidade é familiar para mim e muito poderoso
  • Mix é uma dádiva de Deus e economiza MUITO tempo
  • Elixir nos encoraja a documentar tudo
  • Torna a criação de aplicativos distribuídos um campo de batalha muito menos confuso
  • Eu posso ver Elixir indo longe.

Recursos

Alguns recursos que achei muito úteis no meu curto tempo aprendendo Elixir:

  • http://elixir-lang.org/getting-started/introduction.html
  • https://pragprog.com/book/elixir/programming-elixir
  • https://teamgaslight.com/blog/the-best-resources-for-learning-elixir
  • http://exercism.io

* Vá em frente e saboreie esse Elixir! – @rbin*