6 |
7 |
4 |
5 |
6 |
7 |
12 |
17 |
18 | Explore a documentação »
19 |
20 |
21 | Report Bug
22 | ·
23 | Request Feature
24 |
91 |
92 | 
93 |
94 |
67 | Próximo -> Estruturas de dados 68 |
69 | 70 |71 | Voltar para o menu principal 72 |
73 | -------------------------------------------------------------------------------- /content/conceitos/documentacoes.md: -------------------------------------------------------------------------------- 1 | # Documentações 2 | 3 | Ler as documentações de funções específicas em Clojure é algo possível de se realizar dentro do próprio código, utilizando uma simples função chamada `doc`. 4 | 5 | ## Doc 6 | 7 | Com esta função podemos avaliar e ler uma documentação sobre qualquer função que Clojure tenha, com exemplos práticos e uma descrição de funcionamento, facilitando seu desenvolvimento como um todo. 8 | 9 | Um exemplo simples seria para a validação da função `+`, que tem como objetivo realizar a soma de valores. Para validar sua documentação podemos executar o código abaixo: 10 | 11 | ```clojure 12 | (doc +) 13 | ``` 14 | 15 | Assim, será impresso como resposta algo como o trecho abaixo. 16 | 17 | ``` 18 | clojure.core/+ 19 | ([] [x] [x y] [x y & more]) 20 | Returns the sum of nums. (+) returns 0. Does not auto-promote 21 | longs, will throw on overflow. See also: +' 22 | nil 23 | ``` 24 | > Como já falamos anteriormente o `nil` apenas demonstra o retorno final de uma função. 25 | 26 | ## Find-doc 27 | 28 | Bem, agora se você precisa procurar por alguma ação, ou seja, alguma string em específico que esteja presente na documentação mas você não se lembra exatamente a função que realiza esta ação a função `find-doc` vai te auxiliar nesse processo. Veja o exemplo abaixo: 29 | 30 | ```clojure 31 | (find-doc "sum of nums") 32 | ``` 33 | 34 | O retorno seria algo como: 35 | 36 | ``` 37 | ------------------------- 38 | clojure.core/+ 39 | ([] [x] [x y] [x y & more]) 40 | Returns the sum of nums. (+) returns 0. Does not auto-promote 41 | longs, will throw on overflow. See also: +' 42 | ------------------------- 43 | clojure.core/+' 44 | ([] [x] [x y] [x y & more]) 45 | Returns the sum of nums. (+') returns 0. Supports arbitrary precision. 46 | See also: + 47 | nil 48 | ``` 49 | 50 | Como apresentado, é procurado em toda a documentação de Clojure alguma função que em sua descrição contenha a string enviada como parâmetro. 51 | 52 | ## Apropos 53 | 54 | Bem, se você já tem uma ideia de qual nome sua função tem ou se parece e quer procurar por funções que contenham determinado trecho de texto em seu nome: `apropos` é o nome da função que você está procurando. 55 | 56 | Olhe o trecho de código abaixo para procura de funções que contenham determinado nome: 57 | 58 | ```clojure 59 | (apropos "replace") 60 | ``` 61 | 62 | O retorno apresentado seria algo como: 63 | 64 | ``` 65 | (clojure.core/replace clojure.string/re-quote-replacement clojure.string/replace clojure.string/replace-first clojure.walk/postwalk-replace clojure.walk/prewalk-replace clojure.zip/replace) 66 | ``` 67 | 68 | ## ClojureDocs 69 | 70 | Caso você prefira uma interface interativa na web, recomendo fortemente utilizar as documentações encontradas no [ClojureDocs](https://clojuredocs.org/), facilitando suas buscas por conteúdos diversos e exemplificações maravilhosas. 71 | 72 | --- 73 | 74 | Então, curtiu entender um pouco sobre o funcionamento de documentações com Clojure? O que acha de passarmos um pouco sobre o funcionamento de estruturas lógicas com Clojure? 75 | 76 |77 | Próximo -> Lógica 78 |
79 | 80 |81 | Voltar para o menu principal 82 |
83 | -------------------------------------------------------------------------------- /content/conceitos/estruturas.md: -------------------------------------------------------------------------------- 1 | # Estruturas de Dados 2 | 3 | Clojure trabalha com uma série de estruturas de dados interessantes, que vão te auxiliar muito durante seu desenvolvimento como um todo, por isso, para podermos ter uma experiência legal *recomendo* que você abra seu REPL para testarmos algumas coisas enquanto conhecemos! 4 | 5 | As estruturas de dados básicas existentes em Clojure hoje são: [Vetores](https://clojure.org/guides/learn/sequential_colls#_vectors), [Listas](https://clojure.org/guides/learn/sequential_colls#_lists), [Sets](https://clojure.org/guides/learn/hashed_colls#_sets) e [Mapas](https://clojure.org/guides/learn/hashed_colls#_maps), sendo divididos como os dois primeiros sendo denominados *Coleções Sequenciais* e os dois últimos *Coleções com Hash*. 6 | 7 | Vamos passar por cada uma delas, por isso, aperte os cintos e bora pra próxima! 8 | 9 | --- 10 | 11 | Vamos conhecer as estruturas de dados básicas de Clojure, começando pelos vetores? 12 | 13 |14 | Próximo -> Vetores 15 |
16 | 17 |18 | Voltar para o menu principal 19 |
20 | -------------------------------------------------------------------------------- /content/conceitos/listas.md: -------------------------------------------------------------------------------- 1 | # Listas 2 | 3 | Listas são listas vinculadas sequenciais que, nesse caso, adicionam novos elementos no **início da lista**, em vez de no final, como vetores. Sua sintaxe utiliza parênteses no começo e no final de uma lista. 4 | 5 | De fato, como falado anteriormente, todo o nosso código é formado por listas, na qual em grande parte dos casos o primeiro item da lista será uma determinada função. Isso obviamente não é exclusivo do Clojure, mas, um conceito por trás do funcionamento das linguagens de programação da família de Lisp. 6 | 7 | ## Tratamento 8 | 9 | O tratamento de listas é um pouco diferente, por isso, quero que você teste o código abaixo em seu REPL. 10 | 11 | ```clojure 12 | (1 2 3 4 5) 13 | ``` 14 | 15 | Perceberá que ocorreu um erro, correto? Bem, o motivo é simples: Clojure *pensou* que `1` era uma função e os itens na frente eram nada mais que argumentos para esta determinada função. Para realmente *visualizarmos* essa lista teríamos que adicionar uma aspa simples em seu início, indicando que a lista seguinte não deve ser executada como uma função, prevenindo que ela seja *evaluada* (da tradução literal para avaliada, seria o mesmo conceito que executada - você ainda vai se deparar muito com o termo [evaluation](https://homepages.inf.ed.ac.uk/stg/NOTES/node71.html)). 16 | 17 | ```clojure 18 | '(1 2 3 4 5) 19 | ``` 20 | 21 | Assim o output será o esperado `(1 2 3 4 5)`. Podemos ainda utilizar a função `list` para a criação de uma lista. 22 | 23 | ```clojure 24 | (list 1 2 3 4 5) 25 | ``` 26 | > Esta função declara uma lista que possui como conteúdo os argumentos passados para esta função. 27 | 28 | Bem, vamos agora definir uma lista que será utilizada para nossos exemplos abaixo. 29 | 30 | ```clojure 31 | (def lista-desenvolvedores 32 | '("Kalane" "Daniel" "Cherry" "Canhassi" "Fabrício")) 33 | ``` 34 | 35 | Assim, podemos utilizar outras funções para manipular esta mesma lista, como por exemplo a função `count`. 36 | 37 | ```clojure 38 | (count lista-desenvolvedores) 39 | ``` 40 | 41 | O retorno neste caso seria `5`, afinal, temos 5 itens declarados nesta lista! 42 | 43 | ## First 44 | 45 | Como poderíamos simplesmente retornar o primeiro índice dessa lista declarada? Simples: utilizando a função `first`! 46 | 47 | ```clojure 48 | (first lista-desenvolvedores) 49 | ``` 50 | 51 | Nesse caso o output seria `"Kalane"`, afinal, este é o primeiro índice de nossa lista! 52 | 53 | ## Rest 54 | 55 | E como poderíamos agora mostrar os demais índices, sem contabilizar o primeiro, assim como nos vetores? Bem, utilizamos neste caso o `rest`! 56 | 57 | ```clojure 58 | (rest lista-desenvolvedores) 59 | ``` 60 | 61 | Nesse caso o output seria `("Daniel" "Cherry" "Canhassi" "Fabrício")`! 62 | 63 | ## Nth 64 | 65 | Beleza, mas, caso a gente quisesse algum índice específico, assim como nos vetores? Isso seria possível? Claro! 66 | 67 | ```clojure 68 | (nth list-desenvolvedores 3) 69 | ``` 70 | > O output seria `"Canhassi"`! 71 | 72 | Mas, então poderíamos utilizar simplesmente (assim como nos vetores): 73 | 74 | ```clojure 75 | (list-desenvolvedores 3) 76 | ``` 77 | 78 | Bem, a resposta é não! Se você executou este trecho de código provavelmente se deparou com um erro! Com as listas não podemos trabalhar diretamente com índices como nos vetores... 79 | 80 | ## Conj 81 | 82 | Você se lembra que com vetores podemos adicionar índices no começo e no fim? Bem, com as listas podemos adicionar apenas no começo de toda lista! 83 | 84 | ``` 85 | (conj lista-desenvolvedores "Guto") 86 | ``` 87 | 88 | Neste caso o output seria `("Guto" "Kalane" "Daniel" "Cherry" "Canhassi" "Fabrício")`! 89 | 90 | --- 91 | 92 | O que achou de conhecer um pouco sobre listas? Pronto para entender um pouco melhor sobre sets? 93 | 94 |95 | Próximo -> Sets 96 |
97 | 98 |99 | Voltar para o menu principal 100 |
101 | -------------------------------------------------------------------------------- /content/conceitos/logica.md: -------------------------------------------------------------------------------- 1 | # Lógica 2 | 3 | Bem, quando falamos de lógica falamos necessariamente de algo a mais: comparação. Como já vimos, o tratamento de funções com Clojure é diferente para todas as funções, trazendo uma sintaxe completamente prefixa. 4 | 5 | ## = 6 | 7 | Começando pelas comparações utilizando a função `=`, temos que: 8 | 9 | ```clojure 10 | (= 1 true) ;; false 11 | 12 | (= 1 1) ;; true 13 | 14 | (= true true) ;; true 15 | 16 | (= 1 2) ;; false 17 | 18 | (= 1 1 1) ;; true 19 | 20 | (= 1 1 2) ;; false 21 | ``` 22 | > Ponto importante: `!=` não existe aqui! Então caso você teste receberá um erro... Continue seguindo os exemplos que vamos repassar o funcionamento de negativas com Clojure! 23 | 24 | Pelo que podemos perceber, `true` e `1` não são *nesse caso* tratados como a mesma coisa, implicando no funcionamento geral de algumas comparações! Podemos ainda comparar três valores ou mais, querendo saber se são iguais ou não. Isso é possível graças ao tratamento de sintaxe que foi discutido anteriormente, assim como em outras funções como em `+`. 25 | 26 | ## > >= < <= 27 | 28 | Comparações se valores são maiores e menores é um tanto quanto útil e Clojure deixa ainda mais elegante para você, por isso, vamos ver alguns exemplos abaixo: 29 | 30 | ```clojure 31 | (< 1 2) ;; true 32 | 33 | (<= 1 2) ;; true 34 | 35 | (> 1 2) ;; false 36 | 37 | (>= 1 2) ;; false 38 | 39 | (< 1 2 3) ;; true 40 | 41 | (< 1 3 2) ;; false 42 | ``` 43 | 44 | Perceba que ainda assim podemos passar mais de dois parâmetros para a função, sendo que neste caso, no último exemplo, o resultado foi `false` porque não foram passados de forma crescente, ou seja, `1` é menor que `3` mas `3` não é menor que `2`! 45 | 46 | ## And 47 | 48 | Para validar se dois parâmetros são compatíveis podemos utilizar o `and`, que neste caso seria algo parecido com `&&` de outras linguagens de programação. Veja os exemplos abaixo para entender melhor seu funcionamento: 49 | 50 | ```clojure 51 | (and true true) ;; true 52 | 53 | (and true false) ;; false 54 | 55 | (and true true true) ;; true 56 | ``` 57 | 58 | Com funcionamento similar aos apresentados anteriormente podemos simplesmente validar se cada um dos parâmetros são verdadeiros, assim, retornando se o resultado final é `true` ou `false`. 59 | 60 | ## Or 61 | 62 | Para validar se um dos parâmetros é compatível podemos utilizar o `or`, que neste caso seria algo parecido com `||` de outras linguagens de programação. Veja os exemplos abaixo para entender melhor seu funcionamento: 63 | 64 | ```clojure 65 | (or true true) ;; true 66 | 67 | (or true false true) ;; true 68 | 69 | (or false false) ;; false 70 | ``` 71 | 72 | Neste caso basta um dos parâmetros ser verdadeiro para que o retorno seja `true`, independente da quantidade de argumentos! 73 | 74 | ## Not 75 | 76 | Bem, neste caso o `not` realiza a negativa de alguma condição, que seria algo parecido com `!` de outras linguagens de programação. Veja os exemplos abaixo para entender melhor seu funcionamento: 77 | 78 | ```clojure 79 | (not false) ;; true 80 | 81 | (not true) ;; false 82 | 83 | (not (> 1 2)) ;; true 84 | ``` 85 | 86 | No último exemplo sabemos que a função interna `(> 1 2)` por padrão retornaria `false`, afinal, `1` não é maior que `2`, porém, o `not` inverteu este valor e fez com que ao final fosse retornado `true`! 87 | 88 | --- 89 | 90 | O que achou dos tratamentos de lógica com Clojure? Vamos ver sobre o funcionamento de condicionais com Clojure? 91 | 92 |93 | Próximo -> Condicionais 94 |
95 | 96 |97 | Voltar para o menu principal 98 |
99 | -------------------------------------------------------------------------------- /content/conceitos/mapas.md: -------------------------------------------------------------------------------- 1 | # Mapas 2 | 3 | Os mapas são comumente usados para gerenciar uma associação de chaves a valores, sendo chamado de dicionários ou mapas de hash (famosos hash maps) em outras linguagens de programação. 4 | 5 | Podemos dizer que os mapas associam sempre uma chave com um determinado valor, tendo sua sintaxe básica parecida com o exemplo abaixo: 6 | 7 | ```clojure 8 | {"a" "b" "c" "d"} 9 | ``` 10 | 11 | Quando executado você verá em seu REPL um retorno como `{"a" "b", "c" "d"}`! Perceba que essa vírgula indica a separação interna no mapa que neste caso possui duas chaves com dois valores específicos: chave `"a"` para valor `"b"` e chave `"c"` para valor `"d"`! 12 | 13 | Com mapas é normal utilizar vírgulas exatamente por este motivo, mesmo que não obrigatório, ou então separar com uma quebra de linha. Podemos definir um mapa ainda utilizando a função `hash-map`, resultando em algo como o exemplo abaixo: 14 | 15 | ```clojure 16 | (hash-map "a" "b" "c" "d") 17 | ``` 18 | 19 | O output seria o mesmo! Porém, vamos definir um mapa fixo para utilizarmos em nossos exemplos com a sintaxe abaixo: 20 | 21 | ```clojure 22 | (def musicas {"Dear Future Self (Hands Up)" "Fall Out Boy" 23 | "Onlyfans" "Bibi Babydoll" 24 | "Naquela Mesa" "Nelson Golçalves" 25 | "Everlong" "Foo Fighters"}) 26 | ``` 27 | 28 | ## Get 29 | 30 | Para selecionar alguma determinada chave e verificar seu valor podemos utilizar duas formas distintas, por isso, vamos começar pela função `get`, veja no exemplo abaixo: 31 | 32 | ```clojure 33 | (get musicas "Everlong") 34 | ``` 35 | 36 | O output será `"Foo Fighters"`, mas, poderíamos ainda utilizar algo semelhante mostrado anteriormente, apenas informando o nome de um determinado mapa seguido da chave a ser buscada: 37 | 38 | ```clojure 39 | (musicas "Everlong") 40 | ``` 41 | 42 | O output será o mesmo! 43 | 44 | ## Assoc 45 | 46 | Podemos ainda adicionar novos grupos de chaves e valores em nosso mapa! Para isso utilizamos a função `assoc`, seguido do mapa a ser adicionado, além da chave e do valor específico. Veja o exemplo abaixo: 47 | 48 | ```clojure 49 | (assoc musicas "Zombie" "The Cranberries") 50 | ``` 51 | 52 | O output seria o mapa completo (separando seus itens com vírgulas) com o novo item adicionado ao final do mapa! 53 | 54 | ## Dissoc 55 | 56 | Podemos ainda remover um item completo identificado pela sua chave utilizando a funçõa `dissoc`! Veja no exemplo abaixo: 57 | 58 | ```clojure 59 | (dissoc musicas "Dear Future Self (Hands Up)") 60 | ``` 61 | 62 | Assim, seria retornado o mapa completo sem a chave e o valor de `"Dear Future Self (Hands Up)"`! 63 | 64 | ## Contains? 65 | 66 | Validar se um mapa contém uma determinada chave utilizando a função `contains?`! Veja o exemplo abaixo: 67 | 68 | ```clojure 69 | (contains? musicas "Onlyfans") 70 | ``` 71 | 72 | O output nesse caso seria `true`, mas, caso fosse procurada a chave `"Free Bird"` o retorno seria `false`! 73 | 74 | ## Find 75 | 76 | Além de validar a existência podemos procurar e trazer a chave e o valor específico de um item com a função `find`! Veja no exemplo abaixo: 77 | 78 | ```clojure 79 | (find musicas "Naquela Mesa") 80 | ``` 81 | 82 | O output nesse caso seria `["Naquela Mesa" "Nelson Golçalves"]`, isso mesmo, em formato de vetor! Caso a chave não existisse seria retornado um `nil` no lugar! 83 | 84 | ## Keys 85 | 86 | Para validarmos todas as chaves de um determinado mapa podemos utilizar a função `keys`! Veja o exemplo abaixo: 87 | 88 | ```clojure 89 | (keys musicas) 90 | ``` 91 | 92 | O output será `("Dear Future Self (Hands Up)" "Onlyfans" "Naquela Mesa" "Everlong")`, retornando todas as chaves presentes em nosso mapa! 93 | 94 | ## Vals 95 | 96 | Para validarmos todas os valores de um determinado mapa podemos utilizar a função `vals`! Veja o exemplo abaixo: 97 | 98 | ```clojure 99 | (vals musicas) 100 | ``` 101 | 102 | O output será `("Fall Out Boy" "Bibi Babydoll" "Nelson Golçalves" "Foo Fighters")`, trazendo todos os valores para as chaves existentes! 103 | 104 | ## Zipmap 105 | 106 | Podemos ainda criar um mapa novo a partir de um set específico com a função `zipmap`! Veja o exemplo abaixo: 107 | 108 | ```clojure 109 | (zipmap #{"a" "b" "c"} (repeat 1)) 110 | ``` 111 | 112 | O retorno será `{"a" 1, "b" 1, "c" 1}`, criando um mapa com as chaves originais compondo o set especificado, mas, com valores que surgiram do retorno da função `(repeat 1)`! 113 | 114 | ## Merge 115 | 116 | Combinar mapas é uma tarefa um tanto quanto útil, na qual podemos nos apropriar de diversas finalidades! A função `merge` tem como objetivo combinar dois mapas distintos, trazendo um novo mapa como resultado. Veja o exemplo abaixo com a declaração de um novo mapa: 117 | 118 | ```clojure 119 | (def novas-musicas {"Sweet Child O' Mine" "Guns N' Roses" 120 | "Dream On" "Aerosmith" 121 | "Hotel California" "Eagles" 122 | "Come As You Are" "Nirvana"}) 123 | ``` 124 | 125 | Utilizando a função `merge` temos a seguinte sintaxe: 126 | 127 | ```clojure 128 | (merge musicas novas-musicas) 129 | ``` 130 | > Podemos utilizar a função `merge-with` para definir uma regra com objetivo de evitar conflitos caso os mapas tenham chaves iguais! 131 | 132 | Neste caso o output será a combinação de todos os valores informados, combinando o primeiro mapa com o segundo! 133 | 134 | --- 135 | 136 | Gostou de ver um pouco mais sobre mapas? Bem, vamos entender um pouco melhor sobre a utilização de documentações com Clojure? 137 | 138 |139 | Próximo -> Documentações 140 |
141 | 142 |143 | Voltar para o menu principal 144 |
145 | -------------------------------------------------------------------------------- /content/conceitos/sets.md: -------------------------------------------------------------------------------- 1 | # Sets 2 | 3 | Sets, da tradução literal como *conjuntos* (sim, eu preferi não traduzir para não ficar algo tão diferente do que conhecemos em outros locais). Os sets são como conjuntos matemáticos – não ordenados e sem duplicatas, sendo ideais para verificar com eficiência se uma coleção contém um elemento ou para remover qualquer elemento arbitrário. 4 | 5 | Para definir um set podemos utilizar o exemplo abaixo: 6 | 7 | ```clojure 8 | #{1 2 3 4 5} 9 | ``` 10 | 11 | O output será o mesmo que o enviado, você pode notar que sets também não aceitam que um item seja duplicado! Assim, se você enviar algo como `#{1 2 3 4 5 1}` perceberá que um erro ocorrerá, informando que a chave `1` está duplicada! 12 | 13 | Vamos definir um set para utilizarmos em nossos próximos exemplos, veja abaixo: 14 | 15 | ```clojure 16 | (def set-desenvolvedores 17 | #{"Kalane" "Daniel" "Cherry" "Canhassi" "Fabrício"}) 18 | ``` 19 | 20 | ## Set? 21 | 22 | Para validar se algo é realmente um set podemos utilizar a função `set?`! Veja o exemplo abaixo: 23 | 24 | ```clojure 25 | (set? desenvolvedores) 26 | ``` 27 | 28 | O output será `true`, afinal realmente é um set! Agora se executarmos `(set? lista-desenvolvedores)` será retornado um `false`! 29 | 30 | ## Contains? 31 | 32 | Bem, para validar se algum valor existe dentro de um determinado set podemos utilizar duas formas, começando pela função `contains?`! 33 | 34 | ```clojure 35 | (contains? set-desenvolvedores "Daniel") 36 | ``` 37 | 38 | O output será `true`, afinal, realmente temos o valor `"Daniel"` no set! Mas, se executarmos `(contains? set-desenvolvedores "Guto")` perceberemos que o output será `false`! 39 | 40 | Bem, ainda podemos realizar a verificação de outra forma, como no exemplo abaixo: 41 | 42 | ```clojure 43 | (set-desenvolvedores "Daniel") 44 | ``` 45 | 46 | O output nesse caso será `"Daniel"`, e caso execute `(set-desenvolvedores "Guto")` perceberá que o output é `nil`! Mas, por qual motivo isto funciona? 47 | 48 | Bem, se lembra quando eu falei que os sets eram uma coleção de hashs? Teoricamente o valor passado é a chave, no caso do set, quando encontrado ele a retorna (que seria como um valor realmente), mas, quando não encontra retorna nulo! 49 | 50 | ## Keywords 51 | 52 | Podemos ainda declarar um set de keywords, com a sintaxe `:keyword`! Seu valor é sua própria declaração, por isso, possui algumas propriedades diferentes de quando trabalhamos com strings... 53 | 54 | Se você tentar executar algo como `("Guto" set-desenvolvedores)` não verá mais um `nil`, mas, verificará que um erro ocorreu! Com `keywords` isso não ocorre, na qual podemos utilizar o keyword a ser validado tanto antes quanto depois de um set, como no exemplo abaixo: 55 | 56 | ```clojure 57 | (def letras #{:a :b :c}) 58 | 59 | (:a letras) ;; :a 60 | 61 | (letras :a) ;; :a 62 | 63 | (:d letras) ;; nil 64 | ``` 65 | 66 | ## Conj 67 | 68 | Podemos ainda utilizar o `conj` para adicionar um novo item ao nosso set, como no exemplo abaixo: 69 | 70 | ```clojure 71 | (conj set-desenvolvedores "Guto") 72 | ``` 73 | 74 | O output será `#{"Canhassi" "Kalane" "Daniel" "Fabrício" "Guto" "Cherry"}`, com nosso set contendo o valor especificado! 75 | 76 | ## Disj 77 | 78 | Para remover algum índice de nosso set podemos utilizar a função `disj` como no exemplo abaixo: 79 | 80 | ```clojure 81 | (disj set-desenvolvedores "Fabrício") 82 | ``` 83 | 84 | O output será `#{"Canhassi" "Kalane" "Daniel" "Cherry"}`, removendo o valor especificado! Caso o valor não exista será retornado o set normalmente, sem alertar nenhum erro ou algo do tipo, tratando normalmente. 85 | 86 | --- 87 | 88 | O que achou dos sets dentro de Clojure? Vamos dar uma olhada nos mapas? 89 | 90 |91 | Próximo -> Mapas 92 |
93 | 94 |95 | Voltar para o menu principal 96 |
97 | -------------------------------------------------------------------------------- /content/conceitos/vetores.md: -------------------------------------------------------------------------------- 1 | # Vetores 2 | 3 | Os vetores podem ser definidos como estruturas sequenciais indexadas, ou seja, possuem índices de identificação. Caso você já tenha tido contato com outras linguagens de programação, provavelmente já se deparou com vetores ou os chamados *arrays* em algum momento. 4 | 5 | Não diferente, Clojure implementa os vetores utilizando a notação de colchetes (isso mesmo, nada diferente), na qual podemos definir um vetor de números de forma simples como no exemplo abaixo. 6 | 7 | ```clojure 8 | [1 2 3 4 5 6 7 8 9] 9 | ``` 10 | > Não são necessárias vírgulas ou algo do tipo, apenas um espaço entre os itens. 11 | 12 | Agora você deve estar se perguntando "ok, mas, você havia me falado que Clojure tratava dados como dados puros certo? Eu consigo ter um vetor com múltiplos tipos?"... Bem, a resposta é sim! 13 | 14 | ```clojure 15 | [1 2 3 true false "He4rt Developers"] 16 | ``` 17 | > Múltiplos tipos em uma mesma estrutura não é um problema. 18 | 19 | Vamos definir um vetor fixo para trabalharmos e assim realizarmos alguns testes, por isso, sinta-se livre para escolher sobre o que e com quais índices seu vetor deve ter! O meu seguirá o exemplo abaixo: 20 | 21 | ```clojure 22 | (def desenvolvedores 23 | ["Kalane" "Daniel" "Cherry" "Canhassi" "Fabrício"]) 24 | ``` 25 | 26 | ## First 27 | 28 | Como poderíamos simplesmente retornar o primeiro índice desse vetor declarado? Simples: utilizando a função `first`! 29 | 30 | ```clojure 31 | (first desenvolvedores) 32 | ``` 33 | 34 | Nesse caso o output seria `"Kalane"`, afinal, este é o primeiro índice de nosso vetor! 35 | 36 | ## Rest 37 | 38 | E como poderíamos agora mostrar os demais índices, sem contabilizar o primeiro? Isto é, fazer algo semelhante ao `tail` de outras linguagens de programação? Bem, utilizamos neste caso o `rest`! 39 | 40 | ```clojure 41 | (rest desenvolvedores) 42 | ``` 43 | 44 | Nesse caso o output seria `("Daniel" "Cherry" "Canhassi" "Fabrício")`! 45 | 46 | ## Nth 47 | 48 | Beleza, mas, caso a gente quisesse algum índice específico? Isso seria possível? Claro! Existem ainda duas formas distintas para realizar isso, mas, vou explicar o motivo... 49 | 50 | ```clojure 51 | (nth desenvolvedores 3) 52 | ``` 53 | > O output seria `"Canhassi"`! 54 | 55 | Ou então poderíamos utilizar simplesmente: 56 | 57 | ```clojure 58 | (desenvolvedores 3) 59 | ``` 60 | > O output seria `"Canhassi"`! 61 | 62 | A segunda forma perfeitamente por um simples motivo: se lembra quando eu disse que o uso do `def` seria similar ao de se declarar uma função que não recebe argumentos em específico mas possui um retorno? Bem, exatamente neste princípio! 63 | 64 | ## Count 65 | 66 | Para contabilizar a quantidade de valores em nosso vetor podemos utilizar a função `count`! 67 | 68 | ```clojure 69 | (count desenvolvedores) 70 | ``` 71 | 72 | Nesse caso o output seria `5`, afinal, temos 5 valores em nosso vetor! 73 | 74 | ## Conj 75 | 76 | Podemos ainda concatenar, isto é, adicionar um índice novo em nosso vetor de uma forma muito simples: com a função `conj`! 77 | 78 | ```clojure 79 | (conj desenvolvedores "Guto") 80 | ``` 81 | 82 | Nesse caso o output seria `["Kalane" "Daniel" "Cherry" "Canhassi" "Fabrício" "Guto"]`, fazendo com que o índice novo seja adicionado ao final do vetor! 83 | 84 | ## Cons 85 | 86 | Para adicionar um elemento no início do conteúdo de um vetor utilizamos a função `cons`! 87 | 88 | ```clojure 89 | (cons "Guto" desenvolvedores) 90 | ``` 91 | 92 | Nesse caso o output seria `("Guto" "Kalane" "Daniel" "Cherry" "Canhassi" "Fabrício")`! 93 | 94 | Agora perceba um ponto específico: nós utilizamos diversas funções que realizam modificações em nosso vetor, imprimindo sempre um valor modificado certo? Mas, vamos ver como fica o valor final de `desenvolvedores` depois de tudo isso... 95 | 96 | ```clojure 97 | (println desenvolvedores) 98 | ``` 99 | 100 | Bem, ao final você perceberá que a estrutura não foi modificada, permanecendo no valor original de seu momento de declaração! Como falado anteriormente Clojure trata suas estruturas de forma imutável, criando valores novos que podem ser utilizados da forma como você quiser sem modificar a estrutura original, trazendo segurança para seu desenvolvimento! 101 | 102 | --- 103 | 104 | Gostou da forma de tratamento de vetores dentro de Clojure? O que acha de conhecer as listas? 105 | 106 |107 | Próximo -> Listas 108 |
109 | 110 |111 | Voltar para o menu principal 112 |
113 | -------------------------------------------------------------------------------- /content/condicionais/README.md: -------------------------------------------------------------------------------- 1 | # Condicionais 2 | 3 | Quando tratamos de condicionais sabemos que Clojure realiza um tratamento um tanto quanto elegante, por isso, vamos passar por cada uma delas de maneira detalhada, exemplificando alguns aspectos específicos de cada uma, passando pelo `if`, `when`, `cond` e `case`. 4 | 5 | --- 6 | 7 | Bora começar conhecendo o `if`? 8 | 9 |10 | Próximo -> If 11 |
12 | 13 |14 | Voltar para o menu principal 15 |
16 | -------------------------------------------------------------------------------- /content/condicionais/case.md: -------------------------------------------------------------------------------- 1 | # Case 2 | 3 | Um pouco diferente do `cond` no formato de tratamento, o `case` busca trazer algo mais próximo do que temos como `switch`/`case` de outras linguagens de programação mesmo, validando casos *inteiros* e destacando um caso adicional para quando nenhum dos demais é contemplado! 4 | 5 | Veja o exemplo abaixo e tenho certeza que tudo ficará mais claro! 6 | 7 | ```clojure 8 | (let [n 10] 9 | (case n 10 | 1 "Um!" 11 | 2 "Dois!" 12 | 3 "Três!" 13 | 4 "Quatro!" 14 | "Maior que 4!")) 15 | 16 | ;; Resultado: 17 | ;; "Maior que 4!" 18 | ``` 19 | > Nesse caso não utilizamos um `println`, por isso o resultado voltou como uma `string` mesmo! 20 | 21 | Com o `case` podemos colocar múltiplos casos e no final adicionar algo que chamamos de `default` em outras linguagens de programação para quando nenhum caso acima foi validado! 22 | 23 | --- 24 | 25 | Maravilha! Chegamos ao final do capítulo e espero que tenha gostado de aprender sobre cada uma das condicionais! Vamos conhecer agora as estruturas de repetição, os famosos *loops*? 26 | 27 |28 | Próximo -> Estruturas de Repetição 29 |
30 | 31 |32 | Voltar para o menu principal 33 |
34 | -------------------------------------------------------------------------------- /content/condicionais/cond.md: -------------------------------------------------------------------------------- 1 | # Cond 2 | 3 | Certo certo, já vimos como seria caso quiséssemos executar um trecho de código grande caso uma condição fosse verdadeira, mas, imagine então validar diversas condições com funções específicas para cada uma? 4 | 5 | Bem, vamos conhecer o `cond` com um exemplo bem simples: validando múltiplas condições... 6 | 7 | ```clojure 8 | (let [n 10] 9 | (cond 10 | (> n 0) (println "O número é positivo!") 11 | (< n 0) (println "O número é negativo!") 12 | :else (println "Ok, o número não é positivo nem negativo..."))) 13 | 14 | ;; Resultado: 15 | ;; O número é positivo! 16 | ;; nil 17 | ``` 18 | 19 | Basicamente com o `cond` podemos executar múltiplas funções para validações, podendo trabalhar de forma simples com condições complexas! O único detalhe é para o `:else`, que sempre deve cair como uma última condição de caso, na qual nenhuma das demais foi satisfeita! 20 | 21 | --- 22 | 23 | Utilizar o `cond` em seus projetos é um tanto quanto útil, correto? Vamos conhecer a nossa última condicional do capítulo (nada mais nada menos que `case`)? 24 | 25 |26 | Próximo -> Case 27 |
28 | 29 |30 | Voltar para o menu principal 31 |
32 | -------------------------------------------------------------------------------- /content/condicionais/if.md: -------------------------------------------------------------------------------- 1 | # If 2 | 3 | O `if` pode ser encontrado em diversas linguagens de programação, sendo que sua principal característica é tomar uma decisão caso uma condição seja verdadeira, ou então, pode seguir por um fluxo alternativo caso não seja verdadeira. 4 | 5 | A estrutura do `if` dentro de Clojure é um pouco diferente, afinal, o funcionamento é com funções que recebem parâmetros. Geralmente a estrutura muito conhecida de um `if` seria algo como o exemplo abaixo: 6 | 7 | ```javascript 8 | if (condicao) { 9 | // Faça algo 10 | } else { 11 | // Faça outra coisa 12 | } 13 | ``` 14 | 15 | Bem, em Clojure podemos dizer que o funcionamento é um pouco diferente, por isso, veja o exemplo abaixo: 16 | 17 | ```clojure 18 | (if (> 1 2) 19 | (println "1 é maior que 2") 20 | (println "1 não é maior que 2")) 21 | 22 | ;; Retorno: 23 | ;; 1 não é maior que 2 24 | ;; nil 25 | ``` 26 | 27 | Bem, o funcionamento é bem didático se pararmos para analisar, na qual o `if` segue a estrutura `(if (condicao) (caso positivo) (caso negativo))`, sendo que são enviadas funções internas para tratamento e execução. 28 | 29 | Poderíamos ainda ir além, montando o seguinte trecho de código: 30 | 31 | ```clojure 32 | (def a 5) 33 | 34 | (if (< a 0) 35 | (println "Menor que 0") 36 | (if (= a 0) 37 | (println "Igual a 0") 38 | (println "Maior que 0"))) 39 | 40 | ;; Retorno: 41 | ;; Maior que 0 42 | ;; nil 43 | ``` 44 | 45 | Para facilitar nosso trecho de código podemos ainda utilizar uma *bind* local de valor, o que chamamos de *let*, como no exemplo abaixo: 46 | 47 | ```clojure 48 | (let [a 5] 49 | (if (< a 0) 50 | (println "Menor que 0") 51 | (if (= a 0) 52 | (println "Igual a 0") 53 | (println "Maior que 0")))) 54 | 55 | ;; Retorno: 56 | ;; Maior que 0 57 | ;; nil 58 | ``` 59 | 60 | Neste caso o *let* é utilizado para relacionar um valor, realizar um *match* de valor com alguma *variável*, podendo ser utilizado dentro do mesmo contexto informado, permanecendo sempre no mesmo escopo que declarado! 61 | 62 | Certo, mas, caso eu quisesse executar mais que uma única função em um trecho de código, seria possível? Claro! Para isso utilizamos o `do`, como no exemplo abaixo: 63 | 64 | ```clojure 65 | (if (> 1 2) 66 | (do 67 | (println "Epa, recebi seus valores!") 68 | (println "Pelo que parece 1 é maior que 2!")) 69 | (do 70 | (println "Epa, recebi seus valores aqui hein!") 71 | (println "Pelo que parece 1 não é maior que 2!"))) 72 | 73 | ;; Retorno: 74 | ;; Epa, recebi seus valores aqui hein! 75 | ;; Pelo que parece 1 não é maior que 2! 76 | ;; nil 77 | ``` 78 | 79 | --- 80 | 81 | Mas me diz aí, o que achou de conhecer o `if`? Bora conhecer o `when`? 82 | 83 |84 | Próximo -> When 85 |
86 | 87 |88 | Voltar para o menu principal 89 |
90 | -------------------------------------------------------------------------------- /content/condicionais/when.md: -------------------------------------------------------------------------------- 1 | # When 2 | 3 | O `if` é uma condicional incrível, afinal, recebe como primeiro argumento uma condição para ser validada, como segundo argumento uma função para ser executada caso a condição seja verdadeira e um terceiro argumento como uma função para ser executada caso a condição não seja verdadeira. 4 | 5 | Seria interessante se existisse alguma forma de executar diversas funções de uma vez caso uma condição seja verdadeira, não é mesmo? Bem, para isso que serve o `when`! Veja o exemplo abaixo: 6 | 7 | ```clojure 8 | (when true 9 | (println "Testando 1") 10 | (println "Testando 2") 11 | (println "Testando 3") 12 | (println "Testando 4")) 13 | 14 | ;; Resultado: 15 | ;; Testando 1 16 | ;; Testando 2 17 | ;; Testando 3 18 | ;; Testando 4 19 | ;; nil 20 | ``` 21 | 22 | Sua principal funcionalidade é utilizar de uma condição para executar uma série de funções enviadas! Bem mágico não é? 23 | 24 | --- 25 | 26 | Ok, o `when` realmente é bem maneiro, não é? O que acha de conhecer o `cond` agora? 27 | 28 |29 | Próximo -> Cond 30 |
31 | 32 |33 | Voltar para o menu principal 34 |
35 | -------------------------------------------------------------------------------- /content/finalizacao/README.md: -------------------------------------------------------------------------------- 1 | # Finalização 2 | 3 | Parabéns! Você chegou ao final dessa sua jornada com Clojure, porém, apenas o início de toda a aventura! Agradeço imensamente por você ter ficado até o final, firme e forte, por isso, espero que este conteúdo possa te auxiliar em seus estudos. 4 | 5 | Estou imensamente feliz de ver você lendo isso e saber que todo esse conteúdo ajudou você! Saiba que tudo escrito aqui foi feito com muita dedicação, amor e carinho, na qual nada disso seria possível sem o apoio de diversas pessoas, mas, mais do que tudo a comunidade que tanto amo, a He4rt Developers 💜! 6 | 7 | Amo cada um dos membros e todos que puderam fazer com que todos esses projetos fossem possíveis, por isso, nada mais justo do que retribuir contribuindo de alguma forma, não é mesmo? 8 | 9 | Agradeço imensamente aos meus amigos e familiares, que sempre foram foco de inspiração e pilares essenciais para tudo que almejei em minha vida. Vocês são incríveis. 10 | 11 | Agradeço aos contribuidores da linguagem de programação Clojure, que continuam sempre mantendo o projeto evoluindo, de maneira crescente e cada vez mais incrível. Vocês são muito especiais. 12 | 13 | Clojure me faz uma pessoa feliz, por isso, nada mais justo do que te deixar feliz com Clojure também, não é mesmo? 14 | 15 | Novamente, você aí mesmo atrás dessa tela, saiba que por aqui quem escreve sente muito orgulho de você, ok? Você é simplesmente incrível! Sempre se lembre que todos podem aprender algo novo com tudo, assim como todos podem contribuir de alguma forma, afinal, como diria meu caro Esopo 16 | 17 | > *"Ninguém é tão grande que não possa aprender, nem tão pequeno que não possa ensinar"* 18 | 19 | Obrigado por tudo. 20 | 21 | *Da comunidade para a comunidade. 💜* 22 | 23 | --- 24 | 25 | ### *Redes sociais* 26 |
--------------------------------------------------------------------------------
/content/funcoes/README.md:
--------------------------------------------------------------------------------
1 | # Funções
2 |
3 | Quando falamos de funções falamos da maior parte de tratamento de um ecossistema de linguagens de programação funcionais, na qual *tudo* é *praticamente* uma função. Podemos definir uma função com uma analogia bem simples, dizendo que é uma caixa que espera uma entrada e para esta determinada entrada retorna uma saída, tendo algum tipo de processamento em seu conteúdo interno.
4 |
5 | 
6 |
7 | Basicamente temos a definição de uma função apresentada acima, mas, como poderíamos declarar uma função em Clojure?
8 |
9 | ```clojure
10 | (defn oi []
11 | (println "Oi!"))
12 |
13 | (oi)
14 |
15 | ;; Resultado:
16 | ;; Oi!
17 | ;; nil
18 | ```
19 |
20 | Basicamente temos uma estrutura formada por:
21 | - `(`: indica o início de uma lista
22 | - `defn`: indica que será declarada uma função
23 | - `[]`: argumentos/parâmetros que essa função recebe (nesse caso nada mesmo)
24 | - `(println "Oi!")`: imprimindo a mensagem "Oi!"
25 | - `)`: indica o fim de uma lista
26 | - `(oi)`: *invocando* a função
27 |
28 | As funções como um todo possuem esse formato, no qual é enviado por parâmetro e recebido entre colchetes os valores a serem utilizados dentro da mesma função, assim, podemos declarar uma função simples para somar dois valores:
29 |
30 | ```clojure
31 | (defn soma [a b]
32 | (println (+ a b)))
33 |
34 | (soma 1 2)
35 |
36 | ;; Resultado:
37 | ;; 3
38 | ;; nil
39 | ```
40 | > Lembrando que o `nil` nada mais é do que um retorno do `println`!
41 |
42 | Bem, neste formato, poderíamos criar uma função que recebe dois parâmetros e com isso é realizado um cálculo (neste caso de soma) e retornado e apresentado como resultado final.
43 |
44 | Certo, mas, caso eu quisesse trabalhar com múltiplos parâmetros, validando cada possibilidade, isso seria possível? Claro! Veja o exemplo abaixo:
45 |
46 | ```clojure
47 | (defn testando-argumentos
48 | ([a] (println "Apenas um argumento foi enviado!"))
49 | ([a b] (println "Dois argumentos foram enviados!")))
50 |
51 | (testando-argumentos 1) ;; Apenas um argumento foi enviado!
52 |
53 | (testando-argumentos 1 2) ;; Dois argumentos foram enviados!
54 | ```
55 |
56 | Este caso é bem específico e trata de trabalharmos com funções que possuem tratamentos diferentes de acordo com a quantidade de argumentos recebidos!
57 |
58 | Certo, mas, caso tivéssemos a possibilidade de receber infinitos argumentos (assim como a função `+` por exemplo), seria possível? Sim! Veja o exemplo abaixo:
59 |
60 | ```clojure
61 | (defn infinitos [& args]
62 | (println args))
63 |
64 | (infinitos 1 2 3 4) ;; (1 2 3 4)
65 | ```
66 |
67 | Neste caso será recebido uma lista de argumentos, dos quais você poderá manipular cada um da forma que desejar! Caso deseje receber apenas o primeiro argumento e ter a possibilidade de receber os demais mas sem a necessidade de tratá-los, saiba que é possível de uma forma bem simples:
68 |
69 | ```clojure
70 | (defn infinitos-2 [primeiro & args]
71 | (println "O primeiro argumento foi " primeiro "\nOs demais são: " args))
72 |
73 | (infinitos-2 1 2 3 4)
74 |
75 | ;; Resultado:
76 | ;; O primeiro argumento foi 1
77 | ;; Os demais são: (2 3 4)
78 | ;; nil
79 | ```
80 |
81 | No caso acima tratamos o primeiro argumento apenas, deixando os demais em formato de lista! Caso quiséssemos tratar o segundo também poderíamos adicionar algo como `[primeiro segundo & args]` e assim por diante!
82 |
83 | ---
84 |
85 | Incrível! Agora que já temos a base de como as funções são tratadas em Clojure podemos partir para um tópico um tanto quanto mágico: recursividade!
86 |
87 | 88 | Próximo -> Recursividade 89 |
90 | 91 |92 | Voltar para o menu principal 93 |
94 | -------------------------------------------------------------------------------- /content/funcoes/funcoes_anonimas.md: -------------------------------------------------------------------------------- 1 | # Funções Anônimas 2 | 3 | Podemos definir uma função anônima como uma função que não necessariamente foi declarada, ou seja, não está vinculada a um identificador qualquer, geralmente podendo *ser passados como argumentos para outras funções*, *utilizadas como um retorno* ou realizar algum tipo de cálculo específico (não vou deixar muitos spoilers sobre os próximos tópicos). 4 | 5 | Um exemplo simples de função anônima pode ser definida seguindo o exemplo abaixo: 6 | 7 | ```clojure 8 | (def ola 9 | (fn [nome] 10 | (println "Olá," nome))) 11 | 12 | (ola "He4rt Developers") 13 | 14 | ;; Resultado: 15 | ;; Olá, He4rt Developers 16 | ;; nil 17 | ``` 18 | 19 | A sintaxe para uso de funções anônimas é bem característica, utilizando um `fn` para sua definição, podendo receber parâmetros normalmente (como no exemplo acima), sendo úteis em diversos aspectos. 20 | 21 | ## Funções que retornam outras funções 22 | 23 | Utilizar funções anônimas permite algo mágico: o retorno de outras funções para serem calculadas (eu disse que não iria dar spoiler)! 24 | 25 | Olhe o exemplo abaixo e você verá a magia acontecendo: 26 | 27 | ```clojure 28 | (defn multiplicar [multiplicar-por] 29 | (fn [n] 30 | (* n multiplicar-por))) 31 | 32 | (def dobrando 33 | (multiplicar 2)) 34 | 35 | (dobrando 2) ;; 4 36 | 37 | (def triplicando 38 | (multiplicar 3)) 39 | 40 | (triplicando 4) ;; 12 41 | ``` 42 | 43 | O funcionamento de uma função anônima neste caso foi para gerar uma nova função para realizar algum tipo de cálculo para multiplicação! Incrível não é mesmo? 44 | 45 | --- 46 | 47 | E aí, o que achou de aprender um pouco mais sobre funções anônimas? Vamos para o tópico de manipulações gerais? 48 | 49 |50 | Próximo -> Manipulações 51 |
52 | 53 |54 | Voltar para o menu principal 55 |
-------------------------------------------------------------------------------- /content/funcoes/multimethods.md: -------------------------------------------------------------------------------- 1 | # Multimethods 2 | 3 | Este com toda certeza é um dos conceitos mais incríveis para utilização com Clojure! Para entender melhor vamos para um exemplo simples: lembra quando a gente falou sobre o uso de `cond` dentro de nosso código para validar múltiplas condições existentes? Os `multimethods` vão fazer *praticamente a mesma coisa*, porém, de forma muito mais elegante! 4 | 5 | Veja um exemplo abaixo para entendermos melhor seu funcionamento: 6 | 7 | ```clojure 8 | ;; Definimos uma identidade, informando 9 | ;; que teremos um `multimethod` 10 | (defmulti fatorial identity) 11 | 12 | ;; Caso a chamada para fatorial tenha 13 | ;; como argumento `0`, então, será 14 | ;; retornado 1 15 | (defmethod fatorial 0 [_] 1) 16 | 17 | ;; Caso contrário (:default) será 18 | ;; calculado o fatorial de forma 19 | ;; recursiva 20 | (defmethod fatorial :default [n] 21 | (* n (fatorial (dec n)))) 22 | 23 | (fatorial 0) ;; 1 24 | (fatorial 1) ;; 1 25 | (fatorial 3) ;; 6 26 | ``` 27 | 28 | Neste caso podemos definir de forma mais elegante o formato de tratamento de métodos a serem utilizados dentro de Clojure, calculando apenas quando necessário de forma recursiva (alguns exemplos de implementações para cálculo de fatorial geralmente possuem um `if` para realizar essa validação). 29 | 30 | Assim, podemos dizer que o objetivo principal do `defmethod` é deixar de forma clara e compreensiva a declaração de tratamentos para os métodos em específico. 31 | 32 | --- 33 | 34 | Maravilha! Agora que já conseguimos ver sobre `multimethods` podemos passar para um tópico muito interessante: funções anônimas! 35 | 36 |37 | Próximo -> Funções Anônimas 38 |
39 | 40 |41 | Voltar para o menu principal 42 |
43 | -------------------------------------------------------------------------------- /content/funcoes/recursividade.md: -------------------------------------------------------------------------------- 1 | # Recursividade 2 | 3 | De acordo com José ROmildo Malaquias no Capítulo 6 dos [slides da disciplina de Programação Funcional](http://www.decom.ufop.br/romildo/2012-1/bcc222/slides/06-recursividade.pdf) do Departamento de Computação da Universidade Federal de Ouro Preto, podemos definir que: 4 | 5 | > Recursividade é o mecanismo de programação no qual uma definição de função ou de outro objeto refere-se ao próprio objeto sendo definido. Assim função recursiva é uma função que é definida em termos de si mesma. 6 | 7 | Podemos dizer de forma *rude* que quando presenciamos *recursividade* presenciamos o ato de uma função invocar uma sub-rotina que neste caso é ela mesma, trazendo um aspecto infinito para algo que é finito (profundo não é mesmo?). 8 | 9 | Um exemplo maneiro para recursividade seria contar números de trás pra frente (bem, jaja você vai entender a aplicabilidade disso). Veja o exemplo abaixo: 10 | 11 | ```clojure 12 | (defn contar [n] 13 | (println n) 14 | (if (pos? (dec n)) 15 | (contar (dec n)))) 16 | 17 | (contar 10) 18 | ``` 19 | 20 | O exemplo acima vai contar de `10` até `1`, retornando `nil` ao final pelo `println`. Temos a entrada de um número sendo impressa na tela, depois, a função `pos?` retorna `true` se o número é maior que `0` (validando se é positivo e maior que `0`), caso seja, chamamos novamente a função `contar` passando o valor de `n - 1` (isso mesmo, `dec` vai reduzir um número de contagem, algo parecido com `i -= 1` em outras linguagens de programação). 21 | 22 | Uma outra forma para implementação seria trocar o `contar` pelo `recur`. Veja abaixo: 23 | 24 | ```clojure 25 | (defn contar-recur [n] 26 | (println n) 27 | (if (pos? (dec n)) 28 | (recur (dec n)))) 29 | 30 | (contar-recur 10) 31 | ``` 32 | 33 | O resultado e funcionamento são os mesmos, mas, o `recur` tem algo interessante para ser dito: ele prepara a função para receber uma chamada recursiva, trabalhando-a de forma mais eficiente sem a necessidade de múltiplos empilhamentos! 34 | 35 | Ao executar `(doc recur)` temos a seguinte documentação: 36 | 37 | ```clojure 38 | ------------------------- 39 | recur 40 | (recur exprs*) 41 | Special Form 42 | Evaluates the exprs in order, then, in parallel, rebinds 43 | the bindings of the recursion point to the values of the exprs. 44 | Execution then jumps back to the recursion point, a loop or fn method. 45 | 46 | Please see http://clojure.org/special_forms#recur 47 | ``` 48 | 49 | --- 50 | 51 | O que achou de ver um pouco sobre recursividade? Pronto para conhecer os chamamos `multimethods`? 52 | 53 |54 | Próximo -> Multimethods 55 |
56 | 57 |58 | Voltar para o menu principal 59 |
60 | -------------------------------------------------------------------------------- /content/intro/README.md: -------------------------------------------------------------------------------- 1 | # Introdução
2 |
3 | ## O que é Clojure?
4 |
5 | ### História
6 |
7 | Clojure é uma linguagem de programação criada em 2007 por [Rich Hickey](https://github.com/richhickey), com dialetos da família de linguages de programação Lisp utilizando funções como estruturas de dados elementares, com conceitos envolvendo imutatibilidade de dados, sendo executada na Máquina Virtual Java (famosa JVM), mas, podendo ainda ser executada em outros ambientes, tais como o Clojure CLR (compilando o código para .NET) além de ClojureScript (que compila o código para JavaScript).
8 |
9 | - **Certo, mas, de onde veio essa ideia?**
10 |
11 | Antes de começar a desenvolver a linguagem de programação Clojure, Rich trabalhou na *dotLisp* com um projeto muito semelhante para a plataforma .NET, além de desenvolver a interface **jfli** (uma ponte de recursos do Java para Common Lisp), **FOIL** (uma interface de objetos externos para Lisp) e **Lisplets** (uma interface amigável do Lisp para Java Servlets), criando aspectos de interoperabilidade entre Lisp e Java.
12 |
13 | Levando aproximadamente 2 anos de foco total trabalhando no desenvolvimento da linguagem de programação Clojure, Rich finalmente poderia publicar um anúncio da linguagem para a comunidade Common Lisp.
14 |
15 | ### Filosofia
16 |
17 | O principal objetivo de criação da linguagem foi construir uma versão moderna da linguagem Lisp para a programação funcional, sendo executada na JVM e desenhada para computação concorrente.
18 |
19 | Podemos dizer que em Lisp como um todo, não diferente em Clojure, tudo possui formato de uma lista, na qual o primeiro item sempre será a *função*, seguido dos seus argumentos em específico, determinando ações a serem executadas.
20 |
21 | Um ponto importante para se relacionar com Clojure é que seu objetivo é ser uma linguagem de programação estável, trazendo um ambiente pronto para produção, na qual a utilização da JVM é um bônus com questões adicionais relacionados ao gerenciamento de uma máquina virtual como um todo.
22 |
23 | No artigo [A History of Clojure](https://dl.acm.org/doi/pdf/10.1145/3386321), Rich Hickey demonstra uma série de aspectos relacionados a Clojure, demonstrando mais do que tudo sua estabilidade quanto a linhas de código.
24 |
25 | 
26 |
27 | No exemplo acima podemos notar a estabilidade com linhas de código em determinado ano, demonstrando que uma aplicação Clojure construída em uma determinada versão funcionará *praticamente* perfeitamente 10 anos depois sem muitos problemas em uma versão mais atualizada.
28 |
29 | ## Onde podemos ver Clojure?
30 |
31 | Sendo utilizada por diversas empresas como Walmart, Accenture, Mercado Livre, SoundCloud e Puppet Labs, o suporte fornecido é feito pela Cognitect, que atualmente faz parte do grupo Nubank (sim, a Nubank utiliza Clojure)!
32 |
33 | A primeira versão pública de Clojure surgiu em 2007, enquanto a primeira versão estável surgiu em 2009. Atualmente estamos na versão 1.11.1 (do dia 5 de abril de 2022)!
34 |
35 | ---
36 |
37 | E aí? Gostou da linguagem Clojure? O que acha de realizarmos sua "instalação" e começarmos nossos primeiros testes?
38 |
39 | 40 | Próximo -> Instalação 41 |
42 | 43 |44 | Voltar para o menu principal 45 |
46 | -------------------------------------------------------------------------------- /content/intro/hello_world.clj: -------------------------------------------------------------------------------- 1 | ;; Feito com muito amor e dedicação! 2 | ;; λ 3 | ;; hello_world.clj 4 | 5 | (println "Hello World") 6 | -------------------------------------------------------------------------------- /content/intro/helloworld.md: -------------------------------------------------------------------------------- 1 | # Hello World! 2 | 3 | Certo, agora é o momento de nosso primeiro contato com a linguagem de programação Clojure! Obviamente o clássico "Hello World" não ficaria de fora! Por conta disso, abra seu editor de código favorito e vamos para a prática! 4 | 5 | ## Exibindo na tela 6 | 7 | Agora é o momento de você criar um arquivo com a extensão `.clj`! Eu chamei meu arquivo de `hello_world.clj`... Lembre-se que como Clojure funciona com a famosa JVM, logo, temos contato com praticamente todas as funções do Java (sim, isso significa interoperabilidade)! 8 | 9 | Chega de papo e bora pro código, depois a gente vai repassar detalhe por detalhe de funcionamento, por isso, acalme-se! Observe o código abaixo: 10 | 11 | ```clj 12 | (println "Hello World") 13 | ``` 14 | 15 | Para testarmos, basta abrir o terminal e executar: 16 | 17 | ```sh 18 | $ clj hello_world.clj 19 | ``` 20 | 21 | Você verá o retorno da mensagem na tela! 22 | 23 | ## Parênteses 24 | 25 | Você percebeu que a sintaxe de Clojure é um pouco diferente do que encontramos no Java, não? Porém a função para imprimir algo chamada `println` possui o mesmo nome, mesmo que não venha com `System.out` anteriormente! 26 | 27 | Por qual motivo a sintaxe é assim? Simples: Clojure utiliza conceitos voltados para Lisp, que possui uma sintaxe extremamente parecida - com notações prefixas - e o característico uso de parênteses! 28 | 29 | Ainda vamos entrar com mais detalhes sobre a sintaxe e funcionamento no geral, mas, por agora, não se preocupe! Apenas tenha certeza que tudo funcionou corretamente! 30 | 31 | --- 32 | 33 | Pronto! Agora que você já teve seu primeiro contato com a linguagem de programação Clojure, podemos avançar para os próximos desenvolvimentos! O que você achou? 34 | 35 | Caso você queira estudar um pouco mais sobre Lisp, recomendo os materiais da [UFRN](https://www.dca.ufrn.br/~adelardo/lisp/) e [UFG](https://ww2.inf.ufg.br/~eduardo/lp/alunos/lisp/intro.html)! 36 | 37 |38 | Próximo -> Leiningen 39 |
40 | 41 |42 | Voltar para o menu principal 43 |
44 | -------------------------------------------------------------------------------- /content/intro/instalacao.md: -------------------------------------------------------------------------------- 1 | # Instalação 2 | 3 | Bom, se você chegou até aqui, quer dizer que realmente está interessado em dar continuidade nesse aprendizado! Agora vamos instalar e preparar nosso ambiente de desenvolvimento! 4 | 5 | ## Sistemas operacionais 6 | - [macOS](https://github.com/lanjoni/clojure4noobs/blob/main/content/intro/instalacao.md#macos) 7 | - [Windows](https://github.com/lanjoni/clojure4noobs/blob/main/content/intro/instalacao.md#windows) 8 | - [Linux](https://github.com/lanjoni/clojure4noobs/blob/main/content/intro/instalacao.md#linux) 9 | 10 | Teve algum problema com a instalação? Clique [aqui](https://clojure.org/guides/install_clojure) para acessar a documentação oficial de instalação! 11 | 12 | > Pré-requisito: já ter instalado Java/JDK! Clique [aqui](https://clojure.org/guides/install_clojure#java) para saber mais. 13 | 14 | --- 15 | 16 | ### macOS 17 | 18 | A instalação do Clojure para o macOS é feita utilizando o gerenciador de pacotes [Homebrew](https://brew.sh/). Para realizar sua instalação utilize os seguintes comandos no terminal: 19 | 20 | ```sh 21 | $ brew update 22 | $ brew install clojure/tools/clojure 23 | # ou 24 | $ brew install clojure 25 | ``` 26 | 27 | Para instalar uma nova versão do Clojure basta executar: 28 | 29 | ```sh 30 | $ brew upgrade clojure/tools/clojure 31 | # ou 32 | $ brew upgrade clojure 33 | ``` 34 | 35 | Para mais informações sobre a instalação do Clojure no macOS clique [aqui](https://clojure.org/guides/install_clojure#_mac_os_instructions)! 36 | 37 | # 38 | 39 | ### Windows 40 | 41 | Para a instalação do ambiente no Windows tenha certeza de que esteja utilizando o `PowerShell 5` ou superior, além do `.NET Core SDK 2.1+` ou `.NET Framework 4.5+`, além de obviamente ter o `Java 8+` (com o JDK) instalado. 42 | 43 | Assim que tudo estiver instalado corretametne, basta realizar o download do script clicando [aqui](https://download.clojure.org/install/win-install-1.11.1.1165.ps1). 44 | 45 | Assim que você executar o instalador pelo PowerShell, você vai se deparar com uma tela parecida com esta: 46 | 47 | ```sh 48 | PS Y:\Downloads> .\win-install-1.11.1.1165.ps1 49 | Downloading Clojure tools 50 | WARNING: Clojure will install as a module in your PowerShell module path. 51 | 52 | Possible install locations: 53 | 1) \\Drive\Home\Documents\WindowsPowerShell\Modules 54 | 2) C:\Program Files\WindowsPowerShell\Modules 55 | 3) C:\WINDOWS\system32\WindowsPowerShell\v1.0\Modules\ 56 | Enter number of preferred install location: 1 57 | 58 | Cleaning up existing install 59 | Installing PowerShell module 60 | Removing download 61 | Clojure now installed. Use "clj -h" for help. 62 | ``` 63 | 64 | Para testar, utilize o comando: 65 | 66 | ```sh 67 | > powershell -command clj 68 | ``` 69 | 70 | Caso tenha algum problema de instalação, basta clicar [aqui](https://github.com/clojure/tools.deps.alpha/wiki/clj-on-Windows) para acessar o guia oficial da instalação com Windows! 71 | 72 | # 73 | 74 | ### Linux 75 | 76 | As distribuições Linux no geral estão concentradas aqui pois o script de instalação é o mesmo! Caso você esteja utilizando o Homebrew como gerenciador de pacotes, basta utilizar o mesmo comando que o utilizado no macOS! Caso contrário, siga os passos abaixo. 77 | 78 | Tenha certeza de que você possui instalado os pacotes `curl` (para realizar requisições em urls), `rlwrap` (para não deixar nenhum "bug" de interface no cli do Clojure, impedindo que se movimente com as setas) e `Java` (com JDK completamente instalado). 79 | 80 | O script deixado vai criar um executáveis nos caminhos `/usr/local/bin/clj` e `/usr/local/bin/clojure`, além do diretório `/usr/local/lib/clojure`. Segue o script: 81 | 82 | ```sh 83 | $ curl -O https://download.clojure.org/install/linux-install-1.11.1.1273.sh 84 | $ chmod +x linux-install-1.11.1.1273.sh 85 | $ sudo ./linux-install-1.11.1.1273.sh 86 | ``` 87 | 88 | Depois de instalado o script `linux-install` pode ser removido. Caso tenha algum problema durante a instalação, basta clicar [aqui](https://clojure.org/guides/install_clojure#_linux_instructions) e seguir o guia oficial de instalação para distribuições Linux! 89 | 90 | > Caso queira instalar utilizando seu gerenciador de pacotes pasta procurar pelo pacote `clojure`! 91 | 92 | --- 93 | 94 | E aí, tudo instalado corretamente? É hora de termos o nosso primeiro contato com a linguagem! 95 | 96 |97 | Próximo -> Hello World! 98 |
99 | 100 |101 | Voltar para o menu principal 102 |
103 | -------------------------------------------------------------------------------- /content/intro/leiningen.md: -------------------------------------------------------------------------------- 1 | # Leiningen
2 |
3 | Leiningen é um gerenciador de dependências com diversas funcionalidades para construção de uma aplicação em Clojure.
4 |
5 | ## Como instalar?
6 |
7 | Acessando a [página oficial](https://leiningen.org/) você vai se deparar com um script de instalação para qualquer sistema operacional que esteja utilizando. Além disso, você pode instalar utilizando seu gerenciador de pacotes preferidos, como no macOS utilizando o Homebrew.
8 |
9 | Por exemplo, utilizando o Homebrew basta executar `brew install leiningen`!
10 |
11 | ## Utilizando
12 |
13 | Para criar um novo projeto utilizando o Leiningen basta executar:
14 |
15 | ```sh
16 | $ lein new app test
17 | ```
18 |
19 | > Neste exemplo vamos criar um projeto com o template `app`, mas, ainda existem outros dois templates que podem ser utilizados! Para verificar quais são estas possibilidades basta executar `lein help new`!
20 |
21 | Certo, com nosso projeto criado você vai perceber que um diretório surgiu com o nome `test`, ou seja, nosso template foi criado com sucesso. Agora, basta entrar neste diretório e você vai se deparar com uma estrutura parecida com isso:
22 |
23 | ```md
24 | ├── CHANGELOG.md
25 | ├── LICENSE
26 | ├── README.md
27 | ├── doc
28 | │ └── intro.md
29 | ├── project.clj
30 | ├── resources
31 | ├── src
32 | │ └── test
33 | │ └── core.clj
34 | ├── target
35 | │ └── test
36 | │ └── stale
37 | │ └── leiningen.core.classpath.extract-native-dependencies
38 | └── test
39 | └── test
40 | └── core_test.clj
41 | ```
42 |
43 | Neste momento podemos verificar alguns arquivos interessantes como o `project.clj` que determina as dependências de nosso projeto, `src/test/core.clj` que seria literalmente o "core" (reconhecido em outras linguagens como o chamado "main" ou "arquivo principal de execução"), além de outros aspectos como geração automática de diretório para testes.
44 |
45 | Agora, abra seu arquivo "core" e vamos dar uma olhada no que ele tem para oferecer!
46 |
47 | ```clj
48 | (ns test.core
49 | (:gen-class))
50 |
51 | (defn -main
52 | "I don't do a whole lot ... yet."
53 | [& args]
54 | (println "Hello, World!"))
55 | ```
56 |
57 | Perceba que temos a definição de um `main` a ser executado quando executarmos nosso projeto! Para executar basta utilizar `lein run` e será impresso uma mensagem "Hello, World!"! Legal não?
58 |
59 | Existem ainda diversas possibilidades ao se utilizar o Leiningen, por isso, durante nosso guia introdutório vamos utilizá-lo sempre que possível!
60 |
61 | ## REPL
62 |
63 | Sim, o Leiningen oferece um "REPL" (Read-Eval-Print Loop) para ser utilizado nativamente em seus projetos, sendo útil para interação direta com uma interface de testes, desenvolvimento com REPL dentre outras finalidades (acredite, sua produtividade e praticidade de desenvolvimento melhoram muito quando você torna o REPL seu amigo)! Para executarmos basta utilizar o comando `lein repl` e você vai se deparar com uma tela parecida com essa:
64 |
65 | ```sh
66 | nREPL server started on port 49654 on host 127.0.0.1 - nrepl://127.0.0.1:49654
67 | REPL-y 0.5.1, nREPL 1.0.0
68 | Clojure 1.11.1
69 | OpenJDK 64-Bit Server VM 19.0.2
70 | Docs: (doc function-name-here)
71 | (find-doc "part-of-name-here")
72 | Source: (source function-name-here)
73 | Javadoc: (javadoc java-object-or-class-here)
74 | Exit: Control+D or (exit) or (quit)
75 | Results: Stored in vars *1, *2, *3, an exception in *e
76 |
77 | test.core=>
78 | ```
79 |
80 | Utilizando o "REPL" podemos ainda importar funções diretamente de nosso projeto e realizar diversos testes! Ainda conseguimos criar funções e testar possibilidades! Legal não?
81 |
82 | ---
83 |
84 | Excelente! Tivemos nosso primeiro contato com o Leiningen! O que achou? Bora aprender alguns conceitos envolvendo a linguagem de programação Clojure?
85 |
86 | 87 | Próximo -> Conceitos 88 |
89 | 90 |91 | Voltar para o menu principal 92 |
93 | -------------------------------------------------------------------------------- /content/manipulacoes/README.md: -------------------------------------------------------------------------------- 1 | # Manipulações 2 | 3 | Muito bem! Neste capítulo vamos abordar aspectos principais sobre o funcionamento de manipulações gerais que podem ser feitas com Clojure em um aspecto geral, utilizando neste caso: [map](https://clojuredocs.org/clojure.core/map), [filter](https://clojuredocs.org/clojure.core/filter), [reduce](https://clojuredocs.org/clojure.core/reduce) e [apply](https://clojuredocs.org/clojure.core/apply)! 4 | 5 | --- 6 | 7 | Animado para mais um tópico? Vamos começar com o map? 8 | 9 |10 | Próximo -> Map 11 |
12 | 13 |14 | Voltar para o menu principal 15 |
16 | -------------------------------------------------------------------------------- /content/manipulacoes/apply.md: -------------------------------------------------------------------------------- 1 | # Apply 2 | 3 | O principal uso do `apply` é no momento de necessidade de aplicação para uma coleção em alguma função, na qual precisamos passar um vetor completo ao invés dos parâmetros puros. 4 | 5 | Um exemplo simples utilizando a função `max` (que compara os valores recebidos como argumentos e retorna o maior) está apresentado abaixo: 6 | 7 | ```clojure 8 | (apply max [1 2 3 4 5]) ;; 5 9 | 10 | (max 1 2 3 4 5) ;; 5 11 | 12 | ;; Função não é aplicada corretamente 13 | ;; porque o vetor é visto como um 14 | ;; único parâmetro! 15 | (max [1 2 3 4 5]) ;; [1 2 3 4 5] 16 | ``` 17 | 18 | Basicamente poderíamos dizer que o `apply` literalmente *aplica* uma coleção como argumentos para uma determinada função, sendo extremamente útil para outras funcionalidades também! 19 | 20 | Sua facilidade é encontrada quando sabemos que podemos retornar um vetor em determinados casos e tratá-lo como uma lista de argumentos e execuções para serem aplicadas. 21 | 22 | --- 23 | 24 | Gostou de conhecer o `apply`? O que acha de partirmos para nosso último tópico: criando um mini servidor HTTP com Clojure? 25 | 26 |27 | Próximo -> Mini servidor HTTP 28 |
29 | 30 |31 | Voltar para o menu principal 32 |
33 | -------------------------------------------------------------------------------- /content/manipulacoes/filter.md: -------------------------------------------------------------------------------- 1 | # Filter 2 | 3 | Certo, sabemos que o `map` aplica uma função para uma coleção e retorna uma lista dos resultados, mas, imagine se fosse possível *filtrar* uma coleção de acordo com uma condição e retornar ao final uma lista com os itens que são compatíveis? 4 | 5 | Essa é a finalidade *principal* do `filter`, por isso, veja o exemplo abaixo para entender um pouco mais sobre: 6 | 7 | ```clojure 8 | (filter odd? (range 1 21)) 9 | 10 | ;; Resultado: 11 | ;; (1 3 5 7 9 11 13 15 17 19) 12 | ``` 13 | 14 | Temos o `range` que gera uma coleção completa de valores de `1` até `19`, no qual são validados pela função `odd?`, verificando se o número informado é ímpar. Caso seja é adicionado na lista final de retorno, senão é descartado. 15 | 16 | O funcionamento quanto ao uso de funções anônimas é idêntico ao `map`, assim, irei adicionar uma demonstração com uma função declarada, por isso, veja o exemplo abaixo: 17 | 18 | ```clojure 19 | (defn maior-que-3 [n] 20 | (> n 3)) 21 | 22 | (filter maior-que-3 (range 1 10)) 23 | 24 | ;; Resultado: 25 | ;; (4 5 6 7 8 9) 26 | ``` 27 | 28 | Assim, podemos facilmente repassar parâmetros e validações a serem realizadas pelo `filter` em específico! 29 | 30 | --- 31 | 32 | E então, curtiu o funcionamento do `filter`? Bem, o que acha de conhecer o `reduce`? 33 | 34 |35 | Próximo -> Reduce 36 |
37 | 38 |39 | Voltar para o menu principal 40 |
41 | -------------------------------------------------------------------------------- /content/manipulacoes/map.md: -------------------------------------------------------------------------------- 1 | # Map 2 | 3 | Imagine ter uma coleção de valores qualquer e poder aplicar um *efeito* sobre todos os elementos, podendo *mapeá-los* e aplicar uma função específica para todos, retornando ao final uma lista com o resultado? 4 | 5 | Para a tarefa citada acima o `map` será seu maior amigo! Veja um exemplo simples abaixo: 6 | 7 | ```clojure 8 | (map inc [1 2 3 4 5]) 9 | 10 | ;; Resultado: 11 | ;; (2 3 4 5 6) 12 | ``` 13 | 14 | Basicamente aplicamos a função `inc` (que adiciona `1` para cada valor como um contador) em cada um dos elementos da coleção enviada, retornando uma lista ao final. 15 | 16 | Poderíamos ainda utilizar funções anônimas para realização de cálculos, como no exemplo abaixo: 17 | 18 | ```clojure 19 | (map (fn [n] (* n 2)) [1 2 3]) 20 | 21 | ;; Resultado 22 | ;; (2 4 6) 23 | ``` 24 | 25 | Uma outra forma de realizar o mesmo cálculo é não necessariamente *declarando uma função anônima*, mas, utilizando a sintaxe abaixo: 26 | 27 | ```clojure 28 | (map #(* % 2) [1 2 3]) 29 | 30 | ;; Resultado 31 | ;; (2 4 6) 32 | ``` 33 | 34 | Podemos dizer que o `#` é utilizado para indicar o uso de uma *função anônima*, enquanto o `%` é utilizado para indicar o valor que seria passado como argumento, simplificando ainda mais o processo! 35 | 36 | --- 37 | 38 | O que achou de conhecer o `map`? Vamos dar uma olhada no `filter`? 39 | 40 |41 | Próximo -> Filter 42 |
43 | 44 |45 | Voltar para o menu principal 46 |
47 | -------------------------------------------------------------------------------- /content/manipulacoes/reduce.md: -------------------------------------------------------------------------------- 1 | # Reduce 2 | 3 | Imagine poder mapear uma coleção e retornar um único resultado, sendo este o resultado aplicado para o conjunto completo de forma *encadeada*? 4 | 5 | Parece um pouco complexo mas garanto que é prático de se utilizar, por isso, veja o exemplo abaixo: 6 | 7 | ```clojure 8 | (reduce + [1 2 3 4]) 9 | 10 | ;; Resultado: 11 | ;; 10 12 | ``` 13 | 14 | Basicamente o `reduce` foi aplicado na sequência apresentada, simplificando algo como `(+ 4 (+ 3 (+ 1 2)))`! 15 | 16 | Um outro exemplo, mas, agora utilizando uma função seria: 17 | 18 | ```clojure 19 | (defn multiplicar [a b] 20 | (* a b)) 21 | 22 | (reduce multiplicar [1 2 3 4]) 23 | 24 | ;; Resultado: 25 | ;; 24 26 | ``` 27 | 28 | O funcionamento foi seguindo o formato anterior, porém, com uma função em específico. Poderíamos decompor como: `1 * 2 = 2` -> `2 * 3 = 6` -> `6 * 4 = 24`! Sua utilização é baseada na aplicação completa em uma coleção. 29 | 30 | --- 31 | 32 | O que achou do `reduce`? Prático não é mesmo? Vamos conhecer o `apply`? 33 | 34 |35 | Próximo -> Apply 36 |
37 | 38 |39 | Voltar para o menu principal 40 |
41 | -------------------------------------------------------------------------------- /content/projeto/http-simples/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | /classes 3 | /checkouts 4 | profiles.clj 5 | pom.xml 6 | pom.xml.asc 7 | *.jar 8 | *.class 9 | /.lein-* 10 | /.nrepl-port 11 | /.prepl-port 12 | .hgignore 13 | .hg/ 14 | -------------------------------------------------------------------------------- /content/projeto/http-simples/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Change Log 2 | All notable changes to this project will be documented in this file. This change log follows the conventions of [keepachangelog.com](http://keepachangelog.com/). 3 | 4 | ## [Unreleased] 5 | ### Changed 6 | - Add a new arity to `make-widget-async` to provide a different widget shape. 7 | 8 | ## [0.1.1] - 2023-11-07 9 | ### Changed 10 | - Documentation on how to make the widgets. 11 | 12 | ### Removed 13 | - `make-widget-sync` - we're all async, all the time. 14 | 15 | ### Fixed 16 | - Fixed widget maker to keep working when daylight savings switches over. 17 | 18 | ## 0.1.0 - 2023-11-07 19 | ### Added 20 | - Files from the new template. 21 | - Widget maker public API - `make-widget-sync`. 22 | 23 | [Unreleased]: https://sourcehost.site/your-name/http-simples/compare/0.1.1...HEAD 24 | [0.1.1]: https://sourcehost.site/your-name/http-simples/compare/0.1.0...0.1.1 25 | -------------------------------------------------------------------------------- /content/projeto/http-simples/LICENSE: -------------------------------------------------------------------------------- 1 | Eclipse Public License - v 2.0 2 | 3 | THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE 4 | PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION 5 | OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. 6 | 7 | 1. DEFINITIONS 8 | 9 | "Contribution" means: 10 | 11 | a) in the case of the initial Contributor, the initial content 12 | Distributed under this Agreement, and 13 | 14 | b) in the case of each subsequent Contributor: 15 | i) changes to the Program, and 16 | ii) additions to the Program; 17 | where such changes and/or additions to the Program originate from 18 | and are Distributed by that particular Contributor. A Contribution 19 | "originates" from a Contributor if it was added to the Program by 20 | such Contributor itself or anyone acting on such Contributor's behalf. 21 | Contributions do not include changes or additions to the Program that 22 | are not Modified Works. 23 | 24 | "Contributor" means any person or entity that Distributes the Program. 25 | 26 | "Licensed Patents" mean patent claims licensable by a Contributor which 27 | are necessarily infringed by the use or sale of its Contribution alone 28 | or when combined with the Program. 29 | 30 | "Program" means the Contributions Distributed in accordance with this 31 | Agreement. 32 | 33 | "Recipient" means anyone who receives the Program under this Agreement 34 | or any Secondary License (as applicable), including Contributors. 35 | 36 | "Derivative Works" shall mean any work, whether in Source Code or other 37 | form, that is based on (or derived from) the Program and for which the 38 | editorial revisions, annotations, elaborations, or other modifications 39 | represent, as a whole, an original work of authorship. 40 | 41 | "Modified Works" shall mean any work in Source Code or other form that 42 | results from an addition to, deletion from, or modification of the 43 | contents of the Program, including, for purposes of clarity any new file 44 | in Source Code form that contains any contents of the Program. Modified 45 | Works shall not include works that contain only declarations, 46 | interfaces, types, classes, structures, or files of the Program solely 47 | in each case in order to link to, bind by name, or subclass the Program 48 | or Modified Works thereof. 49 | 50 | "Distribute" means the acts of a) distributing or b) making available 51 | in any manner that enables the transfer of a copy. 52 | 53 | "Source Code" means the form of a Program preferred for making 54 | modifications, including but not limited to software source code, 55 | documentation source, and configuration files. 56 | 57 | "Secondary License" means either the GNU General Public License, 58 | Version 2.0, or any later versions of that license, including any 59 | exceptions or additional permissions as identified by the initial 60 | Contributor. 61 | 62 | 2. GRANT OF RIGHTS 63 | 64 | a) Subject to the terms of this Agreement, each Contributor hereby 65 | grants Recipient a non-exclusive, worldwide, royalty-free copyright 66 | license to reproduce, prepare Derivative Works of, publicly display, 67 | publicly perform, Distribute and sublicense the Contribution of such 68 | Contributor, if any, and such Derivative Works. 69 | 70 | b) Subject to the terms of this Agreement, each Contributor hereby 71 | grants Recipient a non-exclusive, worldwide, royalty-free patent 72 | license under Licensed Patents to make, use, sell, offer to sell, 73 | import and otherwise transfer the Contribution of such Contributor, 74 | if any, in Source Code or other form. This patent license shall 75 | apply to the combination of the Contribution and the Program if, at 76 | the time the Contribution is added by the Contributor, such addition 77 | of the Contribution causes such combination to be covered by the 78 | Licensed Patents. The patent license shall not apply to any other 79 | combinations which include the Contribution. No hardware per se is 80 | licensed hereunder. 81 | 82 | c) Recipient understands that although each Contributor grants the 83 | licenses to its Contributions set forth herein, no assurances are 84 | provided by any Contributor that the Program does not infringe the 85 | patent or other intellectual property rights of any other entity. 86 | Each Contributor disclaims any liability to Recipient for claims 87 | brought by any other entity based on infringement of intellectual 88 | property rights or otherwise. As a condition to exercising the 89 | rights and licenses granted hereunder, each Recipient hereby 90 | assumes sole responsibility to secure any other intellectual 91 | property rights needed, if any. For example, if a third party 92 | patent license is required to allow Recipient to Distribute the 93 | Program, it is Recipient's responsibility to acquire that license 94 | before distributing the Program. 95 | 96 | d) Each Contributor represents that to its knowledge it has 97 | sufficient copyright rights in its Contribution, if any, to grant 98 | the copyright license set forth in this Agreement. 99 | 100 | e) Notwithstanding the terms of any Secondary License, no 101 | Contributor makes additional grants to any Recipient (other than 102 | those set forth in this Agreement) as a result of such Recipient's 103 | receipt of the Program under the terms of a Secondary License 104 | (if permitted under the terms of Section 3). 105 | 106 | 3. REQUIREMENTS 107 | 108 | 3.1 If a Contributor Distributes the Program in any form, then: 109 | 110 | a) the Program must also be made available as Source Code, in 111 | accordance with section 3.2, and the Contributor must accompany 112 | the Program with a statement that the Source Code for the Program 113 | is available under this Agreement, and informs Recipients how to 114 | obtain it in a reasonable manner on or through a medium customarily 115 | used for software exchange; and 116 | 117 | b) the Contributor may Distribute the Program under a license 118 | different than this Agreement, provided that such license: 119 | i) effectively disclaims on behalf of all other Contributors all 120 | warranties and conditions, express and implied, including 121 | warranties or conditions of title and non-infringement, and 122 | implied warranties or conditions of merchantability and fitness 123 | for a particular purpose; 124 | 125 | ii) effectively excludes on behalf of all other Contributors all 126 | liability for damages, including direct, indirect, special, 127 | incidental and consequential damages, such as lost profits; 128 | 129 | iii) does not attempt to limit or alter the recipients' rights 130 | in the Source Code under section 3.2; and 131 | 132 | iv) requires any subsequent distribution of the Program by any 133 | party to be under a license that satisfies the requirements 134 | of this section 3. 135 | 136 | 3.2 When the Program is Distributed as Source Code: 137 | 138 | a) it must be made available under this Agreement, or if the 139 | Program (i) is combined with other material in a separate file or 140 | files made available under a Secondary License, and (ii) the initial 141 | Contributor attached to the Source Code the notice described in 142 | Exhibit A of this Agreement, then the Program may be made available 143 | under the terms of such Secondary Licenses, and 144 | 145 | b) a copy of this Agreement must be included with each copy of 146 | the Program. 147 | 148 | 3.3 Contributors may not remove or alter any copyright, patent, 149 | trademark, attribution notices, disclaimers of warranty, or limitations 150 | of liability ("notices") contained within the Program from any copy of 151 | the Program which they Distribute, provided that Contributors may add 152 | their own appropriate notices. 153 | 154 | 4. COMMERCIAL DISTRIBUTION 155 | 156 | Commercial distributors of software may accept certain responsibilities 157 | with respect to end users, business partners and the like. While this 158 | license is intended to facilitate the commercial use of the Program, 159 | the Contributor who includes the Program in a commercial product 160 | offering should do so in a manner which does not create potential 161 | liability for other Contributors. Therefore, if a Contributor includes 162 | the Program in a commercial product offering, such Contributor 163 | ("Commercial Contributor") hereby agrees to defend and indemnify every 164 | other Contributor ("Indemnified Contributor") against any losses, 165 | damages and costs (collectively "Losses") arising from claims, lawsuits 166 | and other legal actions brought by a third party against the Indemnified 167 | Contributor to the extent caused by the acts or omissions of such 168 | Commercial Contributor in connection with its distribution of the Program 169 | in a commercial product offering. The obligations in this section do not 170 | apply to any claims or Losses relating to any actual or alleged 171 | intellectual property infringement. In order to qualify, an Indemnified 172 | Contributor must: a) promptly notify the Commercial Contributor in 173 | writing of such claim, and b) allow the Commercial Contributor to control, 174 | and cooperate with the Commercial Contributor in, the defense and any 175 | related settlement negotiations. The Indemnified Contributor may 176 | participate in any such claim at its own expense. 177 | 178 | For example, a Contributor might include the Program in a commercial 179 | product offering, Product X. That Contributor is then a Commercial 180 | Contributor. If that Commercial Contributor then makes performance 181 | claims, or offers warranties related to Product X, those performance 182 | claims and warranties are such Commercial Contributor's responsibility 183 | alone. Under this section, the Commercial Contributor would have to 184 | defend claims against the other Contributors related to those performance 185 | claims and warranties, and if a court requires any other Contributor to 186 | pay any damages as a result, the Commercial Contributor must pay 187 | those damages. 188 | 189 | 5. NO WARRANTY 190 | 191 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT 192 | PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS" 193 | BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR 194 | IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF 195 | TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR 196 | PURPOSE. Each Recipient is solely responsible for determining the 197 | appropriateness of using and distributing the Program and assumes all 198 | risks associated with its exercise of rights under this Agreement, 199 | including but not limited to the risks and costs of program errors, 200 | compliance with applicable laws, damage to or loss of data, programs 201 | or equipment, and unavailability or interruption of operations. 202 | 203 | 6. DISCLAIMER OF LIABILITY 204 | 205 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT 206 | PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS 207 | SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 208 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST 209 | PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 210 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 211 | ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE 212 | EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE 213 | POSSIBILITY OF SUCH DAMAGES. 214 | 215 | 7. GENERAL 216 | 217 | If any provision of this Agreement is invalid or unenforceable under 218 | applicable law, it shall not affect the validity or enforceability of 219 | the remainder of the terms of this Agreement, and without further 220 | action by the parties hereto, such provision shall be reformed to the 221 | minimum extent necessary to make such provision valid and enforceable. 222 | 223 | If Recipient institutes patent litigation against any entity 224 | (including a cross-claim or counterclaim in a lawsuit) alleging that the 225 | Program itself (excluding combinations of the Program with other software 226 | or hardware) infringes such Recipient's patent(s), then such Recipient's 227 | rights granted under Section 2(b) shall terminate as of the date such 228 | litigation is filed. 229 | 230 | All Recipient's rights under this Agreement shall terminate if it 231 | fails to comply with any of the material terms or conditions of this 232 | Agreement and does not cure such failure in a reasonable period of 233 | time after becoming aware of such noncompliance. If all Recipient's 234 | rights under this Agreement terminate, Recipient agrees to cease use 235 | and distribution of the Program as soon as reasonably practicable. 236 | However, Recipient's obligations under this Agreement and any licenses 237 | granted by Recipient relating to the Program shall continue and survive. 238 | 239 | Everyone is permitted to copy and distribute copies of this Agreement, 240 | but in order to avoid inconsistency the Agreement is copyrighted and 241 | may only be modified in the following manner. The Agreement Steward 242 | reserves the right to publish new versions (including revisions) of 243 | this Agreement from time to time. No one other than the Agreement 244 | Steward has the right to modify this Agreement. The Eclipse Foundation 245 | is the initial Agreement Steward. The Eclipse Foundation may assign the 246 | responsibility to serve as the Agreement Steward to a suitable separate 247 | entity. Each new version of the Agreement will be given a distinguishing 248 | version number. The Program (including Contributions) may always be 249 | Distributed subject to the version of the Agreement under which it was 250 | received. In addition, after a new version of the Agreement is published, 251 | Contributor may elect to Distribute the Program (including its 252 | Contributions) under the new version. 253 | 254 | Except as expressly stated in Sections 2(a) and 2(b) above, Recipient 255 | receives no rights or licenses to the intellectual property of any 256 | Contributor under this Agreement, whether expressly, by implication, 257 | estoppel or otherwise. All rights in the Program not expressly granted 258 | under this Agreement are reserved. Nothing in this Agreement is intended 259 | to be enforceable by any entity that is not a Contributor or Recipient. 260 | No third-party beneficiary rights are created under this Agreement. 261 | 262 | Exhibit A - Form of Secondary Licenses Notice 263 | 264 | "This Source Code may also be made available under the following 265 | Secondary Licenses when the conditions for such availability set forth 266 | in the Eclipse Public License, v. 2.0 are satisfied: GNU General Public 267 | License as published by the Free Software Foundation, either version 2 268 | of the License, or (at your option) any later version, with the GNU 269 | Classpath Exception which is available at 270 | https://www.gnu.org/software/classpath/license.html." 271 | 272 | Simply including a copy of this Agreement, including this Exhibit A 273 | is not sufficient to license the Source Code under Secondary Licenses. 274 | 275 | If it is not possible or desirable to put the notice in a particular 276 | file, then You may include the notice in a location (such as a LICENSE 277 | file in a relevant directory) where a recipient would be likely to 278 | look for such a notice. 279 | 280 | You may add additional accurate notices of copyright ownership. 281 | -------------------------------------------------------------------------------- /content/projeto/http-simples/README.md: -------------------------------------------------------------------------------- 1 | # http-simples 2 | 3 | FIXME: description 4 | 5 | ## Installation 6 | 7 | Download from http://example.com/FIXME. 8 | 9 | ## Usage 10 | 11 | FIXME: explanation 12 | 13 | $ java -jar http-simples-0.1.0-standalone.jar [args] 14 | 15 | ## Options 16 | 17 | FIXME: listing of options this app accepts. 18 | 19 | ## Examples 20 | 21 | ... 22 | 23 | ### Bugs 24 | 25 | ... 26 | 27 | ### Any Other Sections 28 | ### That You Think 29 | ### Might be Useful 30 | 31 | ## License 32 | 33 | Copyright © 2023 FIXME 34 | 35 | This program and the accompanying materials are made available under the 36 | terms of the Eclipse Public License 2.0 which is available at 37 | http://www.eclipse.org/legal/epl-2.0. 38 | 39 | This Source Code may also be made available under the following Secondary 40 | Licenses when the conditions for such availability set forth in the Eclipse 41 | Public License, v. 2.0 are satisfied: GNU General Public License as published by 42 | the Free Software Foundation, either version 2 of the License, or (at your 43 | option) any later version, with the GNU Classpath Exception which is available 44 | at https://www.gnu.org/software/classpath/license.html. 45 | -------------------------------------------------------------------------------- /content/projeto/http-simples/doc/intro.md: -------------------------------------------------------------------------------- 1 | # Introduction to http-simples 2 | 3 | TODO: write [great documentation](http://jacobian.org/writing/what-to-write/) 4 | -------------------------------------------------------------------------------- /content/projeto/http-simples/project.clj: -------------------------------------------------------------------------------- 1 | (defproject http-simples "0.1.0-SNAPSHOT" 2 | :description "FIXME: write description" 3 | :url "http://example.com/FIXME" 4 | :license {:name "EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0" 5 | :url "https://www.eclipse.org/legal/epl-2.0/"} 6 | :dependencies [[org.clojure/clojure "1.11.1"] 7 | [http-kit "2.7.0"]] 8 | :main ^:skip-aot http-simples.core 9 | :target-path "target/%s" 10 | :profiles {:uberjar {:aot :all 11 | :jvm-opts ["-Dclojure.compiler.direct-linking=true"]}}) 12 | -------------------------------------------------------------------------------- /content/projeto/http-simples/src/http_simples/core.clj: -------------------------------------------------------------------------------- 1 | (ns http-simples.core 2 | (:require [org.httpkit.server :refer [run-server]])) 3 | 4 | (defn app [req] 5 | {:status 200 6 | :headers {"Content-Type" "text/html"} 7 | :body (str "Salve He4rt Developers <3")}) 8 | 9 | (defn -main [& args] 10 | (run-server app {:port 3000}) 11 | (println "Server inicializado na porta 3000")) 12 | -------------------------------------------------------------------------------- /content/projeto/http-simples/test/http_simples/core_test.clj: -------------------------------------------------------------------------------- 1 | (ns http-simples.core-test 2 | (:require [clojure.test :refer :all] 3 | [http-simples.core :refer :all])) 4 | 5 | (deftest a-test 6 | (testing "FIXME, I fail." 7 | (is (= 0 1)))) 8 | -------------------------------------------------------------------------------- /content/projeto/http.md: -------------------------------------------------------------------------------- 1 | # Mini servidor HTTP 2 | 3 | Neste último tópico vamos criar um simples servidor HTTP passo a passo para você ver como é simples! O objetivo aqui é te apresentar o formato de gerenciamento de projeto com [Leiningen](https://leiningen.org/), apresentando um pouco do mundo de um projeto real! 4 | 5 | ## Criando seu projeto 6 | 7 | Bem, primeiramente crie um projeto com o nome `http-simples`: 8 | 9 | ```sh 10 | $ lein new app http-simples 11 | ``` 12 | > O nome `app` é o template esperado! Para entender melhor o funcionamento execute `lein help new`! 13 | 14 | Bom, agora que seu projeto está criado a estrutura será similar ao que temos abaixo: 15 | 16 | ``` 17 | . 18 | ├── CHANGELOG.md 19 | ├── LICENSE 20 | ├── README.md 21 | ├── doc 22 | │ └── intro.md 23 | ├── project.clj 24 | ├── resources 25 | ├── src 26 | │ └── http_simples 27 | │ └── core.clj 28 | └── test 29 | └── http_simples 30 | └── core_test.clj 31 | ``` 32 | 33 | Temos o diretório `test` como um local especial para testes específicos de sua aplicação, `src` para conter todo o código fonte, além de um espaço exclusivo para documentações no caminho `doc`! 34 | 35 | Alguns outros pontos como um `README.md`, `LICENSE` (licenciamento de seu projeto) e `CHANGELOG.md` (um formato de *logs* para modificações em versões de seu projeto) também são adicionados. 36 | 37 | ## Adicionando dependência 38 | 39 | Para modificar as definições de seu projeto e neste caso adicionar a dependência do [http-kit](https://github.com/http-kit/http-kit) (um kit para facilmente criarmos um servidor http) precisamos abrir o `project.clj`, na qual sua estrutura será algo como o exemplo abaixo: 40 | 41 | ```clojure 42 | (defproject http-simples "0.1.0-SNAPSHOT" 43 | :description "FIXME: write description" 44 | :url "http://example.com/FIXME" 45 | :license {:name "EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0" 46 | :url "https://www.eclipse.org/legal/epl-2.0/"} 47 | :dependencies [[org.clojure/clojure "1.11.1"]] 48 | :main ^:skip-aot http-simples.core 49 | :target-path "target/%s" 50 | :profiles {:uberjar {:aot :all 51 | :jvm-opts ["-Dclojure.compiler.direct-linking=true"]}}) 52 | ``` 53 | 54 | Para adicionar nossa dependência vamos modificar o trecho com `:dependencies`, assim: 55 | 56 | ```clojure 57 | ;; ... 58 | :dependencies [[org.clojure/clojure "1.11.1"] 59 | [http-kit "2.7.0"]] 60 | ;; ... 61 | ``` 62 | > Estaremos utilizando nessse caso a versão `2.7.0`! 63 | 64 | Pronto! Seu projeto já está com as dependências definidas! Para instalar todas as dependências basta executar: 65 | 66 | ```sh 67 | $ lein deps 68 | ``` 69 | 70 | Maravilha! 71 | 72 | ## Definindo o servidor 73 | 74 | Bem, chegou a hora de definirmos nosso servidor web! Para isso, abra o arquivo `src/http-simples/core.clj`. Nele vamos primeiramente *importar* o `http-kit`, por isso, vamos modificar o namespace: 75 | 76 | ```clojure 77 | (ns http-simples.core 78 | (:require [org.httpkit.server :refer [run-server]])) 79 | ``` 80 | > Esse seria o formato das primeiras duas linhas do projeto! 81 | 82 | Agora vamos criar uma função chamada `app` responsável por realizar o redirecionamento de rotas e definição de retornos para cada uma: 83 | 84 | ```clojure 85 | (defn app [req] 86 | {:status 200 87 | :headers {"Content-Type" "text/html"} 88 | :body (str "Salve He4rt Developers <3")}) 89 | ``` 90 | 91 | Neste caso não importa qual foi o tipo de requisição recebida, não estamos tratando isso! Vamos apenas preparar nosso servidor para receber requisições do tipo GET (por padrão) em nossa raiz do servidor (famosa rota `/`)! No corpo da página deixei uma mensagem, mas, você pode customizar como quiser! Ah, vale ressaltar que é possível modificar também o `"Content-Type"` de acordo com sua necessidade. 92 | 93 | Vamos inicializar o servidor em nossa função `main` (famosa função principal) utilizando o `run-server` do `http-kit`, utilizando a função `app` para tratamento de conteúdos acessados! 94 | 95 | ```clojure 96 | (defn -main [& args] 97 | (run-server app {:port 3000}) 98 | (println "Server inicializado na porta 3000")) 99 | ``` 100 | 101 | Incrível! Nosso servidor está pronto! 102 | 103 | ## Executando 104 | 105 | Para executar nosso servidor, por favor, volte para a raiz do projeto e execute o seguinte comando: 106 | 107 | ```sh 108 | $ lein run 109 | ``` 110 | 111 | E você verá a mensagem que o servidor foi inicializado! Para testar basta abrir seu navegador e acessar `localhost:3000`! 112 | 113 | --- 114 | 115 | Viu como é elegante criar um servidor HTTP com Clojure? Incrível não é mesmo? Vamos para a finalização por agora! 116 | 117 |118 | Próximo -> Finalização 119 |
120 | 121 |122 | Voltar para o menu principal 123 |
124 | -------------------------------------------------------------------------------- /content/repeticao/README.md: -------------------------------------------------------------------------------- 1 | # Estruturas de Repetição 2 | 3 | Estruturas de repetição são aquelas utilizada para *se repetir algo em uma quantidade N de vezes*, sendo útil em diversos aspectos. 4 | 5 | Este tópico tem como objetivo apresentar as principais estruturas de repetição para trabalhar com Clojure, por isso, bora se aventurar! 6 | 7 | --- 8 | 9 | Vamos começar pelo grandioso `for`? 10 | 11 |12 | Próximo -> For 13 |
14 | 15 |16 | Voltar para o menu principal 17 |
18 | -------------------------------------------------------------------------------- /content/repeticao/doseq.md: -------------------------------------------------------------------------------- 1 | # Doseq 2 | 3 | Ok, provavelmente este será o tópico mais curto! O `doseq` é simplesmente um `for` que não retorna nada! 4 | 5 | Para entender melhor veja o exemplo abaixo: 6 | 7 | ```clojure 8 | (def numeros [0 1 2 3 4 5 6 7 8 9]) 9 | 10 | (doseq [i numeros] 11 | (println i)) 12 | 13 | ;; Resultado: 14 | ;; 1 15 | ;; 2 16 | ;; 3 17 | ;; 4 18 | ;; 5 19 | ;; nil 20 | ``` 21 | > O último retorno (neste caso `nil`) é o valor retornado pelo `doseq`! 22 | 23 | Sua utilização é útil quando não precisamos de um retorno em formato de lista ou algo similar como quando utilizamos o `for`! 24 | 25 | --- 26 | 27 | Como eu falei: o `doseq` é bem simples não é mesmo? Bora conhecer nossa última estrutura de repetição, o famoso `loop`? 28 | 29 |30 | Próximo -> Loop 31 |
32 | 33 |34 | Voltar para o menu principal 35 |
36 | -------------------------------------------------------------------------------- /content/repeticao/for.md: -------------------------------------------------------------------------------- 1 | # For 2 | 3 | Amado por muitos, odiado por alguns, o `for` é um laço de repetição clássico, conhecido na maioria das linguagens de programação por ter um formato um tanto quanto interessante, sendo utilizado muitas das vezes com uma estrutura similar ao que temos abaixo: 4 | 5 | ```javascript 6 | for (inicializa; até que; passo){ 7 | // Faça algo 8 | } 9 | ``` 10 | > A estrutura de um `for` varia de acordo com a linguagem de programação obviamente, mas, sempre é interessante ter essa noção de que seu formato não implica necessariamente em sua funcionalidade! 11 | 12 | Bem, o `for` em Clojure possui um formato um pouco diferente, por isso, vamos dar uma olhada no exemplo abaixo: 13 | 14 | ```clojure 15 | (for [i (range 10)] 16 | (println i)) 17 | ``` 18 | 19 | O exemplo acima basicamente vai imprimir os valores de `0` até `9` (dentro do `range` especificado) em uma lista. O `for` em Clojure possui um funcionamento semelhante quando comparado com linguagens de programação que aceitam vetores para tratamento de laços de repetição, por isso, para entender melhor veja mais um exemplo, porém, utilizando um vetor por base: 20 | 21 | ```clojure 22 | (def numeros [0 1 2 3 4 5 6 7 8 9]) 23 | 24 | (for [i numeros] 25 | (println i)) 26 | ``` 27 | 28 | No exemplo acima o resultado será igual ao apresentado anteriormente com a função `range`, porém, neste caso foi percorrido todo o vetor existente para atribuir seus determinados valores no laço. Poderíamos utilizar `strings` e ao invés de utilizar o `println` para imprimir uma mensagem, utilizar o `str` para concatenar as strings em uma resposta única, deixando sem aquele retorno ao final. Veja o exemplo abaixo: 29 | 30 | ```clojure 31 | (def letras ["a" "b" "c" "d" "e"]) 32 | 33 | (for [l letras] 34 | (str l)) 35 | 36 | ;; Resultado: 37 | ;; ("a" "b" "c" "d" "e") 38 | ``` 39 | 40 | Uma lista com as determinadas letras é retornada, sendo útil para momentos em que desejamos formar uma nova lista a partir de algum vetor ou algo do tipo... Interessante não é mesmo? 41 | 42 | Ainda podemos fazer muito mais com o `for`, por isso, caso tenha interesse recomendo dar uma olhada na documentação do [ClojureDocs](https://clojuredocs.org/clojure.core/for)! 43 | 44 | --- 45 | 46 | Maravilha! Gostou de aprender um pouco mais sobre o funcionamento do `for`? O que acha de conhecermos o `doseq`? 47 | 48 |49 | Próximo -> Doseq 50 |
51 | 52 |53 | Voltar para o menu principal 54 |
55 | -------------------------------------------------------------------------------- /content/repeticao/loop.md: -------------------------------------------------------------------------------- 1 | # Loop 2 | 3 | Podemos comparar o `loop` como algo parecido quando falamos de `while`, na qual enquanto algo é verdade as instruções continuam sendo executadas! 4 | 5 | Veja o exemplo abaixo para observamos melhor: 6 | 7 | ```clojure 8 | (loop [i 1] 9 | (when (<= i 10) 10 | (println i) 11 | (recur (inc i)))) 12 | ``` 13 | 14 | O exemplo acima vai imprimir uma contagem de `1` até `10`, retornando `nil` ao final! A função `inc` é utilizada para incrementar `1` valor em `i`, sendo uma espécie de contador (similar ao que temos como `i += 1` em outras linguagens de programação). 15 | 16 | Ao final é necessário utilizar a função `inc`, com finalidade de executar uma expressão em ordem, em formato recursivo, para que assim seja enviado o valor atualizado da *variável* `i`. 17 | 18 | Podemos dizer e afirmar que esta é a estrutura básica da estrutura de repetição `loop`! 19 | 20 | --- 21 | 22 | O que achou de conhecer as estruturas de repetição? Qual sua favorita? Vamos estudar um pouco melhor sobre os conceitos por trás de funções em Clojure? 23 | 24 |25 | Próximo -> Funções 26 |
27 | 28 |29 | Voltar para o menu principal 30 |
31 | --------------------------------------------------------------------------------