A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

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.

Apresentações semelhantes


Apresentação em tema: "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."— Transcrição da apresentação:

1

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 ) => #( )

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: > ( ) => ( ) > (list ) => ( )

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

20 List: > (cdr (list )) => ( ) > (car (cdr (list ))) => 4

21 List: Podemos utilizar várias combinações de car e cdr. > (cadr (list )) => 4 > (cddr (list )) => (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)

62

63

64

65

66

67 Festa com 99 bottles of the beer (youtube) Concurso Talent Explosion e vídeo no youtube


Carregar ppt "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."

Apresentações semelhantes


Anúncios Google