[ { "path": ".gitignore", "content": "*.psd\n*.dump" }, { "path": "README.md", "content": "

\n \n \"Logo\"\n \n

\n\n

\n Elixir4Noobs desenvolvido por aleDsz\n
\n \n \"License\n \n

\n\n

\n O curso básico/iniciante está finalizado :)\n
\n Explore a documentação »\n
\n
\n Report Bug\n
\n Request Feature\n

\n\n## Conteúdos\n\n1. Introdução\n - [Sobre o Projeto](./contents/1%20-%20Introducao/1-Sobre%20o%20projeto.md)\n - [Pré-requisitos](./contents/1%20-%20Introducao/2-Pre-requisitos.md)\n * [Conhecimentos Necessários](./contents/1%20-%20Introducao/2-Pre-requisitos.md#conhecimentos-necessários)\n * [Instalação](./contents/1%20-%20Introducao/2-Pre-requisitos.md#instalação)\n2. Ambiente\n - [Como começar?](./contents/2%20-%20Ambiente/1-Como%20comecar.md)\n3. Linguagem\n - [Sobre a linguagem](./contents/3%20-%20Linguagem/1-Sobre%20a%20linguagem.md)\n * [Extensão](./contents/3%20-%20Linguagem/1-Sobre%20a%20linguagem.md#extensão)\n - [Paradigma](./contents/3%20-%20Linguagem/2-Paradigma.md)\n - [Expressões](./contents/3%20-%20Linguagem/3-Expressoes.md)\n - [Sintaxe](./contents/3%20-%20Linguagem/4-Sintaxe.md)\n - [Variáveis](./contents/3%20-%20Linguagem/8-Variaveis.md)\n * [Tipos](./contents/3%20-%20Linguagem/8-Variaveis.md#tipos)\n - [Módulos](./contents/3%20-%20Linguagem/5-Modulos.md)\n * [Funções](./contents/3%20-%20Linguagem/5-Modulos.md#funções)\n - [Estruturas de Repetição](./contents/3%20-%20Linguagem/6-Estruturas%20de%20Repeticao.md)\n - [Estruturas de Decisão](./contents/3%20-%20Linguagem/7-Estruturas%20de%20Decisao.md)\n4. Recursos extras\n - [Gerenciador de Pacotes](./contents/4%20-%20Recursos%20extras/1-Gerenciador%20de%20Pacotes.md)\n * [Terminal Interativo](./contents/4%20-%20Recursos%20extras/1-Gerenciador%20de%20Pacotes.md#terminal-interativo)\n - [Testes](./contents/4%20-%20Recursos%20extras/2-Testes.md)\n - [Pattern Matching](./contents/4%20-%20Recursos%20extras/3-Pattern%20Matching.md)\n - [Bibliotecas](./contents/4%20-%20Recursos%20extras/4-Bibliotecas.md)\n - [Operador Pipe](./contents/4%20-%20Recursos%20extras/5-Operador%20Pipe.md)\n\n## Quero contribuir\n\nPara contribuir com esse projeto maravilhoso, você:\n\n1. Precisará criar um fork deste repositório\n2. Criar um branch com o padrão: `feature/awesome-commit`\n3. Criar seu conteúdo maravilhoso nesta branch\n4. Criar um pull-request neste repositório lindo\n5. Esperar a avaliação do mesmo\n\nE tchadam! Tá pronto o sorvetinho ✨\n\n## Autores\n\n- **Alexandre de Souza (aleDsz)** - _Alchemist & Developer_ [Twitter](https://twitter.com/aleDsz)\n\n

\n Made with 💜\n

\n" }, { "path": "contents/1 - Introducao/1-Sobre o projeto.md", "content": "# 1.1 - Sobre o Projeto\n\nSejam bem-vindos ao curso de Elixir (uma contribuição ao projeto da **He4rt Developers**).\n\nEsse projeto tem como objetivo auxiliar todos os desenvolvedores iniciantes na programação funcional.\n\nFicamos imensamente felizes com seu interesse em aprender uma linguagem nova. Este curso, nos próximos passos, mostrará todo o básico necessário para que você possa sair daqui já com conhecimento apra desenvolver pequenas funcionalidades utilizando **Elixir**." }, { "path": "contents/1 - Introducao/2-Pre-requisitos.md", "content": "# 1.2 - Pré-requisitos\n\n## Conhecimentos Necessários\n\nPara que você possa compreender tranquilamente neste curso, é necessário que você tenha conhecimentos básicos em qualquer outra linguagem, por exemplo:\n\n * PHP\n * Javascript\n * Ruby (preferencialmente)\n * Python\n * C#\n * Java\n\nQualquer uma destas linguagens acima, já é o suficiente. Mas claro, se você souber outra linguagem que não esteja listada, também será bem útil para prosseguirmos.\n\n## Instalação\n\nPara começarmos, precisamos instalar o **Elixir** e **Erlang** em seu ambiente. Para isso, existem algumas formas de se instalar ambas as linguagens.\n\n### Erlang\n\n#### Windows\n\nNo Windows conseguimos instalar via [web](http://www.erlang.org/download.html) ou via [chocolatey](https://chocolatey.org/).\n\nPara instalar via Chocolatey, você pode executar via PowerShell ou pelo Prompt de Comando.\n\n**Lembrando que ambos precisam executar como administrador**\n\n```batch\n# Novas versões do Chocolatey\ncinst erlang\n\n# Versões antigas do Chocolatey\nchoco install erlang\n```\n\n#### macOS\n\nNo Mac conseguimos instalar via Homebrew ou Macports.\n\nPara instalar via Homebrew, você executará em ser terminal:\n\n```sh\nbrew install erlang\n```\n\nPara instalar via Macports, você executará em ser terminal:\n\n```sh\nsudo port install erlang\n```\n\n#### Unix\n\n * Ubuntu/Linuxmint:\n\n Para instalar no Ubuntu ou Linuxmint, é necessário adicionar o repositório do Erlang na sua lista de pacotes do Aptitude.\n\n Para isso, é necessário executar alguns comandos no seu terminal:\n\n ```sh\n # Atualizar lista de pacotes\n sudo apt-get update\n sudo apt-get -y upgrade\n\n # Adicionar lista de pacotes ao Aptitude\n wget https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb\n sudo dpkg -i erlang-solutions_2.0_all.deb\n\n # Instalar o Erlang\n sudo apt-get update\n sudo apt-get install esl-erlang\n ```\n\n * Arch Linux:\n\n Para instalar no Arch Linux é necessário executar apenas um comando no seu terminal:\n\n ```sh\n pacman -S erlang\n ```\n\n * openSUSE:\n\n Para instalar no openSUSE é necessário adicionar o repositório do Erlang na sua lista de pacotes.\n\n Para isso, é necessário executar alguns comandos no seu terminal:\n\n ```sh\n zypper ar -f obs://devel:languages:erlang:Factory Erlang-Factor\n zypper install erlang\n ```\n\n### Elixir\n\n#### Windows\n\nNo Windows conseguimos instalar via [web](https://repo.hex.pm/elixir-websetup.exe) ou via [chocolatey](https://chocolatey.org/).\n\nPara instalar via Chocolatey, você pode executar via PowerShell ou pelo Prompt de Comando.\n\n**Lembrando que ambos precisam executar como administrador**\n\n```batch\n# Novas versões do Chocolatey\ncinst elixir\n\n# Versões antigas do Chocolatey\nchoco install elixir\n```\n\n#### macOS\n\nNo Mac conseguimos instalar via Homebrew ou Macports.\n\nPara instalar via Homebrew, você executará em ser terminal:\n\n```sh\nbrew install elixir\n```\n\nPara instalar via Macports, você executará em ser terminal:\n\n```sh\nsudo port install elixir\n```\n\n#### Unix\n\n * Ubuntu/Linuxmint:\n\n Para instalar no Ubuntu ou Linuxmint é necessário executar alguns comandos no seu terminal:\n\n ```sh\n # Instalar o Elixir\n sudo apt-get update\n sudo apt-get install elixir\n ```\n\n * Arch Linux:\n\n Para instalar no Arch Linux é necessário executar apenas um comando no seu terminal:\n\n ```sh\n pacman -S elixir\n ```\n\n * openSUSE:\n\n Para instalar no openSUSE é necessário executar alguns comandos no seu terminal:\n\n ```sh\n zypper ar -f obs://devel:languages:erlang/ Elixir-Factory\n zypper refresh\n zypper install elixir\n ```\n * Void Linux\n \n Para instalar no Void Linux é necessário executar apenas um comando no seu terminal:\n \n ```sh\n xbps-install -S elixir\n ```\n\n\n**OBS.:** Para que tudo funcione corretamente, é estritamente necessário que Elixir e Erlang estejam instalados em seu computador.\n\nPara testar a instalação de ambos, você pode executar este comando em seu terminal:\n\n```\n→ C:\\Users\\aleDsz› elixir --version\nErlang/OTP 21 [erts-10.2] [64-bit] [smp:12:12] [ds:12:12:10] [async-threads:1]\n\nElixir 1.8.2 (compiled with Erlang/OTP 20)\n```\n\nPara continuar, é válido frisar que o curso foi feito em cima do Elixir na versão **1.8.2**\n" }, { "path": "contents/2 - Ambiente/1-Como comecar.md", "content": "# 2.1 - Como começar?\n\nSe você chegou nesse passo, acredito que esteja pensando em qual IDE ou qual editor de texto você precisa instalar para começar a desenvolver.\n\nBom, você não precisa se preocupar tanto com isso, pois você pode usar até um bloco de notas para tal 😅\n\nBrincadeiras a parte, você pode escolher estes editores:\n\n - [Sublime Text 3](https://www.sublimetext.com/3)\n - [Visual Studio Code](https://code.visualstudio.com/download)\n - [Atom](https://atom.io/)\n - [Vim](https://www.vim.org/download.php)\n\nPara que seu desenvolvimento seja mais intuitivo, você pode instalar esta lista de extensões para cada Editor de texto acima:\n\n## Extensões\n\n### Sublime text\n\nPara instalar as extensões para o Sublime Text, você precisa destas extensões:\n\n - Elixir\n - ElixirSublime\n - ElixirSyntax\n\nPara isso, você precisa instalar o [Controle de Pacotes do Sublime](https://packagecontrol.io/installation#st3) e depois executar os comandos em seu Sublime Text:\n\n1. `Control + Shift + P` (Windows/Linux) ou `Command + Shift + P` (macOS)\n2. Digitar `Package Control: Install Package` e pressionar `Enter`.\n3. Digitar o nome dos pacotes, um por um, e pressionar `Enter`.\n\n### Visual Studio Code\n\nPara instalar as extensões para o Visual Studio Code, você precisa destas extensões:\n\n - ElixirLS: Elixir support and debugger\n - vscode-elixir\n - vscode-elixir-syntax\n\nPara isso, você precisa executar os comandos em seu Visual Studio Code:\n\n1. `Control + Shift + X` (Windows/Linux) ou `Command + Shift + X` (macOS)\n2. Digitar o nome das extensões, um por um, e clicar em `Install`.\n\n### Atom\n\nPara instalar as extensões para o Atom, você precisa destas extensões:\n\n - atom-ide-ui\n - ide-elixir\n\nPara isso, você precisa executar os comandos em seu Atom:\n\n```sh\napm install atom-ide-ui\napm install ide-elixir\n```\n\n### Vim\n\nPara instalar as extensões para o Vim, você precisa destas extensões:\n\n - vim-elixir\n - coc.nvim\n - coc-elixir\n\nSe você utiliza Vim, você sabe que é necessário instalar tudo pelo arquivo `.vimrc`.\n\nPorém, para instalar o `coc-elixir`, você precisa rodar este comando no Vim:\n\n```sh\n:CocInstall coc-elixir\n```" }, { "path": "contents/3 - Linguagem/1-Sobre a linguagem.md", "content": "# 3.1 - Sobre a linguagem\n\nElixir é uma linguagem de programação funcional, concorrente, de propósito geral que executa na máquina virtual Erlang (BEAM). Elixir compila em cima de Erlang para fornecer aplicações distribuídas, em tempo real suave, tolerante a falhas, non-stop, mas também a estende para suportar metaprogramação com macros e polimorfismo via protocolos.\n\nJosé Valim é o criador da linguagem de programação Elixir, um projecto de R&D da Plataformatec, uma subsidiária do Nubank. Seus objetivos foram permitir uma maior extensibilidade e produtividade no Erlang VM, mantendo a compatibilidade com ferramentas e ecossistema de Erlang.\n\n## Extensão\n\nNo Elixir, os arquivos que precisam serem compilados no projeto necessariamente são salvos como `.ex`.\n\nQuando você cria um arquivo que não será compilado, você irá salvá-lo como `.exs`, como é o caso dos testes unitários.\n\nExistem outras extensões como `.eex`, que este é interpretado pelo EEx, que é uma aplicação do Elixir para leitura e interpretação de código Elixir para gerar uma valor final.\n\nUm exemplo disso é a renderização de HTML, que pode conter código Elixir no meio deste, mas só é interpretado quando renderizado pelo [EEx](https://elixirschool.com/pt/lessons/specifics/eex/) (Elixir embutido)." }, { "path": "contents/3 - Linguagem/2-Paradigma.md", "content": "# 3.2 - Paradigma\n\nDe maneira simples, o paradigma funcional é uma sequência de funções e/ou passos os quais meu código executará para resolver um problema.\n\nDiferentemente da [Programação Orientado a Objetos](https://pt.wikipedia.org/wiki/Orienta%C3%A7%C3%A3o_a_objetos) (POO), ele não trabalha em cima de entidades que possuem características e comportamentos, ou seja, você apenas orienta o seu sistema em quais passos, utilizando funções, o dado de entrada do seu sistema irá passar até o ponto em que ele se tornar o dado de saída.\n\n## Imutabilidade\n\nNa programação funcional uma variável não é de fato uma viarável pois a imutabilidade proíbe que os dados variem. Mas não se preocupe, não leve isso para o literal, pois explicarei direitinho como isso funciona no decorrer do curso.\n\nPara explicar melhor, irei citar um artigo do [Medium](https://medium.com/trainingcenter/programa%C3%A7%C3%A3o-funcional-para-iniciantes-9e2beddb5b43) que exemplifica bem essa ideia:\n\n A imutabilidade faz sentido dentro da programação funcional pelo seu viés matemático. Nela, um número\n sempre será aquele valor, independente de onde esteja ou como está sendo usado. É importante também\n entender que nas expressões matemáticas, para um mesmo valor passado a uma variável, teremos o mesmo\n retorno da função. Ele nunca muda. Se você tem uma expressão como f(x) = x + 2, você pode passar o\n número 3 quantas vezes quiser, esta função sempre retornará 5. Um último ponto é que o número 3\n passado para x, não irá mudar seu valor, ou seja, ele permanece inalterado após o seu uso na função.\n\nEntendendo o que fora citado acima, podemos dizer que tudo que está fora do mesmo contexto, não altera os dados de outros contextos.\n\nPara entender melhor, podemos seguir com este código:\n\n```elixir\n# Definição da \"variável\"\niex> idade = 20\n20\n\n# Função anônima para alterar a idade\niex> funcao = (fn -> idade = 30 end)\n#Function<20.128620087/0 in :erl_eval.expr/5>\n\n# Execução da função\niex> funcao.()\n30\n\n# Exibição da \"variável\"\nIO.inspect idade\n20\n```\n\nNo código acima, percebemos que a variável `idade` não teve seu valor original alterado pela função anônima `funcao`.\n" }, { "path": "contents/3 - Linguagem/3-Expressoes.md", "content": "# 3.4 - Tudo é uma Expressão\n\nQuando dizemos que no Elixir tudo é considerado uma expressão é por conta que Elixir sempre retorna um resultado. Isso acontece por que dentro dele tudo é considerado uma expressão e toda expressão deve retornar um valor, ou seja não há declarações sem retorno de algum valor. Por exemplo os códigos abaixo que foram feitos como exemplo para explicar o Paradigma da linguagem, irei replicar os mesmos acrescentado alguns comentarios para que vocês entenda.\n\n```elixir\n# Basicamente estamos declarando uma variavel aqui,\n# e como disse não temos declarações sem retorno de valor.\n# Então ele vai simplesmente imprimir para a gente o valor da variavel,\n# comparando com linguagens imperativas o ato de declarar a variavel não traria nenhum retorno, \n# a não ser se a gente fizesse de maneira implícita.\n# O mesmo comportamento acontece nos códigos abaixo deste.\niex> idade = 20\n20\n\n# Função anônima para alterar a idade\niex> funcao = (fn -> idade = 30 end)\n#Function<20.128620087/0 in :erl_eval.expr/5>\n\n# Execução da função\niex> funcao.()\n30\n\n# Exibição da \"variável\"\nIO.inspect idade\n20\n```\n\nEntão sabendo disso o nosso programa em si fica melhor e mais légivel, natural por que cada instrução sempre vai retornar alguma coisa por si mesma, isso acaba deixando o fluxo da execução do nosso programa bem mais evidente.\n\n# Observações\n\n- Sabendo que no Elixir tudo é tratado como uma expressão e toda expressão retorna algo então a gente não precisa declarar um return, ele sempre vai retornar a ultima expressão." }, { "path": "contents/3 - Linguagem/4-Sintaxe.md", "content": "# 3.4 - Sintaxe\n\nA sintaxe do Elixir se assemelha muito com o [Ruby](https://www.ruby-lang.org/pt/), o que facilita muito para programadores que estão migrando do Ruby para Elixir.\n\nResumidamente, a linguagem foi criada com uma sintaxe agradável e pouco verbosa para resolver a maioria dos problemas. Ou seja, o que você teria de escrever em 10 linhas em uma linguagem POO, você consegue com apenas 3~6 linhas com Elixir, e este não fica tão complexo de entender.\n\n

\n \"Sintaxe\"\n

\n\nOutra coisa que precisa-se frisar, é que o Elixir trabalha com identação utilizando espaços de tamanho 2 (conforme descrito no rodapé do Visual Studio Code)" }, { "path": "contents/3 - Linguagem/5-Modulos.md", "content": "# 3.6 Módulos\n\nDentro de uma aplicação feita em Elixir, para que você tenha acesso à um conjunto de funções descritas dentro de um arquivo, utiliza-se **Módulos** para que, quando compilado, você não precise carregar um arquivo parar executar uma função.\n\nEntão, você define um módulo o qual pode conter dentro:\n\n - uma Struct (como explicado na lição anterior);\n - funções;\n - uma [Macro](https://elixirschool.com/pt/lessons/advanced/metaprogramming/) (metaprogramação);\n - um [Guard](https://elixirschool.com/pt/lessons/basics/functions/#guards) (`pattern matching`);\n - um [Protocolo](https://elixirschool.com/pt/lessons/advanced/protocols/).\n\n```elixir\ndefmodule Modulo do\n # Hello darkness, my old friend...\nend\n```\n\nDentro e/ou fora dos módulos é possível que você inclua-os dentro do seu código para a execução de funções dentro dos mesmos.\n\nExistem 4 formas de se fazer isso:\n\n - **alias**\n - **import**\n - **require**\n - **use** ([metaprogramação](https://elixirschool.com/pt/lessons/advanced/metaprogramming/))\n\n### Alias\n\nQuando realizamos uma *alias*, estamos definindo um \"apelido\" ao módulo para ser utilizado dentro do nosso contexto (sendo ele um módulo ou um script [.exs]):\n\n```elixir\ndefmodule MyApp.A do\n def funcao() do\n 1 + 1\n end\nend\n\ndefmodule MyApp.B do\n alias MyApp.A\n\n def funcao() do\n A.funcao() # 2\n end\nend\n```\n\n### Import\n\nJá no import, utilizando esse para literalmente importar todas as funções de um módulo para outro como se fossem funções do próprio módulo:\n\n```elixir\ndefmodule MyApp.A do\n def funcao() do\n 1 + 1\n end\n\n def funcao2() do\n 1 + 1\n end\nend\n\ndefmodule MyApp.B do\n import MyApp.A\n\n def funcao3() do\n funcao() + funcao2() # 4\n end\nend\n```\n\n**Curiosidade:** Você pode importar funções específicas de um módulo apenas para o mesmo não demore para ser compilado defivo à tantas funções dentro do módulo `MyApp.A`:\n\n```elixir\ndefmodule MyApp.A do\n def funcao() do\n 1 + 1\n end\n\n def funcao2() do\n 1 + 1\n end\n\n def funcao3() do\n 1 + 1\n end\n\n def funcao4(a, b, c, d \\\\ 0) do\n 1 + 1\n end\n \n # ...\nend\n\ndefmodule MyApp.B do\n import MyApp.A, only: [funcao1: 0, funcao2: 0]\n\n def funcao3() do\n funcao() + funcao2() # 4\n end\nend\n```\n\n**Curiosidade 2:** Você também pode apenas importar uma mesma função porém com o tamanho específico de argumentos. Ou seja, por conta do *pattern matching* e de argumentos opcionais, é possível que uma mesma função do mesmo nome exista mais de uma vez dentro do contexto do Módulo.\n\nIsso quer dizer que, `funcao4/3` e `funcao4/4` é a mesma função porém uma com apenas 3 argumentos e uma com 4 argumentos, visto que o 4º argumento é opcional pois ele tem já um valor pré-definido como `0`.\n\n### Require\n\nDevido ao uso de metaprogramação, é possível executar Macros diretamente de um módulo quando utilizamos o \"requerimento\" de outro módulo. Um exemplo é o módulo de logs do Elixir, que só é possível usar quando executamos o require dele:\n\n```elixir\niex> Logger.info(\"Test\")\n** (CompileError) iex:1: you must require Logger before invoking the macro Logger.info/1\n (elixir) src/elixir_dispatch.erl:97: :elixir_dispatch.dispatch_require/6\n\niex> require Logger\nLogger\n\niex> Logger.info(\"Test\")\n03:39:21.479 [info] Test\n:ok\n```\n\n## Funções\n\nAssim como outras linguagens, você pode definir funções (e não métodos) para execução de dos passos a serem seguidos para o tratamento do dado recibido por tal. Você também pode definir funções privadas e públicas.\n\n```elixir\ndefmodule Modulo do\n def minha_funcao_publica() do\n 1 + minha_funcao_privada()\n end\n\n defp minha_funcao_privada() do\n 1\n end\nend\n```\n\nNo exemplo acima, colocamos uma função pública que chama a função privada para a execução do código. Isso é um bom exemplo do que conversamos anteriormente sobre o paradigma funcional.\n\nVocê, por padrão, apenas deixa funções públicas as quais serão chamadas por outros módulos, e deixa funções privadas dentro de um módulo quando seguimos um passo-a-passo para o processamento de um dado até que se torne uma informação na hora de retornar isso para a outro ponta (seja ela uma API, um serviço, etc.).\n\n**Curiosidade:** Os nomes de funções são em **snake_case** e o nome dos módulos sempre em maiúsculo, ou o interpretador não entenderá o mesmo como um módulo.\n\nA não ser que você defina a referencia de um módulo em uma variável. Exemplo:\n\n```elixir\niex> defmodule A do\n...> def executar(x) do\n...> x * 2\n...> end\n...> end\niex> x = A\niex> x.executar(2)\n4\n```\n\n### Funções anônimas\n\nNo Elixir também é possível criar funções privadas dentro do mesmo contexto, podendo ser repassada para outros contextos por meio dos parâmetros das funções:\n\n```elixir\niex> funcao = (fn x ->\n...> x * 30\n...> end)\n#Function<20.128620087/0 in :erl_eval.expr/5>\niex> funcao2 = (fn func ->\n...> func.(10)\n...> end)\n#Function<20.128620087/0 in :erl_eval.expr/5>\niex> funcao2.(funcao)\n300\n```" }, { "path": "contents/3 - Linguagem/6-Estruturas de Repeticao.md", "content": "# 3.6 Estruturas de Repetição\n\nPara realizar um *looping* dentro de uma lista, existem algumas formas interessantes de se fazer isso.\n\nO mais comum nas linguagens em geral é a estrutura do `for`, que também existe dentro do elixir, porém não é a mais utilizada.\n\n```elixir\niex> for x <- [1, 2, 3] do\n...> x + 2\n...> end\n[3, 4, 5]\n```\n\nNo exemplo acima, criamos uma repetição dentro da lista de números o qual cada elemento iterado fora definido o valor na variável x e dentro dessa estrutura, x foi somado com 2 retornando uma nova lista de números modificada.\n\nMas essa não é a forma mais comum de se fazer um looping, pois em suma, utilizamos o módulo `Enum` para gerenciar Enumeradores em geral.\n\nPor exemplo, se queremos somar o valor total de um carrinho de um e-commerce, seguimos essa lógica:\n\n```elixir\niex> lista_carrinho = [ \\\n...> %{valor_unitario: 125, quantidade: 2, valor_total: 250}, \\\n...> %{valor_unitario: 9210, quantidade: 1, valor_total: 9210}, \\\n...> %{valor_unitario: 1000, quantidade: 20, valor_total: 20000} \\\n...> ]\n[\n %{quantidade: 2, valor_total: 250, valor_unitario: 125},\n %{quantidade: 1, valor_total: 9210, valor_unitario: 9210},\n %{quantidade: 20, valor_total: 20000, valor_unitario: 1000}\n]\n\niex> valor_total = Enum.reduce(lista_carrinho, 0, fn item, valor_a_somar ->\n...> valor_a_somar + item.valor_total\n...> end)\n29460\n```\n\n### Enumeradores\n\nDentro desse maravilhoso módulo, podemos realizar inúmeras operações tanto com listas, tanto com estruturas (*Structs*). Um exemplo legal é quando você precisa iterar dentro de uma struct para alterar as chaves de String para Átomo:\n\n```elixir\niex> estrutura = %{\"id\" => 123, \"nome\" => \"aleDsz\"}\n%{\"id\" => 123, \"nome\" => \"aleDsz\"}\n\niex> estrutura |> Enum.map(fn {chave, valor} ->\n...> {String.to_atom(chave), valor}\n...> end)\n[id: 123, nome: \"aleDsz\"]\n```\n\nPorém, podemos ver que ao fazer isso, o retorno é uma lista de palavras chave (Keyword List), que nada mais é uma lista com chave e valor, assim como uma estrutura, porém funciona um pouco diferente.\n\nSó que, como nós queríamos alterar de String para Átomo, é necessário definir após a execução, na qual é necessário enviar a resposta para a função de `Enum.into/2`, passando como primeiro argumento a lista de palavras chave e como segundo argumento, uma struct vazia.\n\n```elixir\niex> estrutura = %{\"id\" => 123, \"nome\" => \"aleDsz\"}\n%{\"id\" => 123, \"nome\" => \"aleDsz\"}\n\niex> estrutura |> Enum.map(fn {chave, valor} ->\n...> {String.to_atom(chave), valor}\n...> end) |> Enum.into(%{})\n%{id: 123, nome: \"aleDsz\"}\n```\n\nAcima há apenas exemplos de uso, mas para que isso fique bem claro, iremos definir melhor como funciona cada forma de loop com o módulo de `Enum`.\n\n##### Enum.map\n\nEssa função executa o que o próprio nome diz, ele mapeia todos os itens dentro de um Enumerador retornando a mesma quantidade de elementos, porém estes elementos podem ter sido alterados.\n\nUm bom exemplo, é o mesmo utilizado na estrutura do `for`, porém utilizando o módulo de `Enum`.\n\n```elixir\niex> Enum.map([1, 2, 3], fn x ->\n...> x + 2\n...> end)\n[3, 4, 5]\n```\n\n##### Enum.reduce\n\nQuando precisamos pegar uma lista de reduzí-la (ou aumentá-la, depende do contexto) para algum formato, seja este de tamanho diferente do original, precisamos utilizar o conceito da função `Enum.reduce/3`, que precisa de 3 argumentos:\n\n 1) Enumerador;\n 2) Valor inicial;\n 3) Função anônima pra execução do looping\n\nTendo isso em mente, podemos analisar melhor o exemplo citado anteriormente da soma dos itens do carrinho do e-commerce.\n\n##### Enum.reduce_while\n\nUtiliza-se o mesmo conceito do `Enum.reduce/3`, apenas com uma diferença: É possível parar o looping no meio de sua execução se definido o resultado do looping como uma tupla, obedecendo as duas formas de resposta:\n\n- `{:cont, acumulador}`: Este define que o looping deve continuar, o acumulador para o próximo passo do looping com o valor novo\n\n- `{:halt, resultado}`: Geralmente utilizando para ou retornar um erro, ou apenas encerrar o looping devolvendo o resultado do mesmo até o último laço executado.\n\n```elixir\niex> Enum.reduce_while(1..100, 0, fn numero, soma ->\n...> cond do\n...> numero == 10 ->\n...> {:cont, soma + numero}\n...> \n...> numero == 40 ->\n...> {:cont, soma + numero}\n...> \n...> soma >= 60 ->\n...> {:halt, soma}\n...> \n...> true ->\n...> {:cont, soma + 1}\n...> end\n...> end)\n88\n```" }, { "path": "contents/3 - Linguagem/7-Estruturas de Decisao.md", "content": "# 3.7 Estruturas de Decisão\n\nQuando precisamos tomar decisões difíceis e complicadas em nosso código, é sempre bom utilizar uma das estuturas de decisão.\n\nNo Elixir, estes foram criados para serem utilizados dentro de contextos com a devida semântica. Ou seja, pode-se dizer que existem estruturas de decisões que fazem a mesma coisa, só tem uma forma diferente de se entender por sua escrita.\n\n### IF\n\nO famoso if continua existindo no Elixir assim como em todas as outras, mas o que diferencia é que não é possível realizar vários `else if`, ou seja, você na verdade precisa criar um bloco de `if` dentro da definição do `else`:\n\n```elixir\ndefmodule Decisao do\n def esta_decidido?() do\n if 1 == 2 do\n true\n else\n if 1 == 3 do\n true\n else\n if 1 == 1 do\n true\n else\n false\n end\n end\n end\n end\nend\n```\n\n### Unless\n\nA não ser que, você esteja atrás de uma semântica interessante, você deve utilizar essa estrutura.\n\nBrincadeiras à parte, essa estrutura de decisão é exatamente o que o nome diz, uma validação ao contrário. Ou seja, caso a definição da condição tenha como resultado um booleano `true`, o bloco de código definido será executado:\n\n```elixir\niex> hit_or_miss? = false\niex> unless hit_or_miss? === true do\n...> IO.puts \"Sim, eu sou o diferentão\"\n...> IO.puts \"A não ser que você esteja errado ;)\"\n...> end\n\"Sim, eu sou o diferentão\"\n\"A não ser que você esteja errado ;)\"\n```\n\n### Case\n\nQuando precisamos analisar inúmeras possíveis respostas de uma função, a estrutura de `case` é a melhor por conta de ser a mais simples e ter uma semântica mais `clean` para tal:\n\n```elixir\niex> case AqueleModulo.com_uma_resposta_muito_doida() do\n...> \"resposta 1\" ->\n...> \"que loucura bicho\"\n...> \n...> :atomo_muito_loco ->\n...> \"que loucura bicho\"\n...> \n...> %{name: \"Desestruct memo\"} ->\n...> \"que loucura bicho\"\n...> \n...> _qualquer_outra_resposta_mirabolante ->\n...> \"ai tu cagou tudo mermão\"\n...> end\n```\n\n### Cond\n\nNão é o Conde Drácula, mas esse aqui serve pra quando você precisa validar várias condições sem a necessidade de `if .. else .. if .. else`, etc.\n\n```elixir\niex> cond do\n...> 1 == 2 ->\n...> \"esse aqui é utopia, igual ancap\"\n...> \n...> 1 == 3 ->\n...> \"esse aqui é utopia, igual ancap\"\n...> \n...> 1 == 4 ->\n...> \"esse aqui é utopia, igual ancap\"\n...> \n...> 1 == 0 ->\n...> \"esse aqui é utopia, igual ancap\"\n...> \n...> true ->\n...> \"acho que não teve jeito mesmo\"\n...> end\n```\n\n### With\n\nNão é um with ela(e), mas é uma função do `Kernel` para avaliar uma ou mais condições, é recomendado utilizar em momentos que seu fluxo de execução requerir validação de [pattern matching](../4%20-%20Recursos%20extras/3-Pattern%20Matching.md) de inúmeras condições onde o `case` não seria o suficiente, principalmente quando você não precisa lidar com os resultados não esperados.\n\nDado uma função, se o seu retorno for o esperado (para isso será utilizado o [pattern matching](../4%20-%20Recursos%20extras/3-Pattern%20Matching.md)), execute o código. Ficará mais fácil entender com o exemplo a seguir:\n\n```elixir\niex> with {:ok, _banana} <- MyModule.my_fun(my_param) do\n...> \"Deu boa patrão\"\n...> end\n```\n\nBasicamente, se a função retornar uma tupla de `{:ok, qualquer_valor}` (valores que você pode definir como quiser), o trecho de código no bloco `do` será executado. Caso contrario, um erro é retornado para quem chamou a função.\n\nO `with` pode receber várias condições para avaliar, e também pode conter um bloco de `else` para tratar qualquer cláusula que não seja esperada no bloco `with ... do`. Para tratar tais cláusulas você pode usar uma espécie de `case`.\n\n```elixir\niex> with {:ok, _banana} <- Modulo.funcao(),\n...> _outra_banana <- Modulo.outra_funcao() do\n...> \"Deu boa patrão\"\n...> else\n...> :error -> \n...> \"Deu merda patrão\"\n...>\n...> _other_error ->\n...> \"Deu outra merda patrão\"\n...> end\n```\n\nTambém é possível capturar os valores esperados utilizando o operador de atribuição.\n\n```elixir\niex> with %Struct{} = struct <- MyModule.my_fun(my_param) do\n...> \"Capturado chefia, #{struct}\" \n...> end\n```\n\nUm outro bom exemplo de uso do `with ... do` é quando você não precisa tratar os valores não esperados que você teria de tratar com o `case .. do`:\n\n\n```elixir\n# Case\ncase Modulo.funcao() do\n {:ok, _banana} -> \"banana\"\n {:error, _motivo} -> \"maçã\"\n _ -> \"limão\"\nend\n\n# With\nwith {:ok, _banana} <- Modulo.funcao() do\n \"Se der errado o problema já não é meu...\"\nend\n```\nQuando retornar `{:error, _}` ou qualquer outro resultado, ele pode lidar isso em outro ponto do fluxo da execução, não necessitando de lidar com todos os retornos em todas as funções, mantendo tudo isso direto em apenas um único local.\n" }, { "path": "contents/3 - Linguagem/8-Variaveis.md", "content": "# 3.5 - Variáveis\n\nComo dito anteriormente no curso, as variáveis não se comportam como variáveis na maioria dos casos.\n\nOu seja, se você apenas está definindo uma variável com um valor numérico e posteiormente você apenas altera essa variável no mesmo contexto, a mesma terá um valor novo.\n\n```elixir\niex> x = 10\n10\n\niex> x = 20\n20\n```\n\n**Curiosidade:** No paradigma funcional, as \"variáveis\" se comportam como constantes, já que a mesma não varia por conta da imutabilidade.\n\n## Tipos\n\nAssim como em outras linguagens de programação, no Elixir nós temos vários tipos de variáveis, porém a linguagem não é fortemente tipada como Java, C# e outras.\n\nVocê tem a liberdade de trabalhar sem definir tipos às constantes, porém isso te deixa um pouco inseguro do que você irá receber ou devolver em uma função, e não precisa definir um tipo na hora de declarar a mesma.\n\n```elixir\nnome = \"Alexandre\"\nidade = 23\nmaior_de_idade? = true\n```\n\n**Curiosidade:** Você pode utilizar símbolos como `?` e `!` na hora de definir variáveis ou nome de funções.\n\nQuando definido que uma variável ou função contém o símbolo de interrogação (?) no final da mesma, entende-se que o resultado daquela variável ou função será um booleano.\n\nQuando definido que uma função contém o símbolo de exclamação (!) no final da mesma, entende-se que o resultado será um valor ou uma `exception`.\n\nMas vamos direto ao assunto, existem vários tipos no Elixir, tais como:\n\n```elixir\n# Átomos (Atom)\niex> :atomo\n:atomo\n\n# String (Binary)\niex> \"Esta é uma string maravilhosa\"\n\"Esta é uma string maravilhosa\"\n\n# Booleano (Boolean)\niex> true\ntrue\n\n# Inteiro (Integer)\niex> 10\n10\n\n# Real (Float)\niex> 10.1\n10.1\n\n# Map\niex> %{id: 123, nome: \"Foo\"}\n%{id: 123, nome: \"Foo\"}\n\niex> %{\"id\" => 123, \"nome\" => \"Foo\"}\n%{\"id\" => 123, \"nome\" => \"Foo\"}\n\n# Vetor/Lista (List)\niex> [:a, \"b\", 3]\n[:a, \"b\", 3]\n\niex> [%{test: 1}, %{test: 2}, %{test: 3}]\n[%{test: 1}, %{test: 2}, %{test: 3}]\n\n# Tupla (Tuple)\niex> {:ok, []}\n{:ok, []}\n\niex> {:a, \"b\", :c, 4}\n{:a, \"b\", :c, 4}\n\n# Binary\niex> <<1, 2, 3>>\n<<1, 2, 3>>\n\n# Char list\niex> 'aleDsz'\n'aleDsz'\n\n# Estrutura (Struct)\niex> defmodule User do\n...> defstruct [:id, :nome]\n...> end\niex> %User{}\n%User{\n id: nil,\n nome: nil\n}\n\n# Sigils (é isso mesmo, não tem tradução)\niex> ~w(a b c) # Word list de String\n[\"a\", \"b\", \"c\"]\n\niex> ~w(a b c)a # Word list de Átomos\n[:a, :b, :c]\n\niex> ~r/hello/ # RegEx\n~r/hello/\n```\n\n### Átomos\n\nÁtomos por si só é uma constante que o valor é ele mesmo. Seu uso é bem comum quando utilizado em `pattern matching` (explicaremos isso mais a fundo na seção **Avançada**).\n\nUsando isso como base, outro uso de átomos seria para a definição das chaves de um map (este que é definido por chave-valor).\n\n### String\n\nComo definido acima, as strings são binários, ou seja, exatamente como o C define uma string (um vetor de caracteres). Você pode tratar uma string como `binary` que, por sua vez, o `binary` não pode ser tratado como string por ter um tipo diferente.\n\n### Map\n\nEm POO, você cria uma entidade e instancia a mesma como um objeto para utilizar em seu sistema. Em Elixir, o qual não existe classes e objetos, você pode trabalhar com Maps que, resumidamente, é uma estrutura de chave-valor sem uma definição de tipo para o mesmo.\n\nEm um Map, você pode definir as chaves como `string` ou `átomo`. _Structs_, por padrão, trabalham com chaves do tipo `átomo` e JSON convertido para Map trabalha com chaves do tipo `string`.\n\n### Tupla\n\nResumidamente, uma tupla é uma lista com tamanho pré=definido, tendo como uso padrão, para retorno de funções e padronização do mesmo.\n\n```elixir\n# Uma lista com tamanho dinâmico\niex> [1, 2, 3]\n[1, 2, 3]\n\niex> [1, 2, 3] ++ [4]\n[1, 2, 3, 4]\n\n# Uma lista com tamanho \"pré-definido\"\niex> {1, 2, 3}\n{1, 2, 3}\n\n# Calma, vamos explicar como funciona esse tal de pipe (|>)\niex> {1, 2, 3} |> Tuple.append(4)\n{1, 2, 3, 4}\n```\n\n### Binary\n\nBinário, não necessariamente trabalha com binário, pois este pode ser também:\n\n - uma representação de uma `string`;\n - uma representação de um conjunto de números que pode representar um caracter Unicode;\n - uma representação de um conjunto de números que pode representar um binário (neste caso, pode ser um executável, uma imagem, etc.).\n\n### Char list\n\nComo o próprio nome diz, ele é um vetor de caracteres no qual você define utilizando *singlequotes*, ou seja, a famigerada aspas simples.\n\nO seu uso é comum quando você precisa criar uma interface ou até mesmo usar módulos nativos ou de bibliotecas do Erlang.\n\n```elixir\niex> 'Hello'\n'Hello'\n\niex> is_list('Hello')\ntrue\n```\n\n### Struct\n\nUma Struct é um Map o qual define-se um tipo ao Map como um todo. Ou seja, quando queremos validar se um Map é, de fato, um dado que estamos esperando em uma estrutura pré-definida, a `Struct` é o que garante que aquele Map sempre terá tal chave em sua estrutura, mas não necessariamente com valor.\n\nEm versões mais recentes do Elixir (1.9+), é possível você validar se um Map é apenas um Map ou se ele também é uma Struct ou não.\n\nEm versões mais antigas (1.8-), isso é garantido através da chave `:__struct__` dentro do Map.\n\n### Sigils\n\nÉ uma representação textual que pode ser interpretada conforme à linguagem define ou conforme um Sigil customizado, o qual é definido pelo próprio usuário dentro de um projeto.\n\n*Word List* é um exemplo, pois é uma lista de palavras bastante utilizado quando precisamos criar um tipo de *enum*.\n\n```elixir\niex> avaliable_words = ~w(batata arroz feijao)\n[\"batata\", \"arroz\", \"feijao\"]\n\n# Validação de uma palavra dentro de uma lista de palavras (ou array de Strings)\n\niex> \"salada\" in avaliable_words\nfalse\n```" }, { "path": "contents/4 - Recursos extras/1-Gerenciador de Pacotes.md", "content": "# 4.1 Gerenciador de Pacotes\n\nAssim como em outras linguagem, como o [amado] Javascript, o Elixir também usa um e este é chamado de `mix`. Com ele, criamos projetos, executamos tasks, testes e faz café também (brincadeira, mas poderia não ser 😞)).\n\n```sh\n# Criar novo pacote\n$ mix new lind-ex\n\n# Criar novo app\n$ mix new appzao --sup\n\n# Testes\n$ mix test\n\n# Rodar uma task customizada\n$ mix task aquela.fcking.task\n\n# Instalar dependências\n$ mix deps.get\n\n# Compilar todas as dependências\n$ mix deps.compile\n\n# Compilar uma dependência\n$ mix deps.compile lind-ex\n\n# Atualizar uma dependência\n$ mix deps.update lind-ex\n\n# Compilar projeto\n$ mix compile\n\n# Rodar arquivo utilizando dependências do projeto\n$ mix run lib/aquele/arquivo/foda.ex\n\n# Rodar projeto sem encerrar\n$ mix run --no-halt\n\n# Rodar projeto usando Phoenix\n$ mix phx.server\n```\n\n**Curiosidade:** É comum você definir em alguma parte do nome do seu projeto, algo relacionado com **ex** pois este define que o seu projeto é feito em Elixir.\n\n\n## Terminal Interativo\n\nAssim como o Python, é possível executar código em um terminal interativo, mas no Elixir é possível fazer de algumas formas:\n\n1) Sem as dependências:\n\n```sh\niex\n\n# Executado:\nInteractive Elixir (1.8.2) - press Ctrl+C to exit (type h() ENTER for help)\niex(1)>\n```\n\n2) Sem as dependências utilizando um `node` nomeado:\n\n```sh\niex --sname nome@localhost\n\n# Executado:\nInteractive Elixir (1.8.2) - press Ctrl+C to exit (type h() ENTER for help)\niex(nome@localhost)1>\n```\n\n3) Com as dependências:\n\n```sh\niex -S mix\n\n# Executado:\nInteractive Elixir (1.8.2) - press Ctrl+C to exit (type h() ENTER for help)\niex(1)>\n```\n\n4) Com as dependências utilizando um `node` nomeado:\n\n```sh\niex --sname nome@localhost -S mix\n\n# Executado:\nInteractive Elixir (1.8.2) - press Ctrl+C to exit (type h() ENTER for help)\niex(nome@localhost)1>\n```\n\n**Curiosidade:** Você pode executar o comando `iex -S mix phx.server` caso queira rodar um projeto Phoenix com API ativa dentro do terminal interativo, para testar algumas funções diretamente e conseguir realizar requests pra sua API." }, { "path": "contents/4 - Recursos extras/2-Testes.md", "content": "# 4.2º Testes\n\nTesta, mas testa mesmo, isso que você precisa, dos amados Testes. Todo desenvolvedor que quer manter seu projeto funcional conforme o passar do tempo, **precisa** fazer testes, sejam eles unitários ou *end-to-end*.\n\nO mais simples de se explicar é usando o teste unitário, pois esse não precisa configurar um case de test para API (Phoenix, Plug, etc.).\n\n```elixir\n# my-app/test/algum_test.exs\n\ndefmodule MyApp.AlgumTest do\n use ExUnit.Case, async: false\n\n test \"uno teste mui bonito\" do\n assert true\n end\n\n test \"uno teste mui refutada\" do\n refute false\n end\nend\n```\n\nAo executar o `mix test` seu teste será executado e você poderá ver quantos deram sucesso, mas se quiser que ele seja verboso, utilize o comando `mix test --trace`.\n\nCaso você queira fazer tests **end-to-end**, você precisa ver a documentação da biblioteca que você for usar para gerar uma API:\n\n- [Phoenix](https://hexdocs.pm/phoenix)\n- [Maru](https://hexdocs.pm/maru)\n- [Plug](https://hexdocs.pm/plug)" }, { "path": "contents/4 - Recursos extras/3-Pattern Matching.md", "content": "# 4.3 Pattern Matching\n\nEsse aqui, esse aqui é o motivo que você irá amar o Elixir, pois *pattern matching* é a base de tudo que é maravilhoso nesse mundo de alquimistas.\n\nEm outras linguagens, quando você precisa criar uma função com o mesmo nome, você acaba precisando aumentar os parâmetros ou até utilizar vários *if*'s para conseguir ter processamentos diferentes para dados diferentes:\n\n```php\nclass Foo {\n public function getUser (Array $params) {\n if (!isset($params[\"type\"])) {\n return null;\n }\n\n if ($params[\"type\"] === \"admin\") {\n return getAdmin($params);\n }\n\n if ($params[\"type\"] === \"client\") {\n return getClient($params);\n }\n\n $user = getFromDatabase(\"user\", $params[\"id\"]);\n return $user;\n }\n}\n```\n\nNo exemplo acima, fora necessário validar o campo `type` dentro do array de parâmetros para executar funções diferentes para obter um usuário pelo seu ID.\n\nSe gerarmos um exemplo parecido em Elixir, ele ficaria muito mais simples:\n\n```elixir\ndefmodule Foo do\n def get_user(%{\"id\" => user_id, \"type\" => \"admin\"}) do\n case User.get(user_id) do\n {:ok, user} ->\n {:ok, user}\n\n {:error, reason} ->\n {:error, reason}\n end\n end\n def get_user(%{\"id\" => user_id, \"type\" => \"client\"}) do\n case User.get(user_id) do\n {:ok, user} ->\n {:ok, user}\n\n {:error, reason} ->\n {:error, reason}\n end\n end\n def get_user(%{\"id\" => user_id, \"type\" => \"user\"}) do\n case User.get(user_id) do\n {:ok, user} ->\n {:ok, user}\n\n {:error, reason} ->\n {:error, reason}\n end\n end\n def get_user(_params), do: nil\nend\n```\n\nVocê consegue realizar validações, obter dados diretamente dos parâmetros de uma função utilizando as técnicas ninjas de *pattern matching*.\n\nPara melhorar seu entendimento, colocarei mais exemplos abaixo:\n\n- Utilizando validação de tamanho de string para realizar o *pattern matching*:\n\n```elixir\ndefmodule Foo do\n def validate_document(<>),\n do: :valid_cnpj\n\n def validate_document(<>),\n do: :valid_cpf\n\n def validate_document(_document),\n do: :invalid\nend\n```\n\n- Utilizando guards para validar os tipos dos dados com o *pattern matching*:\n\n```elixir\ndefmodule Bar do\n def get_user(user_id) when is_integer(user_id),\n do: user_id |> Users.get()\n\n def get_user(user_id) when is_binary(user_id),\n do: user_id |> String.to_integer() |> Users.get()\n\n def get_user(%{\"id\" => user_id}) when is_integer(user_id),\n do: user_id |> Users.get()\n\n def get_user(%{\"id\" => user_id}) when is_binary(user_id),\n do: user_id |> String.to_integer() |> Users.get()\nend\n```\n\n- Utilizando átomos e guards para realizar o *pattern matching*:\n\n```elixir\ndefmodule Elixir4Noobs do\n def calcular(:sum, number1, number2) when is_integer(number1) and is_integer(number2),\n do: number1 + number2\n\n def calcular(:subtract, number1, number2) when is_integer(number1) and is_integer(number2),\n do: number1 - number2\n\n def calcular(:division, number1, number2) when is_integer(number1) and is_integer(number2),\n do: number1 / number2\n\n def calcular(:multiply, number1, number2) when is_integer(number1) and is_integer(number2),\n do: number1 + number2\nend\n```" }, { "path": "contents/4 - Recursos extras/4-Bibliotecas.md", "content": "# 4.4 Bibliotecas\n\n## Phoenix\n\nUma das bibliotecas mais importantes para começar a estudar para a construção de API's, utilizando o *real-MVC*, como é considerado no mercado atual. Ele consiste em criar uma interface mais amigável aos desenvolvedores na hora de construir uma API estruturada e com os paradigmas funcionais.\n\nPara instalar, você precisa instalar o hex local para instalar como dependência global (igual o npm e yarn)\n\n```sh\n$ mix local.hex --force\n$ mix archive.install hex phx_new # 1.4.16\n```\n\nApós a instalação, você pode instalar, ao invés de usar o `mix new`, você utilizará um comando específico para criar projetos Phoenix:\n\n```sh\n$ mix phx.new hello_world\n```\n\n\nMais informações, consulte a [documentação do Phoenix](https://hexdocs.pm/phoenix/installation.html)\n\n## Ecto\n\nTodos amamos o uso de ORM para realizarmos consultas no banco de dados, e para isso criou-se a dependência `Ecto`, no qual consiste em criar uma interface com *schemas* para coordenar as tabelas, gerar validações e realizar consultas sem a necessidade de escrever SQL puro. E pasmem, tudo isso utilizando a sintaxe do Elixir:\n\n```elixir\ndefmodule MyApp.Schemas.User do\n @moduledoc \"\"\"\n Schema representation for `users` table\n \"\"\"\n use Ecto.Schema\n import Ecto.Changeset\n\n @primary_key {:id, :binary_id, autogenerate: true}\n\n schema \"users\" do\n field :name, :string\n field :age, :integer\n field :status, :string, default: \"inactive\"\n\n timestamps()\n end\n\n @doc \"\"\"\n Generate changeset for schema using JSON as parameters\n \"\"\"\n def changeset(%__MODULE__{} = schema, attrs) do\n schema\n |> cast(attrs, [:name, :age, :status])\n |> validate_required([:name, :age, :status])\n |> validate_inclusion(:status, ~w(active inactive))\n end\nend\n```\n\nUsando o exemplo acima, temos um schema da tabela `users` onde temos 3 campos (sem contar o campo `:id`, pois ele é gerado automaticamente).\n\nAlém disso, estamos:\n\n1) Recebendo campos específicos utilizando a função `cast/2`;\n2) Validando se os campos \"castados\" não são `nil` ou `empty_string`;\n3) Validando se no campos `:status`, os dados inseridos fazem parte do enum de `[\"active\", \"inactive\"]`.\n\n**Curiosidade:** Esse schema utiliza `:binary_id` como ID, o qual é geralmente utilizado pelo Postgres.\n\n## Tesla\n\nConsumir uma api REST pode ser fácil e prazeroso utilizando a biblioteca [Tesla](https://github.com/teamon/tesla).\nCom pouco esforço é possível contruir clientes flexíveis e poderosos que podem ser utilizados em nossas aplicações a qualquer momento:\n\n```elixir\ndefmodule GitHub do\n use Tesla\n\n plug Tesla.Middleware.BaseUrl, \"https://api.github.com\"\n plug Tesla.Middleware.Headers, [{\"authorization\", \"token xyz\"}]\n plug Tesla.Middleware.JSON\n\n def user_repos(login) do\n get(\"/users/\" <> login <> \"/repos\")\n end\nend\n```\n\n## Floki\n\nUma das mais amadas da comunidade sem dúvidas, a biblioteca [Floki](https://github.com/philss/floki) traz com maestria todas as ferramentas necessárias para o parsing de HTML.\nTarefas como escrever um crawler simples ou interpretações complexas podem ser alcançadas facilmente com essa belezinha!!! Ah e tudo isso utilizando seletores css, o que deixa nossa vida ainda mais fácil hehe!\n\nExemplo\n\n```html\n\n\n\n
\n

Floki

\n Enables search using CSS selectors\n Github page\n philss\n
\n Hex package\n\n\n```\n\n```elixir\n{:ok, document} = Floki.parse_document(html)\n\nFloki.find(document, \"p.headline\")\n# => [{\"p\", [{\"class\", \"headline\"}], [\"Floki\"]}]\n\ndocument\n|> Floki.find(\"p.headline\")\n|> Floki.raw_html\n# =>

Floki

\n```\n" }, { "path": "contents/4 - Recursos extras/5-Operador Pipe.md", "content": "# 4.5 Operador Pipe\n\nO operador pipe `|>` passa o resultado de uma expressão como o primeiro parâmetro de outra expressão. Com ele podemos escrever códigos simples e muito mais elegantes. Exemplos abaixo:\n\nImagine que eu tenha a seguinte string:\n\n```elixir\niex(1)> string = \" eLiXir4NoObS \\n \"\n\" eLiXir4NoObS \\n \"\n```\n\nEntretanto, eu gostaria de gerar uma string sem os `espaços`, sem esse `\\n` e sem essas letras `maiúsculas`. Bom, uma opção que eu poderia fazer seria chamar a função `String.trim/1` passando a minha própria `string`.\n\n```elixir\niex(2)> String.trim(string)\n\"eLiXir4NoObS\"\n```\n\nDito isso, podemos ver que ele removeu os espaços e também o `\\n`. Porém, estamos em uma `linguagem imutável`. Logo, a gente precisa atribuir a nossa `string` novamente.\n\n```elixir\niex(3)> string = String.trim(string)\n\"eLiXir4NoObS\"\niex(4)> string\n\"eLiXir4NoObS\"\n```\n\nAgora sim estamos com a nossa `string` modificada. Para deixarmos com letras minúsculas, teriamos que novamente atribuir a `string` recebendo a função `String.downcase/1`.\n\n```elixir\niex(5)> string = String.downcase(string)\n\"elixir4noobs\"\niex(6)> string\n\"elixir4noobs\"\n```\n\nPronto! Aí está a nossa `string` sem os `espaço`, sem `\\n` e sem as `letras maiúsculas`. Ou seja, primeiro a gente precisou atribuir a nossa `váriavel`, depois tivemos que fazer o `trim` e por fim o `downcase`, isso tudo atribuindo. São nesses cenários que a gente pode usar o `pipe operator`.\n\n## Utilizando o Pipe Operator\n\nVeja como é bem mais fácil produzir código mais legíveis e elegante, um operador muito legal em `Elixir` para deixar nosso código mais elegante e fácil de entender!\n\n```elixir\niex(7)> \" eLiXir4NoObS \\n \" |> String.trim() |> String.downcase()\n\"elixir4noobs\"\n```\n\nO que o `pipe operator` faz? Bom, ele nada mais faz do que pegar o resultado de qualquer operação antes dele e passa para a função seguinte como primeiro argumento. Ou seja, estamos pegando `\" eLiXir4NoObS \\n \"` passando para a função `String.trim/1` e com o resultado da função `String.trim/1` estamos passando para `String.downcase/1` sempre como o primeiro argumento.\n\n---\n\nMais informações, consulte a [documentação Elixir School](https://elixirschool.com/pt/lessons/basics/pipe_operator)" } ]