Scheme

Scheme
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 . Existem dois padrões que definem a linguagem Scheme: o padrão oficial IEEE e um padrão popular chamado "Revisedⁿ Report on the Algorithmic Language Scheme", abreviado como RnRS, onde n é o número de revisões.

Características

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

• . + -: 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

Programa Olá Mundo

Ver artigo principal: Programa Olá Mundo

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

ou, simplesmente:

(display "Olá, Mundo!")

Condicionais

(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

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

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

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

Bibliografia

• 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

• Lisp

Ligações externas

• Página oficial (em inglês)
• Schemers (em inglês) Uma página de referência da linguagem
• TimeLine