Criando variáveis e funções em Clojure

O básico para começar a desenvolver em uma linguagem (funcional) é aprender a criar variáveis para armazenar os dados e funções para poder trabalhar com esses dados.

Vamos ver na prática como trabalhar com variáveis e criar funções, para isso vamos usar o REPL. Se ainda não sabe o que é, conheça REPL - seu melhor amigo no mundo clojure

Criando variáveis

Clojure preza pela imutabilidade, então quando criamos uma variável estamos definindo um símbolo com um valor.

user=> (def foo 1) #'user/foo 

Nesse exemplo estamos definindo foo com o valor 1, o retorno é o nome completo do símbolo criado #'user/foo. Quando criamos, o Clojure cria na namespace atual, que no caso é user. Quando temos um arquivo, ele vai ter a própria namespace, e tudo criado lá dentro será pertencente aquela namespace.
Agora podemos acessar o valor direto ou usá-lo passando para uma função:

user=> foo 1 user=> (inc foo) 2 user=> foo 1 

Notamos nesse exemplo que o valor de foo não mudou após a execução de inc. Isso é evidência a característica de imutabilidade que comentamos, ou seja, o valor não é alterado e sim o novo valor é retornado.
Você pode estar pensando:

"podemos chamar o def novamente com o mesmo nome?"

Sim, isso iria "redefinir". Mas não é recomendado fazer isso, então nem pense nisso 😅

Criando funções

Da mesma maneira que usamos def para atribuir um valor simples, fazemos para criar uma função. Vamos criar uma função chamada ola que recebe um parâmetro nome e imprime Olá <<nome>>:

(def ola (fn [nome] (println (str "Olá " nome)))) 

Estamos atribuindo a ola uma função, que definimos usando fn. Usamos [] para declarar os parâmetros que recebemos, e depois o corpo da função.
Agora podemos executar a função igual as outras que já vimos:

user=> (ola "mundo") Olá mundo nil 

Retornando valores

No exemplo anterior, vimos que depois de imprimir a mensagem aparece nil, isso representa o retorno da nossa função. Em Clojure as funções retornam a última operação/valor.

user=> (defn soma2 [x] (+ x 2)) #'user/soma2 user=> (soma2 1) 3 

(def + fn)

Clojure criou uma maneira um pouco mais simplificada para a criação funções.
Ao invés de escrever def foo (fn []...) para atribuir uma função, podemos utilizar defn. O exemplo anterior ficaria assim:

(defn ola [nome] (println (str "Olá " nome))) 

Aridade

A aridade de uma função é a quantidade de parâmetros que ela recebe. Em Clojure podemos definir na mesma função múltiplas aridades, isso pode ser usado por exemplo para definir parâmetros opcionais ou valores default.
Vamos alterar a função ola para que quando for chamada sem nenhum parâmetro imprima "Ola mundão":

(defn ola ([] (ola "mundão")) ([nome] (println (str "Olá " nome)))) 

Cada aridade é declarada envolta em () e declaramos da menor aridade para a maior.
Vamos executar novamente a função, não passando parâmetro e passando:

user=> (ola) Olá mundão nil user=> (ola "mundo") Olá mundo nil user=> (ola "mundo" "grande") Execution error (ArityException) at user/eval2032 (REPL:1). Wrong number of args (2) passed to: user/ola 

Note que quando chamamos a função passando um número de argumentos que não existe, recebemos uma ArityException.

Funções: de primeira classe

Em Clojure as funções são armazenadas e tratadas como os outros valores, portanto podem ser passadas como argumentos para outras funções 🤯
Para exemplificar, vamos criar uma função que receba o nome da pessoa e a forma como queremos cumprimentar:

(defn cumprimentar [nome cumprimento] (cumprimento nome)) 

E podemos executá-la:

user=> (cumprimentar "Ariel" ola) Olá Ariel nil 

Veja que a função cumprimentar recebe o cumprimento e executa passando o nome, que também veio como parâmetro, para ela.

Docstring

Outra coisa importante é que quando declaramos uma função podemos criar junto uma documentação/descrição do que ela faz. Para isso basta passar antes dos parâmetros uma string com a descrição:

(defn ola "Recebe um nome e devolve Olá <<nome>>" [nome] (println (str "Olá " nome))) 

E agora, podemos usar a função doc que vimos no outro post passando a nossa função:

user=> (doc ola) ------------------------- user/ola ([nome]) Recebe um nome e devolve Olá <<nome>> 

Muito legal né? 🤩

Valores locais

Em Clojure podemos atribuir valores locais a nomes, dentro do escopo de funções, usando o let. Esses valores serão constantes, ou seja, não poderemos mais alterar ou redefinir.
Com o let você pode criar de uma vez 1 ou mais constantes, ele segue a seguinte estrutura:

(let [nome valor nome valor] ;;Podemos utilizar dentro do escopo do let ) 

Para exemplificar vamos alterar a função anterior para criar a string e armazenar localmente, e depois imprimir.

(defn ola [nome] (let [mensagem (str "Ola " nome)] (println mensagem))) 

Criamos a mensagem com a string completa dentro do let e depois chamamos o println.

Espero que tenha gostado do conteúdo! Se sim, compartilhe, comente e/ou deixe uma reação. Isso ajuda a trazer visibilidade e saber que estão curtindo!
E se não gostou, comenta aí o que poderia melhorar! Quem sabe o próximo post você goste?

Abraços e até breve