Carregar apresentação
A apresentação está carregando. Por favor, espere
PublicouAlana Lopes Alterado mais de 10 anos atrás
2
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.
3
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).
4
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)
5
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.
6
Boolean: #t = True(Qualquer coisa diferente de zero e Lista vazia). #f = False (Zero ou Lista vazia).
7
Numbers: Number=(42). Complex=(2+3i). Real=(3.1416), (22/7), (42)
8
Numbers: Rational=(3.1416), (22/7) Integer=(42). Number = Complex = Real = Rational = Integer.
9
Characteres: São representados pela prefixo #\ #\c=caracter (c). #\newline=(nova linha). #\space=(espaço em branco).
10
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.
11
Symbols: (quote xyz) => xyz E => E
12
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.
13
String: (string #\h #\e #\l #\l #\o) ) => "hello" "Hello, World!" => "Hello, World!"
14
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)
15
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.
16
Dotted pair: (cons 1 #t) => (1. #t)
17
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.
18
List: > (2 4 6 8 10) => (2 4 6 8 10) > (list 2 4 6 8 10) => (2 4 6 8 10)
19
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
20
List: > (cdr (list 2 4 6 8 10)) => (4 6 8 10) > (car (cdr (list 2 4 6 8 10))) => 4
21
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)
22
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)))
23
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))))
24
Existem três tipos de expressões condicionais: Usando a palavra reservada If. Usando a palavra reservada Cond. Usando a palavra reservada Case.
25
Expressão condicionail If : (if condição conseqüência alternativa) (if condição conseqüência)
26
Expressão condicionail If : (if (< a b) (square a) (square b)) (if ( x2 x3) (if (> x1 x2) (< x2 x3) #f))
27
Expressão condicionail Cond : (cond (condição1 conseqüência1) (condição2 conseqüência2). (else alternativa))
28
Expressão condicionail Cond : (cond ((> a b) ( square a )) ((> b c) ( square b )). (else (square c) ))
29
Expressão condicionail Case : (case arg expr1 expr2 expr3...)
30
Expressão condicionail Case : (case (+ 3 4) ((7) 'seven) ((2) 'two) (else 'nothing)) => seven
31
Expressão condicionail Case : (case 'a ((a b c d) 'first) ((e f g h) 'second) (else 'rest)) => first
32
Existem três tipos de expressões lógicas: Usando a palavra reservada And. Usando a palavra reservada Or. Usando a palavra reservada Not.
33
Expressões lógica com And: (and expr1 expr2... exprn)
34
Expressões lógica com And: (and (< 2 5) (< 2 4)) =>#t
35
Expressões lógica com Or: (or expr1 expr2... exprn)
36
Expressões lógica com Or: (or (< 2 5) (< 2 4)) =>#t
37
Expressões lógica com Not: (not expr)
38
Expressões lógica com Not: (not (< 5 10)) => #f
39
Utilizamos a palavra reservada define para declarar variáveis globais: (define a 10) a =>10
40
Utilizamos a palavra reservada set! Para alterar variáveis: (define a 10) a =>10 (set! a 5) a => 5
41
Podemos declarar procedures utilizando a palavra reservada define ou lambda. Não existe diferença entre as declarações. ( define square (lambda (x) (* x x)))
42
Utilizando a palavra reservada define: (define (square x) (* x x)) (square 2) => 4
43
Utilizando a palavra reservada lambda: (lambda formal-parâmetros body) (lambda (x) (* 2x) 5) => 10
44
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)
45
Utilizando a palavra reservada let. (let ((x 2) (y 10)) (+ x y)) => 12 (let ((x 2) (y 10)) (/ y x)) => 5
46
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
47
Utilizando a palavra reservada let*. (let* ((var1 exp1) (var2 exp2)... (varn expn)) body)
48
O que é equivalente a: (let ((var1 expr1)) (let ((var2 expr2)) (let... (let ((varn exprn)) body)... )))
49
Utilizando a palavra reservada let*. (define x 10) (let* ((x 5) (y (* x 2))) (+ x y)) => 15
50
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
51
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...)
52
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"
53
Utilizando a palavra reservada letrec. (letrec ((var1 val1) (var2 val2)... (varn valn)) body)
54
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)))
55
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.
56
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))))
57
Utilizando Tail recursion. A saída será: (factorial-tail 5 ) => 120
58
Utilizando Recursão normal. (define (factorial n) ( if (equal? n 0) 1 (* n (factorial (- n 1 )))))
59
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
60
Para gerarmos a saída Hello World usamos o seguinte código: (display "Hello World!") (newline) => Hello World! =>
61
(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)
67
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/
Apresentações semelhantes
© 2024 SlidePlayer.com.br Inc.
All rights reserved.