Listas

As listas são sua estrutura de dados mais importante nos Lisps, incluindo Clojure.

Nao podemos escrever um lista assim :


(1 2 3 4)

Pq? A Lisp sempre trata o primeiro item na lista como um funcao. Pra falar sobre um lista sem tentar avaliar, precisamos o "quote".


'(1 2 3 4)

Funções que produzam listas.


(list 1 2 3 4)


(range 10)

Funções muito importante pra analisar / decompor as listas : first e rest


(first '(1 2 3))


(rest '(1 2 3))

Podemos combinar :


(first (rest '(1 2 3)))

Construção das listas :


(list 1 2 3)

Ou "cons", adicionar um elemento normal no inicio duma lista.


(cons "Calango" '("Hacker" "Clube"))

Podemos escrever funções que moda / processar listas.


(defn vv [xs] (cons (first (rest xs)) (list (first xs))))
(vv '("Visa" "Versa"))

4.1 - Escreve um função que troca os segundos elementos dos duas listas. Por exemplo :


(troc2 '(1 "+" 3) "-") -> (1 "-" 3)
(troc2 '(23 "*" 4) "/") -> (23 "/" 4)s


; Escreve aqui

Recursividade é sua jeito de navegar dentro as estruturas


(defn tamanho [xs]
(if (empty? xs) 0 (+ 1 (tamanho (rest xs)))))

(tamanho '("a" "b" "c" "d" "e" "f"))


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

(soma '(1 2 3 4 5))

5.1 - Escrever um funciao pra multiplicar cada elemento duma lista vezes 3
5.2 - Escrever um funciao pra produzir o ultimo elemento duma lista.
5.3 - Escrever um funciao pra reversar uma lista, eg. '(1 2 3 4 5) -> '(5 4 3 2 1)

Podemos pegar a primeiro n elementos dos listas com take


(take 5 (range 10))

Em Clojure, nos falamos listas sao "lazy" (preguisozo).

Pq? As valores de listas saos so evaliadas quando nos queremos.

Por exemple podemos criar uma lista infinito.

A funcao repeat produzi uma lista infinita da repeticoes da seu argumento.


(take 10 (repeat 1))

Podemos utilizar cycle pra criar listas infinitos de valores


(take 10 (cycle '("A" "B" "C")))

Aqui 'e um funciao que produz o quadrada de todos os elementos duma lista


(defn q [xs]
(if (empty? xs) ()
(cons (* (first xs) (first xs)) (q (rest xs)) )))

(q (range 10))

Podemos aplicar isso pra nossa lista infinito?

Claro.

Mas precisamos fazer duas coisas :

1) Embrulhe-la o corpo do funciao nume lazy-seq
2) Quando nos queremos mostrar ao usuario, restritar pra uma lista finito ... demora bastante imprimir uma lista infinita :-)


(defn q [xs]
(lazy-seq
(if (empty? xs) ()
(cons (* (first xs) (first xs)) (q (rest xs)) ))))

(take 10 (q (cycle '(1 2 3 4))))