Scheme

Article on other languages:

• Scheme
• স্কিম_(প্রোগ্রামিং_ভাষা)
• Scheme
• Scheme
• Scheme
• Scheme
• Scheme_(programming_language)
• Scheme
• Scheme
• اسکیم
• Scheme
• Scheme
• Scheme
• Scheme_(programski_jezik)
• Scheme
• Scheme
• Scheme
• 스킴_(프로그래밍_언어)
• Scheme
• Scheme
• Scheme
• Scheme
• Scheme
• Scheme_(programming_language)
• Scheme_(programovací_jazyk)
• Scheme_(programski_jezik)
• Scheme
• Scheme
• Scheme
• Scheme
• Scheme

	del.icio.us
	Digg
	Furl
	Reddit
	Rojo
	Add to OnlyWire

El llenguatge de programació Scheme és un llenguatge funcional (si bé “impur”, ja que, per exemple, les seves estructures de dades no són immutables) i un dialecte de Lisp. Fou desenvolupat per Guy L. Steele i Gerald Jay Sussman en la década dels setanta e introduït en el món acadèmic a través d'una sèrie d'articles coneguts com el Lambda Papers de Sussman y Steele.

La filosofia de Scheme es decididament minimalista. El se objectiu no es acumular un gran nombre de funcionalitats, sinó d'evitar les debilitats y restriccions que fan necessària la seva addició. Així, Scheme proporciona el mínim nombre possible de nocions primitives, construït la resta en base a aquest reduït nombre d'abstraccions. Per exemple, el mecanisme principal per el control de flux són les crides recursives finals.

Scheme fou el primer dialecte de Lisp que utilitzà àmbit estàtic o lèxic (en lloc de dinàmic) de forma exclusiva. També fou un dels primers llenguatges de programació amb continuacions explícites. Scheme ofereix també gestió automàtica de memòria (recol·lecció de brossa).

Les llistes són la estructura de dades bàsica del llenguatge, que també ofereix “arrays” entre el seus tipus predefinits. degut a la seva especificació minimalista, no hi ha sintaxi explícita per a crear registres o estructures, o per programació orientada a objectes, però moltes implementacions ofereixen les esmentades funcionalitats

Scheme, originalment, s'anomenava “Schemer”, continuant la tradició dels llenguatges Planner i Conniver. El seu nom actual es degut a que els seus autors utilitzaven el sistema operatiu ITS, que limitava la longitud dels noms de fitxers a 6 caràcters

Avantatges d'Scheme

Scheme, com tots els dialectes de Lisp, té una sintaxi molt reduïda, comparada amb la d'altres llenguatges. No necessita regles de precedència, ja que, en essència, no fa servir operadors: utilitza notació prefixa per a totes les crides a funció.

Les macros d'Scheme permeten adaptar-lo a qualsevol domini. Poden ser utilitzades, per exemple per afegir suport a la programació orientada a objectes. Scheme proporciona un sistema de macros “higiènic” que, encara que no tant potent com el de Common Lisp, és molt més segur i, amb freqüència, senzill d'utilitzar. La avantatge d'un sistema de macros d'aquest tipus ( que també es troba en altres llenguatges com Dylan) és que evita automàticament col·lisions entre els noms utilitzats en la definició de la macro i en el context en aquesta s'expandeix. En contrapartida, les macros higièniques no poden introduir nous símbols.

Scheme facilita la programació funcional. La programació funcional pura. no precisa de variables globals ni pateix de efectes secundaris, i és, per tant, automàticament segura en presència de processos concurrents (thread-safe), a mercè de facilitar considerablement la verificació de programes, al menys en comparació amb el estil imperatiu.

En Scheme, els procediments són objectes de primera classe. Aquest fet permet la definició de funcions d'ordre superior, que faciliten un major grau d'abstracció en els programes. També es possible la creació de procediments anònims.

L'estàndard d'Scheme és també minimalista. Això du a terme avantatges i inconvenients. Per exemple, escriure un compilador o intèrpret de Scheme que sigui fidel al estàndard és més fàcil que implementar un de Common Lisp; Fer servir Lisp en dispositius amb poca memòria serà també més factible si utilitzem Scheme en lloc de Common Lisp. Als afeccionats a Scheme els diverteix molt assenyalar que el seu estàndard, amb només 50 pagines, és més curt que l'index del llibre de Guy Steele Common Lisp: The Language!

Desavantatges d'Scheme

El estàndard de Scheme es realment minimalista, y especifica únicament el llenguatge en si mateix. Aixó provoca l'existència de multitud d'implementacions diferents, cadascuna de les quals introdueix extensions y biblioteques pròpies que les fa incompatibles entre elles. Els Scheme Requests for Implementation (SRFI) tracten de posar remei a aquest problema.

Hi ha gent pressuposa que els procediments i variables comparteixen el mateix espai de nombres com una desavantatge, ja que algunes funcions tenen noms que són d'ús comú per variables. Per exemple, list es el nom d'un procediment, així que es molt habitual veure lst o lyst como noms de variables, en lloc del obvi (per als anglosaxons!) "list".

Com hem dit, l'espai de noms és únic (en gerga tècnica, Scheme és el que es coneix com un LISP-1) i, per això, també inclou a les macros. Això impossibilita distinguir l'ús d'una macro del d'una funció, així que, si no consultem la definició de cadascun dels objectes utilitzats, no serà en general possible determinar l'ordre devaluació en programes amb els que no estiguem familiaritzats.

Estàndards

Existeixen dos estàndards que defineixen el llenguaje de programació Scheme: l'estàndard oficial de la IEEE, i un altre estàndard conegut como Revised^n-th Report on the Algorithmic Language Scheme, quasi sempre abreviat como RnRS, on n es el nombre de la revisió. El últim RnRS es R5RS, i esta displonible en línia.

Elements del llenguatge

Comentaris

Els comentaris s'inicien amb un punt i coma (;) i continuen fins el final de la línia.

Variables

Les variables son dinàmicament tipades. Para associar-les a un valor concret, podem utilitzar define, una expressió let, o alguna de les seves variants. Les variables assignades en el primer nivell utilitzen define estan en àmbit global (es a dir, són visibles en la resta del programa).

 (define var1 value)

Las variables assignades mitjançant let veuen el seu àmbit reduït al cos de l'esmentat let:

 (let ((var1 value))
    ...
    àmbit de var1
    ...)

Procediments

Les funcions o procediments son objectes de primera classe en Scheme. Poden ser assignats a variables. Per exemple, una funció de dos arguments arg1 y arg2 poden definir-se com

 (define fun
   (lambda (arg1 arg2)
      ...))

o en la forma abreviada equivalent:

 (define (fun arg1 arg2)
   ...)

Les crides a funció tenen la sintaxis següent:

 (fun value1 value2)

Como veiem, la funció invocada es troba en primer lloc, seguida dels arguments de la crida, formant una llista. Podem també utilitzar el procediment apply, que pren dos arguments: el primer es el procediment que volem invocar, mentres que el segon es la llista d'arguments. Així, la anterior crida a una funció pot escriure's, de forma equivalent, com

 (apply fun (list value1 value2))

En Scheme, les funciones es divideixen, bàsicament, en dos categories: els procediments definits per l'usuari i les primitives. Les primitives estan predefinides en el llenguatge, i inclouent +, -, *, /, set!, car, cdr, i altres procediments bàsics. Moltes implementacions permeten al usuari redefinir algunes primitives. Por exemple, el següent codi

(define +
  (lambda (x y)
    (- x y)))

converteixen la primitiva + en un procediment definit per l'usuari que resta els seus dos arguments en lloc de sumar-los.

Llistes

Scheme utilitza llistes enllaçades de forma anàloga a altres dialectes de Lisp.

Tipus de dades

Altres tipus de dades en Scheme són els enters, racionals, reals, complexes, símbols, cadenas, y ports, llistes associatives, taules hash, vectors, arrays y estructures.

La majoria d'implementacions proporciona allò que es coneix com una torre numèrica completa, així com aritmètica exacta e inexacta.

Els valors booleans es representen mitjançant els símbols #t y #f. En realitat, qualsevol valor distint de #f (incloent la llista buida) s'interpreta com 'vertader' en un context adequat, mentres que en altres dialectes de Lisp la llista buida es interpretada com el valor booleà fals.

Els símbols poden ser definits de varies maneres, sent

 'symbol
 (string->symbol "symbol")

les mes comunes.

Igualtat

Schemem té tres tipus diferents d'igualtat:

eq? 

Retorna #t si els dos objectes son exactament el mateix objecte, comprovant també on estan emmagatzemats físicament.

eqv? 

Normalment igual que eq?, però tracta alguns objectes (per exemplo, caràcters y nombres) de forma especial per que els nombres que siguin iguals fossin eqv? encara que fossin eq?.

equal? 

Compara el contingut de les estructures de dades tals com llistes, vectors y cadenes per determinar si són iguals.

Les operadores de equivalència dependents del tipus també existeixen en Scheme:

string=? 

Compara dos cadenes

char=? 

Compara dos caràcters

= 

Compara nombres

Estructures de control

Avaluació condicional

 (cond (prova1 expr1)
       (prova2 expr2)
       ...
       (else exprn))

La primera expressió per la que la prova fos ser certa (qualsevol cosa excepte #f es pres com cert) serà avaluada. Si totes les prove resulten ser #f, s'avalua la clàusula else.

Una variant de la clàusula cond és

 (cond ...
       (test => expr)
       ...)

En aquest cas, expr ha de resultar en una funció que pren un solo argument. Si test resulta ser cirt, es crida a la funció anterior amb el valor retornat per test.

Scheme també té

 (if test then-expr else-expr)

però s'utilitza molt menys porque cond es més general y normalment resulta més llegible.

Bucles

Els bucles en Scheme solen prendre la forma d'una recursió final. Un exemple clàssic és la funció factorial, que pot definir-se sense recursió final como:

 (define (factorial n)
   (cond ((= n 0) 1)
         (else (* n (factorial (- n 1))))))

 (factorial 5)
 ;; => 120

o una funció d'ordre superior como map, que aplica una funció a cada element de una llista, pot també definir-se sense recursió final de la següent forma:

 (define (map f lst)
   (cond ((null? lst) lst)
         (else (cons (f (car lst))
                     (map f (cdr lst))))))

 (map (lambda (x) (* x x)) '(1 2 3 4))
 ;;  => (1 4 9 16)

Podems definir ambdues fent servir la recursió final como segueix. La expressió let amb nom y la sentència do son sucre sintàctic que simplifica les definicions amb recursió final.

 (define (factorial n)
   (let loop ((fact 1)
              (n n))
     (cond ((= n 0) fact)
           (else (loop (* n fact) (- n 1))))))

 (factorial 5)
 ;; => 120

 (define (map f lst)
   (do ((lst lst (cdr lst))
        (res '() (cons (f (car lst)) res)))
       ((null? lst) (reverse res))))

 (map (lambda (x) (* x x)) '(1 2 3 4))
 ;; => (1 4 9 16)

Fixa't que en ambdós casos es prefereix la versió amb recursió final degut al seu menor ús de espai.

Entrada/sortida

Scheme té el concepte de ports d'on llegir o als que escriure. Scheme defineix tres ports per defecte, accessible amb les funcions current-input-port, current-output-port y current-error-port.

Hola Món

(let ((hola-mon
        (lambda ()
          (display "Hola, món") 
          (newline))))
   (hola-mon))

o, simplement

(display "Hola, món\n")

Exemples

Consultar en:Scheme programming language#Examples.

Implementacions

Consultar en:Scheme programming language#Implementations.

Recursos adicionals

Consultar en:Scheme programming language#Additional_resources.