Scheme

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Scheme
Lambda lc.svg
Paradigma Multiparadigma: funcional e procedural
Surgido em 1975
Última versão R6RS (2007)
Criado por Gerald Jay Sussman e Guy L. Steele, Jr.
Estilo de tipagem: dinâmica, forte
Compiladores MIT/GNU Scheme, Chez Scheme, SCM, GNU Guile, Ypsilon, PLT Scheme
Dialetos: T
Influenciada por ALGOL, Lisp, MDL
Influenciou Common Lisp, EuLisp, JavaScript, R, Ruby, Dylan, Lua, Hop, Racket
Página oficial www.scheme-reports.org

Scheme é uma linguagem de programação multiparadigma que suporta programação funcional e procedural. Foi criada por Guy L. Steele e Gerald Jay Sussman no outono de 1975, a partir da linguagem Lisp com o intuito de estudar a teoria dos atores de Carl Hewitt. O modelo de Hewitt era orientado a objeto (e influenciado pelo Smalltalk). Os objetos eram chamados atores e as mensagens eram também atores. Sussman e Steele tiveram algum problema no entender algumas das conseqüências do modelo a partir dos artigos de Hewitt e decidiram construir uma implementação de brinquedo de uma linguagem de atores visando experimentá-la. Escreveram um pequeno interpretador Lisp e adicionaram os mecanismos necessários para a criação de atores e envio de mensagens[1] . Existem dois padrões que definem a linguagem Scheme: o padrão oficial IEEE e um padrão popular chamado "Revisedn Report on the Algorithmic Language Scheme", abreviado como RnRS, onde n é o número de revisões.

Características[editar | editar código-fonte]

Scheme adota uma filosofia minimalista, assim sendo, provê o mínimo de noções possíveis, e, na prática, qualquer outra noção pode ser adicionada via bibliotecas, como todos os dialetos do Lisp, possui pouca sintaxe comparado à maioria das outras linguagens. Devido à sua sintaxe completamete aninhada, não existem regras de precedência de operadores e sua notação parentizada é usada para todas as chamadas de função, desta forma não há ambigüidades como as que são encontradas nas linguagens de notação infixa. Porém em procedimentos que existam muitos fatores a serem abordados, o programa pode ficar visualmente confuso e necessita ser analisado com mais cuidado.

Exemplos:

(5+3)   seria assim:  (+ 5 3)
(5+3)*2 seria assim:  (* (+ 5 3) 2)
(8/2)   seria assim:  (/ 8 2)

Exemplo de um procedimento composto:

((lambda (x) (+ x x)) (* 3 4))

neste caso:

3*4 = 12;
x = 12;
x + x = 12 + 12 = 24;

Algumas notações da Linguagem[editar | editar código-fonte]

  • . + -: são usados em números e podem ocorrer em qualquer lugar, exceto como primeiro caracter
  • (): parenteses são utilizados para agrupar e listas de dados
  • ,: sozinho, é utilizado para indicar dados literais
  • `: serve para indicar quase todos dados constantes
  • ": delimitador de strings
  • #t #f: constantes boleanas
  • #\: serve para introduzir um caracter constante
  • #e #i #o #d #x: utilizados na notação de números

Exemplos de código em Scheme[editar | editar código-fonte]

Programa Olá Mundo[editar | editar código-fonte]

(define ola-mundo
  (lambda ()
    (display "Olá, Mundo!") 
    (newline)))
(ola-mundo)

ou, simplesmente:

(display "Olá, Mundo!")

Condicionais[editar | editar código-fonte]

(if (teste) (consequencia) (alternativa)) syntax
(if (teste) (consequencia)) syntax

Syntax: (Teste), (consequencia), e (alternativa) podem ser expressões arbitrárias.

Semantica: uma expressão if é validada da sequinte forma: primeiro (teste) é avaliado, se for verdadeiro, então (consequencia) é avaliado e seu valor é retornado. Caso contrário (alternativa) é avaliado e seu valor é retornado. Se o teste não possui (alternativa) especificado, então o resultado da expressão não é especificado.

(if (> 3 2) 'yes 'no)  --> yes
(if (> 2 3) 'yes 'no)  --> no
(if (> 3 2)
(- 3 2)
(+ 3 2)) --> 1

Recursividade[editar | editar código-fonte]

Cálculo do fatorial de um número:

(define (fatorial n)
  (cond ((= n 0)  1)
    (else (* n (fatorial (- n 1))))))
 
(fatorial 5)
;; => 120

Números Perfeitos[editar | editar código-fonte]

Exemplo de programa que mostra os n primeiros números perfeitos:

 (define inverteListax
  (lambda (lista1 lista2)
    (if (null? lista1) lista2
        (inverteListax (cdr lista1) (cons (car lista1) lista2)))))
 
 (define inverteLista
   (lambda (lista)
     (inverteListax lista '())))
 
 (define (perf n)
    (let loop ((i 1)
                (sum 0))
       (cond ((= i n)
              (= sum n))
             (
                (= 0 (modulo n i))
                (loop (+ i 1) (+ sum i)))
             (else
              (loop (+ i 1) sum)))))
 
 (define aux
   (lambda (x n l)
     (if (= x 0) l
         (if (perf n) (aux (- x 1) (+ n 1) (cons n l))
                      (aux x (+ n 1) l)))))
 
 (define main
   (lambda (x)
     (aux x 1 '())))
 
 (define perfeitos
   (lambda (n)
     (inverteLista (main n))))

Compiladores[editar | editar código-fonte]

Alguns compiladores de Scheme:

  • Bigloo
  • Chez Scheme
  • Chicken
  • Gambit
  • Gauche
  • Guile
  • Ikarus
  • JScheme
  • Kawa
  • Larceny
  • MIT/GNU Scheme
  • Mosh
  • PLT Scheme
  • Pvts
  • RScheme
  • Scheme 48
  • SCM
  • SISC
  • Stalin
  • STk
  • STklos
  • TinyScheme
  • Ypsilon

Referências

  1. BERGIN, Thomas J.; GIBSON, Richard G.. History of Programming Languages II. New York: ACM Press, Addison-Wesley, 1996. 864 p. ISBN 0-201-89502-1

Bibliografia[editar | editar código-fonte]

  • DYBVIG, R. Kent. The Scheme Programming Language: Ansi Scheme. New Jersey: Prentice Hall PTR, 1996. ISBN 0-13-454646-6
  • ABELSON, Harold; SUSSMAN, Gerald Jay; SUSSMAN Julie. Structure and Interpretation of Computer Programs. New York: McGraw-Hill, 1996. ISBN 0-07-000484-6

Ver também[editar | editar código-fonte]

Ligações externas[editar | editar código-fonte]

Ícone de esboço Este artigo sobre programação de computadores é um esboço. Você pode ajudar a Wikipédia expandindo-o.