Baixa o ambiente do Racket pra sua computador aqui

As ideias do Lisp (incluindo Racket, Scheme, Clojure etc.)

As programas são feito de listas.

  (1 2 3) 
 

E listas dentro as listas

  (1 2 (3 4))

Expressões também são listas. Sempre o nome do operador ou função como a primeiro elemento do lista e as operandos / argumentos depois.

  (+ 2 2)
  
  (* 3 (+ 2 5))
  

Traduze esta expressão em Lisp e avalia no sua computador

 
  3 * (5 + 9)
 

E isso?

  4 * (1 + 2 + 3 + 4 + 5 + 6) * 5 / 10

Sua programa em Lisp e nada mais do que um series destas expressões.

Por exemplo, o expressão condicional utilizando “if” :

  (if (= 0 1) "sim" "nao")

Obs : em Racket, o “verdade” é #t e “falso” é #f

  (= 0 1)
  (= 1 1)

Ou funções que lidar com strings.

  (substring "todo bem?" 0 4)
  
  (substring "abcdefg" 3)

Utilizar “string-append” pra concatenar duas strings.

  (string-append "A" "BC")

Teste de igualidade :

  (equal? "abc" "abc")
  (equal? "abc" "abcd")

Obs : O ponto de interrogação pode ser utilizado nos nomes do funções e variáveis.

Criando um nome, e vinculando um valor com o nome utilizar o função “define”

  (define x 15)

  (if (< 10 x) "sim" "nao")

Criando uma função também com estrutura de lista … utilizando o função “define”

  (define (f x) (* x x))

  (f 8)

Criar um função que receber dois argumentos strings e responde se eles tem as primeiros 4 caracteres iguais.

Eg.

  (teste "askhkjasdhk" "askhbhdifdsbkfbkdsjb") -> "sim"
  (teste "askhfdfsdkfbksdj" "lhsdlfsbdk") -> "nao"

Adaptar sua função pra receber as dois argumentos e um numero n e teste as primeiros n caracteres.

Nao podemos escrever um lista assim :

  (1 2 3 4)
  
  ERROR: 
  application: not a procedure;
  expected a procedure that can be applied to arguments    
  

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 : car e cdr

  (car '(1 2 3))

  (cdr '(1 2 3))

Podemos combinar :

  (car (cdr '(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.

  (define (vv xs) (cons (car (cdr xs)) (list (car xs))))

  (vv '("Visa" "Versa"))

Escrever um função que troca a segunda elemento dos duas listas.

  (define (tamanho xs) 
      (if (empty? xs) 0 (+ 1 (tamanho (cdr xs)))))

  (tamanho '(1 2 3 4 5))
  

  (define (soma xs) 
      (if (empty? xs) 0 (+ (car xs) (soma (cdr xs)))))
      

  (soma '(1 2 3 4 5))    

4.1 - Escrever um funciao pra multiplicar cada elemento duma lista vezes 3

4.2 - Escrever um funciao pra produzir o ultimo elemento duma lista.

4.3 - Escrever um funciao pra reversar uma lista, eg. '(1 2 3 4 5) → '(5 4 3 2 1)

  (define (mult2 x) (* 2 x))

Podemos passar elas como argumentos :

  
  (define (mymap f xs) 
    (if (empty? xs) '()
        (cons (f (car xs)) (mymap f (cdr xs)))))

  (mymap mult2 '(1 2 3 4 5))

Podemos produzir elas utilizando “curry” pra “customizar” funções que já existe :

  (mymap (curry * 2) '(1 2 3 4 5))

Como nos queremos passar muitos pequenos funções como argumentos para outros funções, temos a capacidade definir funções anônimos com a “lambda”.

  (mymap (lambda (x) (* x 3)) '(1 2 3 4 5))
      

A biblioteca padrão contem varias funções pra tratar listas com outras funções

  (map (curry * 4) '(1 2 3 4 5))

  (filter (lambda (x) (< x 5)) (range 10))

  (foldr (lambda (a b) (* a b)) 1 '(1 2 3 4 5))
  

Escrever o função que somar as números par dentro uma lista utilizando estas funções do biblioteca padrão.

Escrever sua própria versão de filter