Scheme

**Scheme** (aŭ **Skimo**) estas la funkcia programlingvo, kreita de *Guy L. Steele* kaj *Gerald G. Sussman* je 1975, unu el du la plej popularaj dialektoj de Lisp (la alia populara Lispa dialekto estas Common Lisp). Ĝia baza ideo estas minimumeco. Anstataŭ amasigi trajtojn unu post la alia, **Scheme** provizas kiel eble malmulte primitivajn nociojn, sed ebligas facile efektivigi ĉion super ili.

## Mallonga priskribo de trajtoj 
* Treege minimuma sintakso kompare al aliaj programlingvoj.
* Precipe funkcia stilo de programado (t.&nbsp;e. "funkcioj vokas funkciojn" sen deviga tempa ordo de komputo), sed ordonema stilo (kiam "agoj sekvas agojn" en strikta tempa ordo) ankaŭ uzeblas.
* Listo estas la precipa datuma strukturo (kiel en ĉiu Lispa dialekto).
* Unua membro de listo estas normale la nomo de funkcio aŭ operatoro - tial **Scheme** bezonas neniujn regulojn por operatora prioritato.
* Efike realigitaj tabeloj (angle - "arrays").
* Statikaj, t.e. blokaj, regionoj de nomoj (tradicie Lisp havis dinamikajn regionojn).
* Unu spaco de nomoj por variabloj kaj funkcioj (Common Lisp havas du apartajn spacojn).
* Sekuraj "higienaj" makrooj (kvankam malpli potencaj ol la danĝeraj makrooj de Common Lisp).
* Realigado de "vosta rekursio" kiel iteracio sur interna malalta nivelo.
* Rekta, senpera subtenado de daŭrigoj (angle - "continuations") : programisto havas plenan regon pri ili.
* Plena subtenado de "leksike regionigitaj fermoj" (angle - "closures") - fakte, ĉiu funkcio estas ankaŭ la fermo.
* Aŭtomata senrubigo (vakigo de neuzata memoro).

## Ekzemploj 
### Simplaj matematikaj operacioj 
```scheme
(+ 2 (* 2 2))
(+ 1 2 3 4)
```

Voko al operacio estas prezentita kiel listo, komenciĝanta per la signo de la operacio.

### Predikatoj de tipo 
```scheme
(number? 5)
(number? "foo")
(string? "foo")
```

Laŭ la konvencio, la nomoj de predikataj funkcioj devas finiĝi per simbolo ?.

### Predikatoj de egaleco 
```scheme
(eq? "foo" "bar")
(eq? 5 (+ 2 3))
(eq? (eq? 2 3) (eq? 3 4))
```
En Scheme, ekzistas multaj predikatoj de egaleco, kies sencoj diferenciĝas : `eq?`, `eqv?`, `equal?` kaj `=`.

### Difino de funkcio 
```scheme
(define fact (lambda (x)
    (if (= x 1)
        1
        (* x (fact (- x 1))))))

(define fib (lambda (n)
    (cond ((= n 0) 0)
   ((= n 1) 1)
   (else (+ (fib (- n 1))
                   (fib (- n 2)))))))

(define sum (lambda (x)
    (cond ((null? x) 0)
   (else (+ (car x) (sum (cdr x)))))))

(fact 14)
(fib 10)
(sum '(6 6 6 100))
(sum (map fib '(1 2 3 4)))
```

Oni konstruas difinon de ĉiu funkcio laŭ jena modelo:

(define nomo-de-funkcio (lambda (listo de argumentoj) (realigado de funkcio)))

aŭ

(define (nomo-de-funkcio listo de argumentoj) (realigado de funkcio))

### Enigo/Eligo 
```scheme
(display "Saluton, mondo!") ; Eligu la frazon "Hello, World!"
(display (+ (read) (read))) ; Enigu 2 nombrojn, adiciu ilin kaj eligu sumon
```

## Vidu ankaŭ 
* LISP (programlingvo)

## Eksteraj ligiloj 
* Granda kolekto de informoj pri Skemo
* Skemo Petas por Realigo (SRFI)
* Guile - Oficiala programlingvo por etendaĵoj de GNU
* Kawa - JVM bazita Skemo.
* Reviziita5 Raporto pri la Algoritma Lingva Skemo
* Reviziita6 Raporto pri la Algoritma Lingva Skemo 

Kategorio:Funkciaj programlingvoj