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 o primeiro elemento do lista e as operandos / argumentos depois.

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

Traduze esta expressão em Lisp e avalia no seu 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

  #lang racket

  (require racket/draw)
  (require racket/gui) 

  (define target (make-bitmap 400 400)) 
  (define dc (new bitmap-dc% [bitmap target]))
  (make-object image-snip% target)

  (define (:x p) (car p))
  (define (:y p) (cadr p))

  (define (desenha dc forma cor) 
    (send dc set-pen cor 3 'solid)
    (if (< (sequence-length forma) 2) '()
        (let ([p1 (car forma)]
              [p2 (cadr forma)] )
          (send dc draw-line (:x p1) (:y p1) (:x p2) (:y p2))
          (desenha dc (cdr forma) cor) ) )
     )

  (define quad1 '( (0 0) (0 100) (100 100) (100 0) (0 0)))
  (define quad2 '( (100 200) (100 300) (200 300) (200 200) (100 200)))

  (define cena (list quad1 quad2))

  (define (repaint dc)
      (for ([forma cena])
          (desenha dc forma "green")
          )
      )  

  (define frame (new frame%
                     [label "Tela"]
                     [width 400]
                     [height 400]))

  (new canvas% [parent frame]
               [paint-callback
                (lambda (canvas dc)
                  (repaint dc)
                  )])

  (send frame show #t)

Obs : Mais informacao dos funcoes do desenha em Racket sao aqui : http://docs.racket-lang.org/draw/overview.html