Embed Size (px)
Citation preview
Scheme foi criada em 1975 no laboratório de AI do MIT por Guy L. Steele e Gerald J. Sussman que queriam criar uma linguagem de semântica simples e clara. Scheme foi influenciada pelo cálculo lambda, que é uma das primeiras linguagens de programação funcional no mundo, também teve seu escopo estático herdade de Algol e a sintaxe de Lisp. É uma linguagem muito bem desenhada e de propósito geral.
• A flexibilidade de Scheme é gatantida devido a ausência de restrições, assim o porder da linguagem não limitando .
• Utilização de sistema de recursão denominado “Tail Recursion” (recursão de cauda).
• Homogeneidade com sua notação pré-fixada, ou seja, existe basicamente uma regra que rege a escrita de qualquer expressão:
(+ 2 3)
(squart 5)
(f x y)
• A passagem de parâmetros é feita por valor.
• Utilização de Listas como mecanismo básico de estruturação de dados.
• Suporta multiplos-paradigmas como, programação funcional, imperativa , orientação a objetos, etc.
• Boolean:
• #t = True (Qualquer coisa diferente de zero e “Lista vazia”).
• #f = False (Zero ou “Lista vazia”).
• Numbers:
• Number = (42).
• Complex = (2+3i).
• Real = (3.1416), (22/7), (42)
• Numbers:
• Rational = (3.1416), (22/7)
• Integer = (42).
• Number = Complex = Real = Rational = Integer.
• Characteres: São representados pela prefixo #\
• #\c = caracter (c).
• #\newline = (nova linha).
• #\space = (espaço em branco).
• Symbols:
• Apesar de ser tipo simples, ou seja, primitivo como os anteriores, são tratados como identificadores de variáveis, portanto seu valor é o valor contido na mesma.
• Para especificarmos um símbolo usamos a palavra reservada quote ou aspa simple antes do símbolo.
• Symbols:
• (quote xyz)=> xyz
• ‘E=> E
• String:
• Não é um tipo simples, ou seja, primitivo como os anteriores, é composta pela combinação de caracteres, sendo assim uma seqüência de caracteres de modo estruturado e entre aspas duplas “”.
• String:
• (string #\h #\e #\l #\l #\o) )
=> "hello"
• "Hello, World!"
=> "Hello, World!"
• Vectors:
• São seqüências como as Strings mas, seus elementos podem ser uma seqüência de qualquer tipo e não apenas de caracteres.
• (vector 0 1 2 3 4) => #(0 1 2 3 4)
• Dotted pair:
• É composto de dois valores arbitrarios, sendo o primeiro chamado de car e o segundo de cdr e sua combinação é realizada com a palavra reservada cons.
• Dotted pair:
• (cons 1 #t)
=> (1 . #t)
• List:
• Listas podem ser construídas simplesmente colocando os valores desejados entre parênteses e utilizando aspa simple antes do primeiro parêntese ou utilizando a palavra reservada list. Listas podem conter qualquer valor inclusive lista de lista.
• List:
• > ‘(2 4 6 8 10)
=> (2 4 6 8 10)
• > (list 2 4 6 8 10)
=> (2 4 6 8 10)
• List:
• Assim como em vetores, podemos utilizar car e cdr para acessarmos o 1º elemento e o restante da lista respectivamente.
• > (car (list 2 4 6 8 10))=> 2
• List:
• > (cdr (list 2 4 6 8 10))=> (4 6 8 10)
• > (car (cdr (list 2 4 6 8 10)))=> 4
• List:
• Podemos utilizar várias combinações de car e cdr.
• > (cadr (list 2 4 6 8 10))=> 4
• > (cddr (list 2 4 6 8 10))=> (6 8 10)
• List:•(caar ls) ; is the same as (car (car ls))• (cadr ls) ; is the same as (car (cdr ls))•(cdar ls) ; is the same as (cdr (car ls))•(cddr ls) ; is the same as (cdr (cdr ls))•(caaar ls) ; is the same as (car (car (car ls)))•(caadr ls) ; is the same as (car (car (cdr ls)))•(cadar ls) ; is the same as (car (cdr (car ls)))•(caddr ls) ; is the same as (car (cdr (cdr ls)))•(cdaar ls) ; is the same as (cdr (car (car ls)))•(cdadr ls) ; is the same as (cdr (car (cdr ls)))•(cddar ls) ; is the same as (cdr (cdr (car ls)))•(cdddr ls) ; is the same as (cdr (cdr (cdr ls)))
• List:•(cadaar ls) ; is the same as (car (cdr (car (car ls))))•(cadadr ls) ; is the same as (car (cdr (car (cdr ls))))•(caddar ls) ; is the same as (car (cdr (cdr (car ls))))•(cadddr ls) ; is the same as (car (cdr (cdr (cdr ls))))•(cdaaar ls) ; is the same as (cdr (car (car (car ls))))•(cdaadr ls) ; is the same as (cdr (car (car (cdr ls))))•(cdadar ls) ; is the same as (cdr (car (cdr (car ls))))•(cddadr ls) ; is the same as (cdr (cdr (car (cdr ls))))•(cdddar ls) ; is the same as (cdr (cdr (cdr (car ls))))•(cddddr ls) ; is the same as (cdr (cdr (cdr (cdr ls))))
• Existem três tipos de expressões condicionais:
• Usando a palavra reservada If.
• Usando a palavra reservada Cond.
• Usando a palavra reservada Case.
• Expressão condicionail If :
• (if condição conseqüência alternativa)
• (if condição conseqüência)
• Expressão condicionail If :
• (if (< a b) (square a) (square b))
• (if (< x1 x2) (> x2 x3)
(if (> x1 x2) (< x2 x3)
#f))
• Expressão condicionail Cond :
• (cond (condição1 conseqüência1)(condição2 conseqüência2)...(else alternativa))
• Expressão condicionail Cond :
• (cond ((> a b) (square a))((> b c) (square b))...(else (square c)))
• Expressão condicionail Case :
• (case arg expr1 expr2 expr3 ...)
• Expressão condicionail Case :
• (case (+ 3 4)
((7) 'seven)
((2) 'two)
(else 'nothing))
=> seven
• Expressão condicionail Case :
• (case 'a
((a b c d) 'first)
((e f g h) 'second)
(else 'rest))
=> first
• Existem três tipos de expressões lógicas:
• Usando a palavra reservada And.
• Usando a palavra reservada Or.
• Usando a palavra reservada Not.
• Expressões lógica com And:
• (and expr1 expr2 ... exprn)
• Expressões lógica com And:
• (and (< 2 5) (< 2 4))
=>#t
• Expressões lógica com Or:
• (or expr1 expr2 ... exprn)
• Expressões lógica com Or:
• (or (< 2 5) (< 2 4))
=>#t
• Expressões lógica com Not:
• (not expr)
• Expressões lógica com Not:
• (not (< 5 10))
=> #f
• Utilizamos a palavra reservada define para declarar variáveis globais:
• (define a 10)
a
=>10
• Utilizamos a palavra reservada set! Para alterar variáveis:
• (define a 10)
a
=>10
(set! a 5)
a
=> 5
• Utilizando a palavra reservada define:
• (define (square x) (* x x))
• (square 2)
=> 4
• Utilizando a palavra reservada lambda:
• (lambda formal-parâmetros body)
• (lambda (x) (* 2x) 5)
=> 10
• Utilizamos a palavra reservada let e let* para criar variáveis locais. A diferença entre as duas declarações é que let* é um aninhamento de lets, ou seja, uma variável declarada em um let mais a esquerda pode ser usada em um let mais a direita.
• (let ((var1 exp1) (var2 exp2) . . . (varn expn)) body)
• Utilizando a palavra reservada let.
• (let ((x 2) (y 10)) (+ x y))
=> 12
• (let ((x 2) (y 10)) (/ y x))
=> 5
• Utilizando a palavra reservada let.
• (define x 10)
(+ (let ((x 5)) (* x (+ x 2))) x)
=> 45
• (define x 10)
(let ((x 5) (y (* x 2))) (+ x y))
=> 25
• Utilizando a palavra reservada let*.
• (let* ((var1 exp1)
(var2 exp2)
. . .
(varn expn))
body)
• O que é equivalente a:
• (let ((var1 expr1))
(let ((var2 expr2))
(let ...
(let ((varn exprn))
body) ... )))
• Utilizando a palavra reservada let*.
• (define x 10)
(let* ((x 5)
(y (* x 2)))
(+ x y))
=> 15
• Comparando let com let*.
• (define x 10)
(let ((x 5) (y (* x 2)))
(+ x y))
=> 25
• (define x 10)
(let* ((x 5) (y (* x 2)))
(+ x y))
=> 15
• Utilizando a palavra reservada do.
• É uma construção de iteração complexa, onde algumas variáveis são especificadas, a inicialização de algumas também e o passo, ou seja, um controle de loop. É um loop parecido com o for.
• (do ((var1 init1 step1)
...)
(test expr ...) command ...)
• Utilizando a palavra reservada do.
• (do ((str (string #\f #\o #\o #\b #\a #\r))
(i 0 (+ i 1 ))) ((= i (string-length str ) ) str )
(string-set! str i #\b))
• A saída será:
• => "bbbbbb"
• Utilizando a palavra reservada letrec.
• (letrec ((var1 val1)
(var2 val2)
. . .
(varn valn))
body)
• Utilizando a palavra reservada letrec.
• (define factorial
(lambda (n)
(letrec ((iter
(lambda (product counter)
(if (> counter n)
product
(iter (* counter product)
(+ counter 1))))))
(iter 1 1)))
• Tail recursion.
• São chamadas recursivas que não necessitam de alocação dinâmica na memória, ou seja, utilização de empilhamento de chamadas recursivas. Cada chamada já passa a resposta da sua iteração para a próxima iteração, assim não precisamos de fazer o desempilhamento devolvendo a resposta de cada chamada recursiva para combinarmos e encontrarmos a resposta final.
• Utilizando Tail recursion.
• (define (factorial-tail n)(factorial-helper n 1))
(define (factorial-helper n total)(if (equal? n 0)
total (factorial-helper (- n 1) (* n total))))
• Utilizando Tail recursion.
• A saída será:
• (factorial-tail 5 )=> 120
• Utilizando Recursão normal.
• (define (factorial n)( if (equal? n 0)
1 (* n (factorial (- n 1 )))))
• Utilizando Recursão normal.
• A saída será |(factorial 5)| (factorial 4)| |(factorial 3)| | (factorial 2)| | |(factorial 1)| | | (factorial 0)| | | 1| | |1| | 2| |6| 24|120
• Para gerarmos a saída “Hello World” usamos o seguinte código:
• (display "Hello World!")
(newline)
=> Hello World!
=>
• (define bottles• (lambda (n)• (cond ((= n 0) (display "No more bottles"))• ((= n 1) (display "One bottle"))• (else (display n) (display " bottles")))• (display " of beer")))
• (define beer• (lambda (n)• (if (> n 0)• (begin• (bottles n) (display " on the wall") (newline)• (bottles n) (newline)• (display "Take one down, pass it around") (newline)• (bottles (- n 1)) (display " on the wall") (newline)• (newline)• (beer (- n 1))))))
• (beer 99)
• http://en.literateprograms.org/Hello_World_(Scheme)• http://www.cs.hut.fi/Studies/T-93.210/schemetutorial/node1.html• http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme.html• http://pheattarchive.emporia.edu/courses/2002/cs220f02/anotherSchemeTtutorial/default.htm• http://www.inf.ufsc.br/~barreto/trabaluno/PF_Geraldo_Maria.pdf
Festa com 99 bottles of the beer (youtube)• http://www.youtube.com/watch?v=vWKKuBblumo• http://www.youtube.com/watch?v=n_C7Rj2qMMs&feature=related• http://www.youtube.com/watch?v=PyEMGDa8Jcg&feature=related
Concurso Talent Explosion e vídeo no youtube• http://www.youtube.com/watch?v=lQrOhQhdoQI&feature=related• http://www.shawnlam.ca/jackfm/
