Clojure #0

Posted on August 21, 2010

4


Clojure é uma linguagem dinâmica que pode rodar na JVM, possui uma syntax bem limpa e clara, é extremamente baseada em Lisp, e tem características de liguagem funcional, ou seja, estrutura de dados imutáveis tornando a maioria das funções livres de efeitos colaterais, o que torna mais fácil a escrita de programas complexos.

Por rodar na JVM, Clojure é muito relacionado com Java. A integração é bem simples e rápida, não necessitando nenhuma camada intermediária e, ao contraário da maioria das linguagens dinâmicas, clojure é rápido pois foi justamente escrito para tirar vantagens dos poderes de otimização das JVMs, podendo ser usada para diversos propósitos.

Clojure combina idéias vindas do Lisp, da programação funcional e lida com problemas de concorrência.

Instalando

Pra ver os primeiros códigos Clojure rodando é necessário baixar o arquivo cloujure.zip

Descompaacte o arquivo. Voce vai encontrar diversas pastas e arquivos, mas não se preocupe com isso agora.
Dentro dessa pasta crie um arquivo chamado clojure.clj (repare no .CLJ para arquivos clojure).
Vamos começar criando um teste ao invés do tradicional REPL. Não se preocupe em entender toda syntax agora, apenas vá se adaptando:

(ns clojure.test.example
(:use clojure.test))

(deftest add-1-to-1
(is (= 2 (+ 1 1))))

(run-all-tests)

Rode no terminal com:
java -cp clojure.jar clojure.main -i clojure.clj

Quando tudo der certo você deve ver o seguinte output:

Testing user

Testing clojure.zip

Ran 1 tests containing 1 assertions.
0 failures, 0 errors.

Mais Clojure

Clojure equilibra conhecimentos de linguagens do passado com poderes das linguagens atuais.
Veja o exemplo abaixo:

//Java
public class StringUtils {
public static boolean isBlank(String str) {
int strLen;
if (str == null || (strLen = str.length()) == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if ((Character.isWhitespace(str.charAt(i)) == false)) {
return false;
}
}
return true;
}
}

; Clojure
(defn blank? [s] (every? #(Character/isWhitespace %) s))

A versão Clojure é bem mais curta, mas o mais importante é ser mais simples. Não são necessárias nem variáveis. Isso é possível graças as chamadas “higher-order function” (funções que aceitam outras funções como argumento e/ou retornam funções como resultado). Além disso a versão Cljure é bem legivel. É como ler “uma string é vazia se toos os caracteres nela são espaços em branco”.


// java
public class Person {
private String firstName;
private String lastName;
public Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}

; clojure
(defstruct person :first-name :last-name)

Person em Clojure é imutavel (Clojure também prove implementação correta de hash_code e equals automaticamente).

Definindo funções

(defn hello-world [username]
(println (format "Hello, %s" username)))

Clojure é uma linguagem funcional, mas não puramente como Haskell.
Funções podem ser criadas em runtime, retornadas, e normalmente usadas como um tipo como outro qualquer.
E nos tempos atuais, programação funcional é muito mais urgente que antes, devido aos avanços de hardware.

Clojure simplifica a programação concorrente, tornando fácil escrever código thread-safe.
Como estruturas imutáveis não mudam nunca, não existe risco de dados corrompidos por terem sidos utilizados
por outras threads. Tudo isso dentro da já consagrada JVM, onde inclusive, Clojure implementa funções simples
para uma série de interfaces Java.

Agora que já falamos sobre as características do Clojure, os próximos posts abordarão mais sobre código.

Posted in: clojure