Introdução à linguagem de programação Elixir

Se você está lendo posts de blogs, tópicos de notícias sobre hackers, tweets de seus desenvolvedores favoritos ou ouvindo podcasts, neste momento você provavelmente já ouviu falar sobre a linguagem de programação Elixir. A linguagem foi criada por Jose Valim, um desenvolvedor bem conhecido no mundo de código aberto. Você pode conhecê-lo pelo framework Ruby on Rails MVC ou pelas gems ruby ​​devise e simple_form que ele e seus colegas de trabalho da Plataformatec têm trabalhado nos últimos anos.

Segundo José Valim, a Elixir nasceu em 2011. Ele teve a ideia de construir a nova linguagem devido à falta de boas ferramentas para resolver os problemas de simultaneidade no mundo ruby. Naquela época, depois de passar um tempo estudando simultaneidade e linguagens com foco distribuído, ele encontrou duas linguagens que ele gostava, Erlang e Clojure que rodavam na JVM. Ele gostava de tudo o que via na linguagem Erlang (Erlang VM) e odiava as coisas que não via, como polimorfismo, metaprogramação e atributos de extensibilidade da linguagem nos quais Clojure era bom. Assim, Elixir nasceu com isso em mente, ter uma alternativa ao Clojure e uma linguagem dinâmica que roda na Máquina Virtual Erlang com bom suporte a extensibilidade.

Elixir se descreve como uma linguagem dinâmica e funcional com estado imutável e uma abordagem baseada em atores para simultaneidade projetada para construir aplicativos escaláveis ​​e de fácil manutenção com uma sintaxe simples, moderna e organizada. A linguagem é executada na Erlang Virtual Machine, uma máquina virtual à prova de batalha, de alto desempenho e distribuída, conhecida por suas características de baixa latência e tolerância a falhas.

Antes de vermos algum código, vale dizer que Elixir foi aceito pela comunidade que está crescendo. Se você quiser aprender Elixir hoje, encontrará facilmente livros, bibliotecas, conferências, encontros, podcasts, postagens em blogs, boletins informativos e todos os tipos de fontes de aprendizado disponíveis, assim como foi aceito pelos criadores do Erlang.

Vamos ver algum código!

Instale o Elixir:

A instalação do Elixir é super fácil em todas as principais plataformas e é simples na maioria delas.

Arch Linux

Elixir está disponível no Arch Linux através dos repositórios oficiais:

 pacman -S elixir

Ubuntu

Instalar o Elixir no Ubuntu é um pouco chato. Mas é bastante fácil mesmo assim.

 wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb && sudo dpkg -i erlang-solutions_1.0_all.deb apt-get update apt-get install esl-erlang apt-get install elixir

OS X

Instale o Elixir no OS X usando o Homebrew.

 brew install elixir

Conheça o IEx

Após a conclusão da instalação, é hora de abrir seu shell. Você passará muito tempo na sua concha se quiser desenvolver no Elixir.

O shell interativo do Elixir ou IEx é um REPL - (Read Evaluate Print Loop) onde você pode explorar o Elixir. Você pode inserir expressões lá e elas serão avaliadas, fornecendo feedback imediato. Lembre-se de que seu código é realmente avaliado e não compilado, portanto, certifique-se de não executar perfis nem benchmarks no shell.

O comando de quebra

Há uma coisa importante que você precisa saber antes de iniciar o IEx REPL - como sair dele.

Você provavelmente está acostumado a pressionar CTRL+C para fechar os programas em execução no terminal. Se você pressionar CTRL+C no IEx REPL, você abrirá o Menu Break. Uma vez no menu de interrupção, você pode pressionar CTRL+C novamente para sair do shell, além de pressionar a .

Eu não vou mergulhar nas funções do menu de pausa. Mas, vamos ver alguns ajudantes IEx!

Ajudantes

O IEx fornece vários auxiliares, para listar todos eles digite: h() .

E é isso que você deve ver:

Esses são alguns dos meus favoritos, acho que serão os seus também.

• h como acabamos de ver, esta função irá imprimir a mensagem auxiliar.
• h/1 que é a mesma função, mas agora espera um argumento.

Por exemplo, sempre que você quiser ver a documentação do método String strip/2 , você pode facilmente fazer:

Provavelmente o segundo auxiliar de IEx mais útil que você usará enquanto programa no Elixir é o c/2 , que compila um determinado arquivo de elixir (ou uma lista) e espera como segundo parâmetro um caminho para gravar os arquivos compilados.

Digamos que você esteja trabalhando em um dos exercícios do http://exercism.io/ Elixir, o exercício Anagram.

Então você implementou o módulo Anagram , que tem o método match/2 no arquivo anagram.exs. Como o bom desenvolvedor que você é, você escreveu algumas especificações para garantir que tudo funcione conforme o esperado.

Esta é a aparência do seu diretório atual:

Agora, para executar seus testes no módulo Anagram, você precisa executar/compilar os testes.

Como você acabou de ver, para compilar um arquivo, basta invocar o executável elixir passando como argumento path para o arquivo que deseja compilar.

Agora digamos que você queira executar o IEx REPL com o módulo Anagram acessível no contexto da sessão. Existem duas opções comumente usadas. A primeira é que você pode exigir o arquivo usando as opções -r , algo como iex -r anagram.exs . O segundo, você pode compilar diretamente da sessão IEx.

Simples, assim mesmo!

Ok, e se você quiser recompilar um módulo? Você deve sair do IEx, executá-lo novamente e compilar o arquivo novamente? Não! Se você tem uma boa memória, vai lembrar que quando listamos todos os helpers disponíveis no IEx REPL, vimos algo sobre um comando de recompilação. Vamos ver como isso funciona.

Observe que desta vez, você passou como argumento o próprio módulo e não o caminho do arquivo.

Como vimos, o IEx tem vários outros auxiliares úteis que ajudarão você a aprender e entender melhor como funciona um programa Elixir.

Noções básicas de tipos de elixir

Números

Existem dois tipos de números. Números inteiros de tamanho arbitrário e números de pontos flutuantes.

Inteiros

Os inteiros podem ser escritos na base decimal, hexadecimal, octal e binária.

Como em Ruby, você pode usar sublinhado para separar grupos de três dígitos ao escrever números grandes. Por exemplo, você poderia acertar cem milhões assim:

 100_000_000

Octal:

 0o444

Hexdecimal:

 0xabc

Binário:

 0b1011

Flutuadores

Floare são de precisão dupla IEEE 754. Eles têm 16 dígitos de precisão e um expoente máximo de cerca de 10308.

Os floats são escritos usando um ponto decimal. Deve haver pelo menos um dígito antes e depois do ponto. Você também pode anexar um expoente à direita. Por exemplo 1.0, 0.3141589e1 e 314159.0-e.

Átomos

Átomos são constantes que representam nomes. São valores imutáveis. Você escreve um átomo com dois pontos iniciais : e uma sequência de letras, dígitos, sublinhados e arroba @ . Você também pode escrevê-los com dois pontos à esquerda : e uma sequência arbitrária de caracteres entre aspas.

Atoms são uma ferramenta muito poderosa, eles são usados ​​para referenciar funções erlang assim como chaves e métodos Elixir.

Aqui estão alguns átomos válidos.

 :name, :first_name, :"last name", :===, :is_it_@_question?

Booleanos

Claro, booleanos são valores verdadeiros e falsos. Mas a coisa boa sobre eles é que no final das contas, eles são apenas átomos.

Cordas

Por padrão, as strings no Elixir são compatíveis com UTF-8. Para usá-los, você pode ter um número arbitrário de caracteres entre " ou ' . Você também pode ter expressões interpoladas dentro da string, bem como caracteres de escape.

Esteja ciente de que as strings entre aspas simples são, na verdade, uma lista de binários.

Funções anônimas

Como linguagem funcional, Elixir possui funções anônimas como tipo básico. Uma maneira simples de escrever uma função é fn (argument_list) -> body end . Mas uma função pode ter vários corpos com várias listas de argumentos, cláusulas de guarda e assim por diante.

Dave Thomas, no livro Programming Elixir, sugere que pensemos em fn…end como sendo as aspas que cercam um literal de string, onde em vez de retornar um valor de string estamos retornando uma função.

Tuplas

Tupla é uma matriz indexada imutável. Eles são rápidos para retornar seu tamanho e lentos para acrescentar novos valores devido à sua natureza imutável. Ao atualizar uma tupla, na verdade você está criando uma cópia totalmente nova da tupla self.

As tuplas são frequentemente usadas como o valor de retorno de uma matriz. Ao codificar no Elixir, você verá isso com frequência, {:ok, something_else_here} .

Veja como escrevemos uma tupla: {?a,?b,?c} .

Correspondência de padrões

Não poderei explicar tudo o que você precisa saber sobre Correspondência de padrões, mas o que você está prestes a ler abrange muito do que você precisa saber para começar.

Elixir usa = como um operador de correspondência. Para entender isso, precisamos desaprender o que sabemos sobre = em outras linguagens tradicionais. Em linguagens tradicionais, o operador equals é para atribuição. No Elixir, os operadores de igualdade são para correspondência de padrões.

Então, é assim que funciona os valores do lado esquerdo. Se forem variáveis, estão ligadas ao lado direito, se não forem variáveis, o elixir tenta combiná-las com o lado direito.

Operador de pinos

Elixir fornece uma maneira de sempre forçar a correspondência de padrões contra a variável do lado esquerdo, o operador de pino.

Listas

No Elixir, as Listas parecem arrays como conhecemos de outras linguagens, mas não são. Listas são estruturas vinculadas que consistem em uma cabeça e uma cauda.

Listas de palavras-chave

Listas de palavras-chave são uma lista de pares de Tuplas.

Você simplesmente os escreve como listas. Por exemplo: [{:um, 1}, 2, {:três, 3}]. Existe um atalho para definir listas, veja como fica: [um: 1, três: 3].

Para recuperar um item de uma lista de palavras-chave, você pode usar:

 Keyword.get([{:one, 1}, 2, {:three, 3}], :one)

Ou use o atalho:

 [{:one, 1}, 2, {:three, 3}][:one]

Como as listas de palavras-chave são lentas ao recuperar um valor, é uma operação cara, portanto, se você estiver armazenando dados que precisam de acesso rápido, deve usar um Map.

Mapas

Os mapas são uma coleção eficiente de pares chave/valor. A chave pode ter qualquer valor que você queira como chave, mas normalmente deve ser do mesmo tipo. Diferente das listas de palavras-chave, o Maps permite apenas uma entrada para uma determinada chave. Eles são eficientes à medida que crescem e podem ser usados ​​na correspondência de padrões Elixir em mapas de uso geral quando você precisa de um array associativo.

Veja como você pode escrever um mapa:

 %{ :one => 1, :two => 2, 3 => 3, "four" => 4, [] => %{}, {} => [k: :v]}

Conclusão

Elixir é incrível, fácil de entender, tem tipos simples, mas poderosos e ferramentas muito úteis ao seu redor, que o ajudarão quando começar a aprender. Nesta primeira parte, cobrimos os vários tipos de dados em que os programas Elixir são construídos e os operadores que os alimentam. Em partes posteriores iremos mergulhar mais fundo no mundo do Elixir - programação funcional e concorrente.