• As origens
• Imutabilidade
• Funções puras
• Funções de primeira classe
• Composição de funções
• Aplicação de funções
• Lazy evaluation
• Clojure e a JVM
• Conclusão

§As origens

Clojure é uma linguagem de programação dinâmica e funcional para a plataforma JVM. É baseada em LISP e foi projetada para ser expressiva, concisa e fácil de usar.

Foi criada por Rich Hickey em 2007 e é uma linguagem dinâmica e funcional. O objetivo de Hickey ao criar Clojure era proporcionar uma linguagem de programação moderna, que tivesse as vantagens da programação funcional e que pudesse ser executada na plataforma JVM (Java Virtual Machine).

Desde então, a comunidade de desenvolvedores de Clojure tem crescido constantemente, sendo a linguagem utilizada em vários projetos comerciais, incluindo aplicativos web, aplicativos móveis, e aplicativos de big data. No Brasil temos como exemplo o banco Nubank, que tem boa parte de seus serviços criados em Clojure.

Com seu enfoque em imutabilidade e programação funcional, Clojure oferece uma abordagem diferente para a resolução de problemas de programação, tornando-o uma escolha popular entre desenvolvedores que buscam simplicidade e eficiência.

Além de rodar na JVM, Clojure é interoperável com Java, permitindo assim que os desenvolvedores aproveitem todas as ferramentas e bibliotecas existentes na plataforma. Isso a torna uma escolha robusta para projetos de desenvolvimento mais escaláveis.

Atualmente, Clojure é mantido como um projeto de software livre e é uma das linguagens de programação funcional mais populares entre os desenvolvedores.

§Imutabilidade

A imutabilidade é uma idéia fundamental em programação funcional e no cálculo lambda. Esse conceito está presente em Clojure, e significa que uma vez que um valor é criado, ele não pode ser alterado.

Ao invés de modificar valores existentes, a imutabilidade incentiva a criação de novos valores a partir dos antigos. Isso torna o código maisprevisível e fácil de manter, pois não há efeitos colaterais, que são geralmente a causa de erros inesperados.

Suponha que você tenha uma lista de números e queira adicionar um número. Em vez de modificar a lista original, você cria uma nova lista que inclua o novo número. Assim, se garante que a lista original permanece inalterada, facilitando a verificação de erros (especialmente no debug).

O uso de valores imutáveis torna o programa mais seguro, pois as informações são compartilhadas entre partes diferentes do programa sem causar modificações dos dados originais.

Podemos dizer que na programação funcional, o estado é visto como imutável e os dados são tratados como valores imutáveis que são passados como argumentos para funções puras.

As funções puras não possuem efeitos colaterais e retornam sempre o mesmo resultado quando chamadas com os mesmos argumentos, como veremos adiante.

Podemos falar um pouco sobre a origem desses conceitos, que é o cálculo lambda. Essa teoria matemática fornece a base para a programação funcional.

O cálculo lambda define essas estruturas básicas, como a imutabilidade, a composição de funções e a aplicação de funções a argumentos.

§Funções puras

São funções que sempre produzem o mesmo resultado para um determinado conjunto de argumentos, não gerando portanto efeitos colaterais, como a alteração de variáveis externas ou o uso de entradas e saídas.

Essas funções facilitam o raciocínio sobre o comportamento do programa e a realização de testes automatizados.

Em Clojure, as funções puras são implementadas seguindo os princípios da programação funcional. Ou seja, as funções devem ser tratadas como valores imutáveis e nunca devem modificar variáveis externas.

Além disso, Clojure possui funções de alta ordem, que permitem a composição de funções para criar novas funcionalidades de maneira modular e sem efeitos colaterais.

Um exemplo de função pura em Clojure é a função inc, que recebe um número como argumento e retorna o sucessor desse número.

Essa função sempre produz o mesmo resultado para um determinado número, sem efeitos colaterais. Ela pode ser facilmente testada, pois sempre retorna o mesmo valor para um dado argumento.

(inc 1)     ; retorna 2
(inc 2)     ; retorna 3

Outro exemplo de função é reverse, que recebe uma sequência e retorna outra com os elementos na ordem inversa. Essa função é pura, pois sempre produz o mesmo resultado para uma sequência, não tendo efeitos colaterais.

(reverse [1 2 3])       ; retorna [3 2 1]

(reverse "abc")         ; retorna "cba"

Sendo as funções puras uma parte importante da programação funcional, Clojure fornece as ferramentas necessárias de maneira fácil, porém eficaz.

§Funções de primeira classe

De forma simples, funções de primeira classe (first-class functions) são aquelas que podem ser tratadas como qualquer outro valor em uma linguagem de programação. Significa que elas também podem ser passadas como argumentos de outras funções, retornadas como valores e armazenadas em variáveis, ou até mesmo criadas dinamicamente.

O termo originou-se na teoria dos tipos em computação e refere-se à capacidade de uma linguagem para tratar funções como valores, ou seja, sem nenhuma restrição. A idéia foi introduzida na linguagem Lisp em meados de 1950, sendo uma característica fundamental das linguagens funcionais modernas.

Em Clojure, as funções são valores de primeira classe. Elas podem ser armazenadas em variáveis, passadas como argumentos e retornadas como valores.

Por exemplo, podemos definir uma função soma que recebe duas funções como argumentos e retorna uma nova função, que é a soma dos resultados dessas funções aplicadas a um determinado valor:

(defn soma [f g]
  (fn [x]
    (+ (f x) (g x))))

(defn dobro [x] (* x 2))
(defn triplo [x] (* x 3))

((soma dobro triplo) 4)     ; retorna 20 (4 * 2 + 4 * 3)

No exemplo acima, soma é uma função que recebe duas funções, f e g, e retorna uma nova função que aplica f e g ao mesmo argumento x, soma seus resultados e retorna o valor resultante.

Em seguida, definimos duas funções dobro e triplo que multiplicam seu argumento por 2 e 3, respectivamente. Então criamos uma nova função chamada soma-dobro-triplo que é a soma dessas duas funções aplicadas ao valor 4.

É um exemplo muito simples, mas que ilustra outra característica especial das linguagens funcionais: a composição de funções.

§Composição de funções

Este é um conceito central em programação funcional, que envolve a criação de novas funções a partir de outras existentes.

Assim, podemos ter funções combinadas de maneira modular, criando funcionalidades mais complexas e poderosas a partir de trechos de código mais simples.

No exemplo anterior, a função soma foi criada a partir da composição das funções f e g, que foram passadas como argumentos. Portanto, esta nova função soma encapsula a lógica para combinar os resultados das funções f e g, criando uma nova funcionalidade. Isso favorece a reutilização da lógica em outros partes do código.

Composição de funções é uma técnica incrível que permite escrever código legível, conciso e modular. Ao combinar funções, é possível criar uma hierarquia que torna o código mais fácil de manter.

É também uma prática que incentiva a reutilização de código, o que pode levar a maior eficiência e redução de erros.

§Aplicação de funções

As funções são aplicadas a argumentos para produzir resultados.

(defn square [x] (* x x))
(square 4)                  ; retorna 16

No exemplo acima, a função square é definida usando defn e aceita um único argumento x. Em seguida, a função é aplicada ao número 4 e retorna 16, que é o resultado do quadrado de 4.

Outro exemplo de aplicação de funções é quando você precisa passar múltiplos argumentos para uma função. Aqui está um exemplo:

(defn add [a b] (+ a b))
(add 2 3)                   ; retorna 5

Neste outro exemplo, a função add é definida com dois argumentos, a e b, e retorna a soma deles. Em seguida, a função é aplicada aos números 2 e 3 e retorna 5.

§Lazy evaluation

Traduzindo literalmente para português, “avaliação preguiçosa”, é um conceito que se baseia em avaliar uma expressão somente quando necessário, ou seja, adiar a avaliação até que o resultado seja exigido pelo programa.

É uma técnica muito utilizada em programação funcional, pois permite lidar com listas infinitas e evitar avaliações desnecessárias, melhorando a eficiência.

A idéia de lazy evaluation tem também sua origem no cálculo lambda, no entanto a implementação desse conceito só foi feita posteriormente, como uma forma de lidar com a manipulação de listas infinitas.

Em Clojure, é implementada por meio da estrutura de dados chamada lazy sequence.

Essa estrutura permite criar sequências lazy, que são avaliadas sob demanda. Um exemplo é a função range, que retorna uma sequência infinita de números inteiros, mas que só é avaliada até o ponto necessário para atender a solicitação do programa.

(take 5 (range)) ; retorna (0 1 2 3 4)

Outro exemplo é a função map, que aplica uma função a cada elemento de uma sequência e retorna uma nova sequência com os resultados.

Ao utilizar a função map com uma sequência lazy, os resultados só são avaliados sob demanda:

(defn square [n] (* n n))
(take 5 (map square (range))) ; retorna (0 1 4 9 16)

§Clojure e a JVM

Até agora, falamos sobre os aspectos funcionais de Clojure, e como isso é aplicado através de alguns exemplos.

Mas e sobre a JVM? Como poderia uma linguagem funcional ser compatível com Java, que é orientada a objetos?

Por rodar sobre a JVM, podemos dizer que Clojure possui uma interoperabilidade ampla com o Java. É possível utilizar código Java diretamente em programas Clojure, e chamar funções e objetos Clojure a partir de programas Java.

Isso também permite a utilização de todas as bibliotecas Java, e a escrita de novas bibliotecas com código Clojure. Essa funcionalidade pode ser muito útil em projetos grandes, onde for necessário integrar sistemas de linguagens diferentes.

Porém, essa compatibilidade não é perfeita e tem suas limitações. Uma das dificuldades é a diferença de estilos de programação, a funcional e a orientação a objetos de Java. Isso pode tornar a integração complexa, exigindo um esforço maior no uso de algumas bibliotecas.

Apesar disso, é possível utilizar objetos Java em conjunto com a programação funcional.

Em um exemplo simple,s podemos utilizar as classes Java como tipos de dados dentro do código Clojure, permitindo a criação de instâncias de objetos Java. Isso tem a vantagem de termos acesso aos métodos dessas classes:

(import java.util.Date)

(def data-hoje (Date.))        ; cria uma nova instância de Date
(.toString data-hoje)        ; chama o método toString do objeto

Além disso, Clojure também possui bibliotecas para a interagir com Java, como o clojure.java.javadoc, que permite acessar a documentação das classes Java a partir do código Clojure:

(require '[clojure.java.javadoc :as javadoc])
(javadoc/doc java.util.Date) ; acessa a documentação da classe Date

Um outro exemplo de interoperabilidade é a utilização de bibliotecas gráficas, como o Swing, para a criação de interfaces gráficas de usuário.

Com Clojure, você pode aproveitar a sintaxe concisa e expressiva da linguagem, enquanto ainda é possível criar interfaces gráficas que utilizam as bibliotecas Java mais complexas.

Essa compatibilidade é uma característica importante, pois dá uma grande variedade de recursos ao desenvolvedor, e pode ser bem atrativa para todos aqueles que tem conhecimento e desejam aproveitar o ecossistema Java, aumentando sua produtividade e robustez das soluções.

§Conclusão

Neste artigo falamos sobre alguns dos conceitos fundamentais da programação funcional que estão presentes em Clojure, das suas raízem em LISP e também sobre seus aspectos modernos, como rodar na plataforma JVM.

Tudo isso faz com que Clojure seja uma linguagem funcional completa e altamente expressiva, com uma comunidade crescente de desenvolvedores.