LP – Anotações Aula de Racket

Por Anderson Zanichelli

ctrl + \ = ?

Formas especiais
lambda
define
cond
quote
let

Definindo uma função
(define (quadrado x) (* x x))

(define quadrado
	( lambda (x)
		(* x x)))

Definindo um valor, uma variável
(define x 5)

(cond
  (cond1 exp1)
  (cond2 exp2)
  ...
  [(else expn)])

(define fat
	(? (n)
		(cond
			((= n 1) 1)
			((> n 1) (* n (fat(- n 1)))))))

(define (fat n)
    (cond
      ((= n 1) 1)
      ((> n 1) (* n (fat(- n 1))))))

(integer? x)
(odd? y)
(number? a)
(string? b)

(reminder 10 4) == % mod
(quotient 10 3) divisao inteira

(sqrt 2)
(expt 3 4)

(and #t #t)
(or #t #f)

(quote objeto)
'(+ 2 3)

(length '( 1 2 3 4 5))
(define pessoa '(nome, idade, sexo))

car (first racket) head
cdr (rest  racket) tail

(define (tamanho lista)
  (cond
    ((null? lista) 0)
    (else (+ 1 (tamanho (cdr lista))))))

Recursão em cauda
(define (tamanho-acc acc lista)
  (cond
    ((null? lista) acc)
    (else (tamanho-acc (+ 1 acc) (cdr lista)))))

Função tamanho otimizada
(define (tamanho lista)
  (tamanho-acc 0 lista))

(define (minimo lista)
  (cond
    [((null? (cdr lista)) (car lista))]
    [((< (car lista) (minimo (cdr lista))) (car lista))]
    [(else (minimo (cdr lista)))]))

Minimo melhorada
(define (minimo lista)
  (cond
    [((null? (cdr lista)) (car lista))]
    [else
     (define primeiro (car lista))
     (define minimo-resto (minimo (cdr lista)))
     (if (< primeiro minimo-resto)
         primeiro
         minimo-resto)]))

Utilizando o let para criar uma espécie de bloco
(let ((10 valores )*) exp)

Exemplo
(* (+ x x) (+ x x))

usariamos
(let ((z (+ x x )))
	(* z z))
(let (()))

Mínimo com o uso do let
(define (minimo lista)
  (if (null? (cdr lista))
      (car lista)
      (let ([primeiro (car lista)])
        [minimo-resto (minimo (cdr lista))])
      (if (< primeiro minimo-resto)
          primeiro
          minimo-resto)))

Aumento de expressividade com o let
(let ((x (* 20 10))
      (y (+ 50 5))
      (* x x y)))

Se fosse com o lambda
(lambda (x y)
	(* x x y)) --> Retorna uma função

(lambda (x y)
	(* x x y)) (* 21 10) (+ 50 5) deve ser aplicada assim com o lambda, o let facilitou a escrita

let* permitiria fazer algo do tipo
(let* ((x (* 20 10))
       (y  (- x 5))
       (* x x y)))

Minimo com acumulador
(define (minimo-acc acc lista)
  (if (null? lista)
      acc
      (minimo-acc (if (< acc (car lista))
                      acc
                      (car lista))
                  (cdr lista))))

(define (minimo lista)
  (minimo-acc (car lista) (cdr lista)))

Abstração para reduce

(define (reduce func acc lista)
  (if (null? lista)
      acc
      (reduce func
              (func acc (car lista))
              (cdr lista))))

Reescrevendo a minimo e tamanho
(define (minimo lista)
  (define (min a b))
  (if (< a b) a b)
  (reduce min (car lista) (cdr lista)))

(define (tamanho lista)
  (define (soma1 acc b)
    (add1 acc))
  (reduce soma1 0 lista))

internamente o reduce se chama fold, foldl e foldr

ctrl + \ = ?

Formas especiais
lambda -> let
define
cond -> if
quote
fold
map
filter
--------------------
Funções primitivas
car
cdr
cons -> construction
eval
apply
append
negate
----------------------
Funções Predicado
even?
positive?

----------------------
cons
Montar listas, adiciona um elemento na cabeça da lista

(cons 7 '(3 4 6))
(cons '(1 5) '(3 4 6))

(define x 10)
(define y 20)

(cons x '())
(cons y (cons x '()))

(list x y 10)

(enumerar 1 10)

(define (enumerar inicio fim)
  (if (>= inicio fim) 
      (list fim)
      (cons inicio (enumerar (add1 inicio) fim))))

faz a enumeração 

(1 .. 3)
	v
	1	(2 .. 3)
			v
			2	(3 .. 3)
					v
					3

(define (mais1 lista)
  (if (null? lista)
      '()
      (cons (add1 (car lista)) (mais1 (cdr lista)))))

(mais1 '(2 3 4))
> '(3 4 5)

(foldr cons '() '(7 9 2))

(foldl cons '() '(7 9 2))

   cons  cons cons 
'()    (7    9    2)
	 V
	'(7)
		  V
		'(9 7)
				V
			  '(2 9 7)

Mais um com foldr

(define (mais1-fold lista)
  (define (cons-mais1 e acc)
    (cons (add1 e) acc))
  (foldr cons-mais1 '() lista))

(define (quadrado x)
  (* x x))

(define (quadrado-fold lista)
  (define (cons-quadrado e acc)
    (cons (quadrado e) acc))
  (foldr cons-quadrado '() lista))

(map quadrado '(3 4 5)) semelhante ao de cima

(define (mymap function lista)
  (define (cons-map e acc)
    (cons (function e) acc))
  (foldr cons-map '() lista))

Função anônima para aplicar o cubo
(mymap (? (x) (* x x x)) '(1 2 3))

----------------------
eval
Avalia listas, ou programas

(eval '(+ 3 4))
> 7
-------------------
apply
Pega os valores de uma lista e aplica a função a ela

(apply < '(3 4))
(apply + '(3 4 5 6))
----------------------
filter

(filter even? '(1 2 4 6 7 9 3))

Quick Sort com o filter

(define (quicksort lista)
  (if (null? lista)
      '()
      (let* ([pivo (car lista)]
             [cauda (cdr lista)]
             [menor-pivo? (? (x) (< x pivo))]
             [maior-pivo? (negate menor-pivo?)])
        (append (quicksort (filter menor-pivo? cauda))
                (list pivo)
                (quicksort (filter maior-pivo? cauda))))))