DEV Community: Guilherme Rodrigues de Melo

Clojure na Web com Ring

Guilherme Rodrigues de Melo — Fri, 08 Jan 2021 18:48:45 +0000

Ring é uma biblioteca baseada no WSGI do Python e no Rack do Ruby que nos ajuda na criação de aplicações web em Clojure, abstraindo os detalhes do HTTP. Ring é a base para muitas aplicações e bibliotecas do mundo web em Clojure, pois ele trabalha com o baixo nível das requisições HTTP. Ring possui três conceitos principais: Handler, Adapter e Middleware.

Handler

Para trabalhar com as requisições, precisamos criar handlers, que nada mais são do que funções que recebem uma requisição e devolvem uma resposta. As requisições e as repostas são mapas que contém informações como chaves baseadas na API de Servlet.

Requisição

Uma requisição contém informações que são acessadas através das chaves, onde as principais são:

:server-port: Porta do servidor que está recebendo a requisição
:server-name: Nome ou IP do servidor que está recebendo a requisição
:query-string: Query string da requisição (?q=name)
:request-method: Método HTTP utilizado na requisição (:post, :get, etc)
:body: Corpo da requisição
:headers: Headers da requisição

Resposta

Uma resposta contém apenas três informações que são:

:body: Corpo da resposta
:headers: Header da resposta contendo um mapa com chave/valor
:status: Status da resposta (200, 404, 500, etc)

Adapter

Um adapter é uma ponte entre a aplicação Ring e os detalhes de implementação do protocolo HTTP. O adapter recebe uma requisição, transforma a requisição em um mapa e passa esse mapa para a aplicação Ring realizar o processamento. Após processar o mapa recebido, a aplicação Ring retorna um mapa de resposta que é usado pelo adapter para retornar a resposta HTTP.

Alguns exemplos de adapter:

Middleware

Um middleware permite que alteremos a forma como a requisição é processada. Middlewares são utilizados para ampliar a funcionalidade dos handlers. Um middleware é uma função que recebe um handler e outros parâmetros opcionais, processa-os e retornando um novo handler com novos comportamentos. No exemplo a seguir veremos como criar e utilizar middlewares existentes.

Criando um projeto com Ring

Para criar um servidor com o Ring, precisamos primeiramente criar um projeto. No nosso caso, utilizaremos o Leiningen para a criação do projeto. Para instalar e configurar o Leiningen, acesse o site e siga as instruções. Após instalar o Leiningen, execute o seguinte comando no seu terminal:

*lein new hello-ring

Será gerado um projeto com a seguinte estrutura:

Diretórios mais importantes para nós nesse momento:

doc: Diretório onde é colocada a documentação do projeto
src: Diretório onde fica o código fonte do projeto
test: Diretório onde ficam os testes
project.clj: Arquivo responsável por toda configuração do projeto (semelhante ao pom.xml de projetos Java com Maven)

Abra o arquivo project.clj. Começaremos adicionando novas dependências para o projeto. No vetor :dependencies, adicione duas dependências do Ring:

:dependencies [[org.clojure/clojure "1.10.0"]
               ; principais funções do Ring
               [ring/ring-core "1.8.1"]
               ; adapter Jetty para Ring
               [ring/ring-jety-adapter "1.8.1"]]

Após adicionar as duas dependências, execute o comando para baixa-las no seu reposítorio local do Leiningen.

*lein deps

Agora, abra o arquivo core.clj que está dentro do diretório src/hello_ring. Nesse arquivo temos a declaração do namespace hello-ring.core e a importação do adapter do servidor Jetty.

(ns hello-ring.core
  (:require [ring.adapter.jetty :as jetty]))

Vamos adicionar nosso primeiro handler que retornará um mapa como resposta contendo o status, o corpo da requisição e um header de Content-Type.

(defn ola-web [request]
  {:status 200
   :body "Olá web"
   :headers {"Content-Type" "text/plain; charset=utf-8"}})

Por fim, criamos uma função chamada -main que será chamada pelo Leiningen. Dentro da função main, iniciamos o servidor Jetty associando a ele o handler (ola-web) e um mapa com a configuração da porta (3000).

(ns hello-ring.core
  (:require [ring.adapter.jetty :as jetty]))

(defn ola-web [request]
  {:status 200
   :body "Olá web"
   :headers {"Content-Type" "text/plain; charset=utf-8"}})

(defn -main [& args]
  (jetty/run-jetty ola-web {:port 3000}))

Para inicializar o servidor pelo terminal, precisamos fazer uma configuração a mais. Abra o arquivo project.clj e adicione uma linha (:main hello-ring.core) para dizer ao Leiningen que o projeto inicializará pelo namespace hello-ring.core através da função -main:

(defproject hello-ring "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0"
            :url "https://www.eclipse.org/legal/epl-2.0/"}
  :dependencies [[org.clojure/clojure "1.10.0"]
                 [ring/ring-core "1.8.1"]
                 [ring/ring-jetty-adapter "1.8.1"]]
  :main hello-ring.core
  :repl-options {:init-ns hello-ring.core})

Agora, abra novamente o terminal e execute o comando para incializar o projeto.

*lein run

O servidor será inicializado. Abra o navegador e digite localhost:3000. Deve ser mostrada a mensagem "Olá web".

Criando um middleware

Criaremos um middleware que adicionará a chave :query-params ao header da requisição com os dados da query-string.

(defn parse-query
  "Transforma a query-string em um mapa de parâmetros"
  [query-string]
  (if (> (count query-string) 0)
    (apply hash-map (str/split query-string #"[&=]"))))

(defn wrap-query-param
  "Adiciona a chave :query-param ao header da requisição"
  [handler]
  (fn [request]
    (let [query-param (parse-query (:query-string request))
          nova-req (assoc request :query-params query-param)]
      (handler nova-req))))

No código acima, criamos a função parse-query responsável por quebrar os parâmetros da requisição e criar um mapa de chave/valor. Nosso middleware (wrap-query-param) captura os parâmetros, recebe o mapa criado pela função anterior e associa esse mapa a requisição atual, criando uma nova requisição e passando-a para o handler recebido como parâmetro do middleware.

Para utilizar nosso middleware, passamos nosso handler como parâmetro para ele, que por sua vez, é passado como parâmetro para a função que cria o servidor.

(defn -main [& args]
  (jetty/run-jetty (wrap-query-param ola-web) {:port 3000}))

Alteramos o código da função ola-web para pegar o parâmetro e retornar a mensagem. Abaixo o código completo:

(ns hello-ring.core
  (:require [ring.adapter.jetty :as jetty]
            [clojure.string :as str]))

(defn ola-web [request]
  (let [nome (get (:query-params request) "nome")]
    {:status 200
     :body (str "Olá " nome)
     :headers {"Content-Type" "text/plain; charset=utf-8"}}))

(defn parse-query
  "Transforma a query-string em um mapa de parâmetros"
  [query-string]
  (if (> (count query-string) 0)
    (apply hash-map (str/split query-string #"[&=]"))))

(defn wrap-query-param
  "Adiciona a chave :query-param ao header da requisição"
  [handler]
  (fn [request]
    (let [query-param (parse-query (:query-string request))
          nova-req (assoc request :query-params query-param)]
      (handler nova-req))))

(defn -main [& args]
  (jetty/run-jetty (wrap-query-param ola-web) {:port 3000}))

Execute novamente o comando para subir o servidor:

*lein run

No navegador, digite localhost:3000/?nome=Guilherme e veja o resultado.

Utilizando um middleware pronto para retornar JSON

Agora utilizaremos dois middlewares existentes. Um vai capturar os dados da query-string como fizemos no nosso middleware e o outro retornará os dados da requisição como JSON. Abra o arquivo project.clj e adicione a seguinte dependência responsável pelo middleware de JSON:

*[ring/ring-json "0.5.0"]

No nosso namespace hello-ring.core, vamos adicionar as dependências dos dois middlewares, sendo o wrap-params pertencente à biblioteca ring-core e o wrap-json-response à biblioteca ring-json.

(ns hello-ring.core
  (:require [ring.adapter.jetty :as jetty]
            [ring.middleware.params :refer [wrap-params]]
            [ring.middleware.json :refer [wrap-json-response]]))

(defn ola-web [request]
  (let [nome (get (:query-params request) "nome")]
    {:status 200
     :body {:nome nome}
     :headers {}}))

(defn -main [& args]
  (jetty/run-jetty
    (-> ola-web
        wrap-params
        wrap-json-response)
    {:port 3000}))

No nosso código acima temos algo um pouco diferente na inicialização do servidor. Utilizamos uma thread-fist para processar nosso handler utilizando os dois middlewares. Thread-first é uma forma que temos em Clojure de processar informações de forma clara e encadeada, pois o resultado da primeira linha é passado como parâmetro para a função da linha de baixo. Nesse caso, passamos nosso handler como parâmetro para o middleware wrap-params e o resultado do retorno desse middleware é passado como parâmetro para o middleware de baixo (wrap-json-response).

Execute novamente o comando para subir o servidor:

*lein run

No navegador, digite localhost:3000/?nome=Guilherme. O resultado é mostrado no formato JSON.

Podemos melhorar o retorno do nosso handler adicionando uma biblioteca para utilizar os métodos HTTP. No arquivo project.clj, adicione a dependência abaixo:

*[metosin/ring-http-response "0.9.1"]

No namespace hello-ring.core, adicione a dependência do http-response para a utilização da função ok. Passamos o mesmo mapa para a função ok, que retornará o status 200 juntamente com o corpo da resposta.

(ns hello-ring.core
  (:require [ring.adapter.jetty :as jetty]
            [ring.middleware.params :refer [wrap-params]]
            [ring.middleware.json :refer [wrap-json-response]]
            [ring.util.http-response :refer [ok]]))

(defn ola-web [request]
  (let [nome (get (:query-params request) "nome")]
    (ok {:nome nome})))

(defn -main [& args]
  (jetty/run-jetty
    (-> ola-web
        wrap-params
        wrap-json-response)
    {:port 3000}))

Ring é uma biblioteca potente e básica para inicializar o desenvolvimento web em Clojure, porém é a base para outras bibliotecas que veremos mais pra frente, como Compojure, Reitit e Pedestal. Nos vemos num próximo post. :)

Programação Funcional em Clojure

Guilherme Rodrigues de Melo — Fri, 08 Jan 2021 18:24:08 +0000

Olá! Nesse post falaremos um pouco sobre programação funcional em Clojure. Bora? :)

Imutabilidade

Imutabilidade é útil quando desejamos evitar a mudança de estado em nosso sistema, principalmente quando temos que trabalhar com concorrência, pois caso haja alguma falha, torna-se difícil de debugar o mesmo para encontrar a verdadeira causa. Em Clojure, toda vez que manipulamos uma estrutura de dados, retornamos não a estrutura manipulada, mas sim uma nova versão da estrutura com as mudanças realizadas. Clojure utiliza de certas estruturas de dados internamente para que essa copia não tenha uma performance ruim.

Transparência Referencial

Transparência Referencial é quando podemos substituir uma expressão pelo seu valor sem mudar o comportamento do programa, ou seja, é quando definimos uma função que recebe um argumento e sempre retorna o mesmo resultado quando dado o mesmo argumento.

Exemplo de uma função referencialmente transparente:

(defn multiplicacao [x y]
    (* x y))

(multiplicacao 10 5)
; => 50

No exemplo acima, sempre que passarmos os mesmos argumentos, o resultado será o mesmo.

Funções Puras

Funções puras são aqueles que atendem a dois requisitos. O primeiro deles é que a função deve retornar sempre o mesmo resultado dado os mesmos argumentos. O segundo requisito é que a função não deve causar nenhum efeito colateral, ou seja, ela não deve fazer nenhuma mudança fora da função em si, como por exemplo, mudando o valor de uma variável externa. Se a função alterar algum valor dentro dela ou algo afetar o resultado da função, então essa função não é pura. Exemplo:

(def numeros '(1 2 3 4 5))

(defn incrementa-numeros []
    (map inc numeros))

(incrementa-numeros)
; => (2 3 4 5 6)

No exemplo acima, a função incrementa-numeros não recebe parâmetros, porém ela utiliza uma variável externa que poderia ser modificada antes dela ser invocada, podendo não retornar os mesmos valores dados os mesmos argumentos. No exemplo abaixo podemos ver uma versão pura da função anterior, onde a função recebe a sequência como parâmetro.

(def numeros '(1 2 3 4 5))

(defn incrementa-numeros [sequencia]
   (map inc sequencia))

(incrementa-numeros numeros)
; => 2 3 4 5 6

Se uma função lê um arquivo, ela não é referencialmente transparente porque o conteúdo do arquivo pode se modificar. Nos exemplos abaixo existem as funções conta-caracteres e analisa-arquivo, sendo respectivamente, uma pura e outra não.

(defn conta-caracteres [texto]
    (str "Quantidade de caracteres:" (count texto)))

(defn analisa-arquivo [arquivo]
    (conta-caracteres (slurp arquivo)))

Funções puras tornam a manutenção e a leitura do sistema mais clara, pois as funções ficam isoladas, sem impactar as demais funções e valores do sistema. Além de serem consistentes, pois utilizam do conceito de transparência referencial.

Trabalhando com Estrutura de Dados imutáveis

Todo programa deve ter funções impuras, porém essas funções devem ser em menor quantidade e bem isoladas. Clojure nos ajuda provendo estruturas de dados imutáveis em seu core que veremos a seguir.

Recursão em vez de for/while

Diferente de outras linguagens que utilizam de efeitos colaterais em loops como for e while, Clojure nos proporciona a alterativa para a mutação através da recursão. O exemplo abaixo demonstra a soma dos valores de um vetor através de recursão:

(defn soma 
    ([numeros] (soma numeros 0))
    ([numeros total]
        (if (empty? numeros)
            total
            (soma (rest numeros) (+ (first numeros) total)))))

No exemplo acima é verificado se o vetor passado como parâmetro é vazio. Caso seja vazio o total da soma é retornado. No entanto, se o vetor ainda não é vazio, chama-se a função novamente passando como parâmetros o restante dos valores do vetor e a soma do primeiro item do vetor com o total acumulado até o momento. A função rest sempre devolve todos os itens do vetor, exceto o primeiro. Abaixo podemos ver como ocorrem as chamadas recursivas:

(soma [1 2 3 4 5])
(soma [1 2 3 4 5] 0)
(soma [2 3 4 5] 1)
(soma [3 4 5] 3)
(soma [4 5] 6)
(soma [5] 10)
(soma [] 15)
; => 15

A cada chamada recursiva, um novo escopo é criado onde numeros e total são associados a diferentes valores, sem a necessidade de alterar os valores originais. Se executamos essa função para somar apenas do 0 até o 1000, tudo funciona corretamente.

(soma (range 1000))
; => 499500

Porém, se executamos a soma do 0 até 100 mil, temos um StackOverflow.

(soma (range 100000))
; Execution error (StackOverflowError)

Por razões de performance e para evitar problemas desse tipo, Clojure recomenda a utilização da função recur se você estiver processando recursivamente uma coleção com milhares ou milhões de valores. Exemplo da função anterior utilizando recur.

(defn soma 
 ([numeros] (soma numeros 0))
 ([numeros total]
     (if (empty? numeros)
         total
         (recur (rest numeros) (+ (first numeros) total)))))

(soma (range 100000))
; => 4999950000

Composição de função

Composição de função é o ato de combinar funções passando valores de uma função para outra. Ao utilizar composição de funções, passamos a ter um código mais reutilizável. Clojure oferece algumas funções que ajudam o desenvolvedor como a função comp.

Comp

A função comp tem o objetivo de criar uma nova função através de outras funções. Abaixo um exemplo simples de utilização:

((comp clojure.string/capitalize clojure.string/lower-case clojure.string/reverse) "GUILHERME")
; => "Emrehliug"

As funções passadas como parâmetro para comp são executadas da direita para a esquerda, ou seja, sendo a ordem de execução: reverse, lower-case e capitalize. O código anterior é uma versão mais concisa do código abaixo:

(clojure.string/capitalize 
    (clojure.string/lower-case 
        (clojure.string/reverse "GUILHERME")))
; => "Emrehliug"

Devemos usar comp para deixar nosso código mais fácil de entender e mais reutilizável. No exemplo a seguir vemos como a utilização de comp deixa tudo mais claro.

Utilizando comp:

(map (comp keyword str) ["Brasil" "França"])
; => (:Brasil :França)
Sem utilizar comp:

(map #(keyword (str %)) ["Brasil" "França"])
; => (:Brasil :França)

Nos dois casos o resultado é o mesmo, porém no primeiro exemplo fica mais claro como as coisas acontecem.

Aplicação parcial com partial

A função partial recebe uma função e vários argumentos. Com isso, partial retorna uma nova função que, ao ser invocada, retorna a função original passada como parâmetro utilizando os parâmetros originais. Exemplo:

(def adiciona-cem (partial + 100))

(adiciona-cem 200)
; => 300

No exemplo, quando chamamos adiciona-cem, ela chama a função + passando o valores 100 e 200 como parâmetro.

A função partial é útil quando desejamos reutilizar uma determinada combinação de funções e argumentos. No exemplo abaixo utilizamos partial para reaproveitar a geração do log:

(defn log 
    [nivel mensagem]
    (condp = nivel
        :erro (clojure.string/upper-case mensagem)
        :sucesso (clojure.string/lower-case mensagem)))

(def mensagem-erro (partial log :erro))

(def mensagem-sucesso (partial log :sucesso))

(mensagem-erro "Erro ao tentar acessar recurso")

(mensagem-sucesso "Recurso salvo")

Memoize

Memoization nos da a vantagem da transparência referencial que citei no início do post, pois memoize guarda os parâmetros e o retorno da função. Dessa forma, quando houver várias chamadas para a mesma função com os mesmos argumentos, o resultado é retornado imediatamente. Em casos de funções que levam muito tempo para serem executadas, a função memoize é muito útil.

No exemplo abaixo temos uma primeira versão da função exibe que exibe a mensagem após 1 segundo. Na segunda versão da função utilizamos memoize para retornar o valor imediatamente após a primeira chamada.

(defn exibe [mensagem]
    (Thread/sleep 1000)
    mensagem)

(def exibe-com-memoize (memoize (defn exibe [mensagem]
    (Thread/sleep 1000)
    mensagem)))

Espero que esse post tenha te ajudado a entender um pouco mais sobre Clojure e como usamos programação funcional nessa linguagem. Nos vemos num post futuro. :)

Sequências e a importância das funções em Clojure

Guilherme Rodrigues de Melo — Fri, 08 Jan 2021 18:16:33 +0000

Olá! Nesse post veremos sobre sequências e a importância das funções para as sequências e para Clojure.

O que são sequências?

Sequências são tipos de dados que abstraem os tipos de dados concretos que armazenam múltiplos valores. Ou seja, listas, mapas, sets e vetores são sequências que podem fazer uso de diversas funções da biblioteca de sequências do Clojure, pois podemos chamar funções iguais para diferentes tipos concretos de sequências. Veremos a seguir exemplos de funções que utilizam desse conceito.

Antes de mostrar os exemplos, devemos entender um outro conceito que já foi implementado no post anterior e que tem o objetivo de deixar o post um pouco mais claro.

Funções de primeira classe e de grandeza superior

Funções são de extrema importância para linguagens que utilizam o paradigma de programação funcional (não me diga, hehe). Mas por que elas são tão importantes? Funções são cidadãs de primeira classe em Clojure, pois são tratadas como valores. Ou seja, podemos passa-las como parâmetro para outras funções, como fazemos com textos e números, por exemplo.

Com a possibilidade de passar funções como parâmetro de outras funções, temos ainda um novo recurso da linguagem que são as funções de grandeza superior. Funções de grandeza superior são funções que recebem outras funções como parâmetro ou que retornam uma função como resultado.

A seguir serão apresentadas funções para manipulação de dados que utilizam os conceitos explicados acima.

Map

A função map nos ajuda a mapear sequências para novos valores. Map recebe como parâmetros uma função e uma sequência. Será aplicada a função para cada item da sequência. Exemplo:

(map inc [1 2 3 4 5])
; (2 3 4 5 6)

No exemplo acima a função inc incrementa um em cada item da sequência (nesse caso send um vetor).

É muito comum precisarmos recuperar apenas um valor de um mapa. No exemplo a seguir utilizamos a keyword :nome como uma função para criar uma nova sequência através do mapa.

; define vetor de mapas de jogadores
(def jogadores 
    [{:nome "Ronaldo"    :idade 43},
     {:nome "Rivaldo"    :idade 47},
     {:nome "Ronaldinho" :idade 40},
     {:nome "Kaká"          :idade 37}])

; Mapeando apenas os nomes dos jogadores 
(map :nome jogadores)  
; ("Ronaldo" "Rivaldo" "Ronaldinho" "Kaká")

Podemos utilizar também a função map para criar novos mapas utilizando mais de uma sequência.

(def jogadores ["Ronaldo" "Rivaldo" "Ronaldinho" "Kaká"])

(def idades [43 47 40 37])

(defn define-jogadores [jogador idade]
    {:nome jogador
     :idade idade})

(map define-jogadores jogadores idades)
; ({:nome "Ronaldo", :idade 43} {:nome "Rivaldo", :idade 47} {:nome "Ronaldinho", :idade 40} {:nome "Kaká", :idade 37})

Reduce

Reduce é uma função que combina todos os itens de uma coleção em um só valor. Reduce, assim como as outras funções, também aplica uma função para cada item da coleção, porém para cada aplicação da função o resultado é acumulado. Exemplo:

(reduce + [1 2 3 4 5])
; 15

No exemplo acima, a cada item que foi somado, o valor somado foi salvo em uma variável interna que é o acumulador. Quando não houver mais itens na coleção o valor acumulado é retornado. É como se estivessemos fazendo assim:

(+ (+ (+ (+ 1 2) 3) 4) 5)
; 15

Reduce aceita também um valor inicial:

(reduce + 10 [1 2 3 4 5])
; 25

Podemos unificar uma sequência de sequências utilizando reduce:

(reduce concat [] [[1 2 3 4 5] [6 7 8 9 10]])
; (1 2 3 4 5 6 7 8 9 10)

Filter

A função filter é utilizada para filtrar valores de uma sequência de acordo com a regra definida pela função passada como parâmetro juntamente com a sequência. Exemplo:

(def pacientes-hospital [{:mes 1 :pacientes-atendidos 150}
    {:mes 2 :pacientes-atendidos 233}
    {:mes 3 :pacientes-atendidos 298}
    {:mes 4 :pacientes-atendidos 144}
    {:mes 5 :pacientes-atendidos 128}])


(filter #(< (:mes %) 3) pacientes-hospital)
; ({:mes 1, :pacientes-atendidos 150} {:mes 2, :pacientes-atendidos 233})

Take-while

A função take-while recebe uma função e uma sequência como parâmetro. A função passada para take-while deve retornar true ou false de acordo com algum critério. Exemplo:

(take-while #(< (:mes %) 3) pacientes-hospital)
;({:mes 1, :pacientes-atendidos 150} {:mes 2, :pacientes-atendidos 233})

No exemplo acima, só serão retornados os registros em que o mês é menor que 3, pois quando a função anônima retorna false, são retornados todos os valores testados até aquele ponto.

A diferença entre o filter e o take-while é que o filter processa toda a sequência enquanto o take-while processa a sequência até uma determinada parte de acordo com regra implementada pela função passada como parâmetro.

Drop-while

A função drop-while segue um raciocínio parecido com a take-while, sendo a única diferença que os registros da sequência serão excluidos até que a função passada como parâmetro retorne false.

(drop-while #(< (:mes %) 3) pacientes-hospital)
; ({:mes 3, :pacientes-atendidos 298} {:mes 4, :pacientes-atendidos 144} {:mes 5, :pacientes-atendidos 128})

Some

A função some também recebe uma função e uma sequência como parâmetro e retorna true quando encontra um elemento que segue a regra da função ou false quando não encontra. Exemplo:

(some #(> (:pacientes-atendidos %) 250) pacientes-hospital)
; true

Sort-By

A função sort-by também recebe uma função e uma sequência como parâmetros. A função sort-by ordena a sequência de acordo com a regra implementada pela função passada como parâmetro. No exemplo abaixo, a sequência é ordenada pelo tamanho do nome:

(sort-by count ["Ronaldo" "Rivaldo" "Ronaldinho" "Kaká"])
; ("Kaká" "Ronaldo" "Rivaldo" "Ronaldinho")

Bem, por enquanto é isso. Espero que tenha aproveitado o conteúdo e nos vemos num post futuro. Até lá! :)

Funções em Clojure

Guilherme Rodrigues de Melo — Fri, 08 Jan 2021 18:04:47 +0000

Vimos no post anterior como são as estruturas básicas de dados em Clojure. Nesse post, veremos como declarar e trabalhar com funções na linguagem Clojure.

Definindo funções

A criação de uma função é dividida em cinco partes, sendo elas:

defn
Nome da função
A documentação da função, sendo opcional
Parâmetros que são passados entre colchetes
Corpo da função

Criando nossa primeira função em Clojure:

(defn ola
"Função que retorna um texto de boas vindas!"
[nome]
(println "Olá, " nome))

Acima definimos o nome da nossa função como "ola", escrevemos uma documentação simples, passamos "nome" como parâmetro e criamos um corpo da função que imprime a frase retornada.

Invocando a função:

(ola "Guilherme")
; Olá Guilherme

Parâmetros e Aridade

Em linguagens orientadas a objetos podemos ter métodos com o mesmo nome, porém com quantidade de parâmetros diferentes na mesma classe. Em Clojure, temos algo parecido. Podemos definir que uma função pode ter diferentes formas de implementação com diferentes aridades (número de parâmetros passados para a função), o que chamamos de sobrecarga de aridade (arity overloading). Abaixo nossa função "ola" ganha novas aridades e para isso, devemos modificar um pouco a forma como escrevemos a função, envolvendo cada forma de implementar com parênteses.

(defn ola
"Função que retorna um texto de boas vindas!"
([nome]
(println "Olá," nome))

([nome sobrenome]
(println "Olá," nome sobrenome))

([nome sobrenome idade]
(println "Olá," nome sobrenome ". Idade:" idade "anos")))

Invocando a função utilizando as três formas:

(ola "Guilherme")
; Olá, Guilherme

(ola "Guilherme" "Rodrigues")
; Olá, Guilherme Rodrigues

(ola "Guilherme" "Rodrigues" 23)
; Olá, Guilherme Rodrigues . Idade: 23 anos

Clojure também nos permite definir uma função com aridade variável através do parâmetro rest (rest parameter). Para indicar que estamos utilizando rest parameter, devemos utilizar o simbolo & como no exemplo abaixo.

(defn imprime-nome [nome]
    (println "Olá" nome))

(defn ola [& nomes]
    (map imprime-nome nomes))

No exemplo acima definimos uma função chamada imprime-nome passando como parâmetro o nome. Utilizamos a função imprime-nome para mapear a lista de argumentos e imprimi-los. Invocando a função com os parâmetros:

(ola "Guilherme" "João" "José")

; Olá Guilherme
; Olá João
; Olá José

Para utilizar rest parameter juntamente com outro parâmetro, devemos passa-los como último parâmetro da função. Exemplo:

(defn mostra-time [time & nomes]
    (println "Os jogadores do" time "são: " 
        (clojure.string/join ", " nomes)))
Invocando a função:

(mostra-time "Real Madrid" "Benzema" "Casemiro" "Rodrigo")
; Os jogadores do Real Madrid são: Benzema, Casemiro, Rodrigo

Desestruturação

Clojure nos permite extrair valores dos parâmetros que são passados para a função utilizando um conceito chamado destructuring. No exemplo abaixo recuperamos apenas o primeiro elemento da coleção passada como parâmetro e retornamos o mesmo.

(defn primeiro-elemento [[primeiro-elemento]]
    primeiro-elemento)

(primeiro-elemento ["Carro" "Bicicleta" "Caminhão"])
; "Carro"

Clojure nos permite utilizar a desestruturação com rest parameters como no exemplo abaixo:

(defn dois-primeiros-elementos-e-resto [[primeiro segundo & resto]]
    (println "Primeiro:" primeiro)
    (println "Segundo:" segundo)
    (println "Outros:")
    (println (clojure.string/join ", " resto)))

(dois-primeiros-elementos-e-resto ["Carro" "Bicicleta" "Caminhão" "Metrô" "Ônibus"])

; Primeiro: Carro
; Segundo: Bicicleta
; Outros:
; Caminhão, Metrô, Ônibus

Também é possível utilizar desestruturação com mapas. No exemplo abaixo os valores das chaves :nome e :sobrenome informadas são passados para os parâmetros nome e sobrenome:

(defn ola [{nome :nome sobrenome :sobrenome}]
(println "Nome:" nome)
(println "Sobrenome:" sobrenome))

(ola {:nome "Guilherme" :sobrenome "Rodrigues"})

; Nome: Guilherme
; Sobrenome: Rodrigues

Corpo de função

O corpo da função pode conter inúmeras formas dentro dele. Porém, Clojure retorna apenas a última expressão avaliada pela função. No exemplo abaixo temos diversas formas, porém apenas a última é retornada:

(defn corpo-funcao []
    (+ 10 15)
    "Corpo da função"
    (* 100 12))

(corpo-funcao)
; 1200

Funções anônimas

Acima fizemos um exemplo utilizando a função map e passamos a função imprime-nome como parâmetro. Relembrando a função:

(defn imprime-nome [nome]
    (println "Olá" nome))

(defn ola [& nomes]
    (map imprime-nome nomes))

Porém, em Clojure não é necessário que todas as funções tenham nomes, pois a linguagem nos possibilita utilizar funções anônimas. Vejamos abaixo como podemos utilizar funções anônimas nesse caso:

(defn ola [& nomes]
    (map (fn [nome] 
           (println "Olá" nome)) nomes))

(ola "Guilherme" "João")         

; Olá Guilherme
; Olá João

Como visto, para definir uma função anônima, trocamos o defn por fn, retiramos o nome da função e passamos como parâmetro de outra função. Porém, podemos diminuir mais um pouco a definição da função anônima. Para isso, deixamos de utilizar o fn, não definimos o nome do parâmetro e substituimos o parâmetro apenas por %. Exemplo acima com função encurtada:

(defn ola [& nomes]
    (map #(println "Olá" %) nomes))

(ola "Guilherme" "João")    

; Olá Guilherme
; Olá João

Caso a função anônima receba mais de um parâmetro, é possível utiliza-los como no exemplo abaixo:

(#(+ %1 %2) 10 15)
;25

Espero que tenha gostado das funções em Clojure. Por enquanto é só e nos vemos em um futuro post. Abraços :)

Começando com Clojure

Guilherme Rodrigues de Melo — Fri, 08 Jan 2021 17:55:30 +0000

O que é Clojure?

Clojure é um dialeto de Lisp, que é uma linguagem de programação funcional. Clojure roda na JVM (Java Virtual Machine), possui uma sintaxe um tanto quanto peculiar e simples. Por poder ser executada na JVM, programas escritos em Clojure pode fazer uso de bibliotecas Java.

Mas o que é uma programação funcional?

Programação funcional é um paradigma de programação, ou seja, é uma forma de se programar. Este paradigma é baseado em um modelo computacional chamado Cálculo Lambda, criado por Alonzo Church em 1930. Em programação funcional tudo é função, ou seja, um código funcional é uma sequência de funções que resolvem um problema.

O início

Como dito anteriormente, Clojure possui uma sintaxe muito simples, porém que pode confundir muito (me confundiu muito) quem está começando no mundo de linguagens baseadas em Lisp. Abaixo como é escrito o código Clojure:

(operador operando1 operando2... operando)

Não entendeu? Então vamos ao exemplo. Suponhamos que você deseja realizar uma soma entre 5 números.

O que em Javascript poderíamos fazer assim:

let resultado = 3 + 7 + 8;

Em Clojure fazemos assim:

(+ 3 7 8)
=> 18

No código acima o operador "+" soma os parâmetros 3, 7 e 8.

Um outro exemplo utilizando o famoso Hello World, onde a string "Hello World" é passada como parâmetro para a função println:

(println "Hello World")
=> "Hello World"

Nomeando valores

Usa-se a instrução def para vincular o nome do símbolo a um valor. Exemplos:

(def texto "Iniciando com Clojure")
(def contas-pagas 100)
Imprimindo os valores definidos:

(println texto)
=> "Iniciando com Clojure"

(println "Quantidade de contas pagas:"  contas-pagas)
=> "Quantidade de contas pagas: 100"

Estruturas de dados

Em Clojure todas as estruturas de dados são imutáveis, ou seja, seus valores não podem ser alterados.

Números básicos

Em Clojure podemos definir três tipos básicos de números, sendo eles Integer, Float ou fracionados. Exemplo:

(def numero-inteiro 10)
(def numero-ponto-flutuante 3.5)
(def numero-fracionado 10/3)

Strings

Strings representam textos, assim como em outras linguagens de programação. Exemplo:

(def hobbit "Bilbo")

Mapas

Mapas, assim como em outras linguagens de programação, são estruturas que armazenam chaves e valores. Abaixo algus exemplos de mapas em Clojure:

(def usuario {:nome "Guilherme" :idade 30})

(def funcao {"funcao-soma" +})

Também é possível encadear mapas:

(def mapa {:nome "Guilherme" :endereco {:cidade "São Paulo" :rua "Rua Sete de Abril"}})

Outra forma de criar mapas é através da função hash-map:

(def usuario (hash-map :nome "Guilherme" :cidade "São Paulo"))

Para recuperar alguma informação do mapa, utilizamos a função get. Nela nós passamos o mapa e a keyword utilizada como chave para recuperar a informação desejada. Exemplo:

(get mapa :nome)
=> "Guilherme"

Keywors são geralmente utilizadas como chaves em mapas no Clojure. No exemplo anterior, :nome é uma keyword.

Vetores

Um vetor é como um array em linguagens mais comuns, onde o index começa no 0. Definindo um símbolo como vetor:

(def numeros [3 2 1])

Recuperando item do vetor de acordo com o índice:

(get numeros 2)
=> 1

Também é possível criar vetores utilizando a função vector

(def empresas (vector "Apple" "Microsoft" "Samsung"))

(get empresas 1)
=> "Microsoft"

Listas

Listas são parecidas com vetores em Clojure, porém com algumas diferenças. Por exemplo, para recuperar algum item de acordo com a posição da lista, usa-se a função nth e não a função get. Para declarar uma lista, basta definir os itens da lista entre parênteres e colocar um apóstrofo no início. Exemplo:

(def numeros '(1 2 3 4))
(def estados '("SP" "RJ" "RS" "PR"))

(nth estados 2)
=> "RS"

Levando em consideração a performance, a função get é mais rápida que a nth, pois a nth passa por todos os elementos da lista para encontrar o item buscado.

Também é possível criar listas utilizando a função list:

(def numeros (list 1 2 3 4))

Sets

Sets são coleções em que os itens são únicos, ou seja, não podem se repetir. Em Clojure temos duas formas de criar um Set:

Forma literal:

(def produtos #{"Refrigerante" "Carne" "Arroz"})

Utilizando a função hash-set:

(def produtos (hash-set "Refrigerante" "Carne" "Arroz"))

Podemos inclusive transformar um vetor em um set:

(set [2 2 5 6 5 1 1])
=> #{1 6 2 5}

Por enquanto é isso. Quem sabe nos vemos em um próximo post. :)