Cet article fait partie de la série Langages de programmation

Langages à objets

4D - C++ - C# - D Delphi - Eiffel - Groovy Java - Python - Ruby Simula - Smalltalk Visual Basic - WinDev

Langages impératifs

APL - ASP - Assembleur BASIC - C - Cobol Forth - Fortran - Limbo Logo - Pascal - Perl - PHP

Langages fonctionnels

Haskell - ML/OCaml Lisp/Common Lisp Scheme XSLT

Langages déclaratifs

Clips - Prolog

Langages concurrents

Ada 95 - Erlang

Langage de balisage

HTML - SGML - XML S-expressions

Voir aussi

Conception - Codage Tests - Optimisations

Scheme (prononcer « skim' ») est un langage de programmation dérivé du langage fonctionnel Lisp, créé dans les années 1970 au MIT par Gerald Jay Sussman et Guy L. Steele.

Le but des créateurs du langage était d'épurer le langage Lisp en conservant les aspects essentiels, la flexibilité et la puissance expressive. Scheme a donc une syntaxe extrêmement simple, avec un nombre très limité de mots-clé. Comme en Lisp, la notation préfixée permet de s'affranchir des opérateurs de précédence. De plus, la puissance des macros de Scheme lui permet de s'adapter à n'importe quel problème, notamment de le rendre orienté objet et donc multi-paradigme.

La spécification de Scheme précise que tous les produits doivent optimiser le cas de la récursion terminale.

Les types de données de base de Scheme sont les booléens, les nombres, qui peuvent être entiers de taille indéfinie, rationnels ou complexes, les caractères ou les symboles, qui sont des variables.

À ceux-là s'ajoutent des types de données composites suivants : chaînes de caractères, vecteurs, paires orientées, listes, listes associatives, tables de hachage et un type particulier générique, la S-expression, dont tous les autres types dérivent, rendant possible la méta-programmation, c'est-à-dire la possibilité d'étendre le langage avec de nouveaux opérateurs spéciaux.

Exemples de code

Les variables sont typées dynamiquement et leur portée est lexicale :

(define var1 value)

 (let ((var2 value))
   ...)

Listes :

 (cons 1 (cons 2 (cons 3 (cons 4 '()))))

Cette concaténation peut être abrégée en

 (list 1 2 3 4)

ou en

 '(1 2 3 4)

Fonctions : elles sont définies comme des lambda-expressions

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

ou plus simplement

 (define (fun arg1 arg2)
   ...)

Application à une liste :

 (apply fun (list value1 value2))

Evaluations conditionnelles :

 (cond (test1 expr1)
       (test2 expr2)
       ...
       (else exprn))

et aussi

 (if condition
       then-expr
       else-expr)

Exemple 1 - calcul d'une factorielle :

 (define (factorial n)
   (if (= n 0)
       1
       (* n (factorial (- n 1)))))

 (factorial 5)
 ;; => 120

Exemple 2 - définition d'une fonction map, qui applique une lambda-expression (qui élève son argument au carré) à tous les éléments d'une liste:

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

Versions tail-récursives des deux exemples précédents :

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

Mises en œuvre

Scheme est, avec Common Lisp, le Lisp le plus populaire. Le langage est défini par le document R5RS.

Les principaux produits Scheme sont:

• Chez Scheme, un interpréteur Scheme gratuit et compilateur commercial pour Microsoft Windows et plusieurs systèmes Unix
• Chicken est compilateur Scheme-vers-C.
• Guile est le langage d'extension du projet GNU. L'interpréteur Scheme est une bibliothèque qui peut servir comme langage de script pour des applications.
• PLT Scheme, une suite de programmes incluant un interpréteur (MzScheme), un outil de développement graphique(MrEd), un éditeur orienté pédagogie (DrScheme), et divers composants incluant des bibliothèques Component object model (COM) et ODBC.
• Scsh ou Scheme Shell est un produit R5RS utilisable comme langage de script système et interpréteur de commandes.
• Gauche est un produit R5RS multilingue sous licence BSD, pour programmeurs et administrateurs systèmes.
• Bigloo est un compilateur Scheme-vers-C et Scheme-vers-Java qui produit des exécutables compacts et rapides, doté d'un nombre relativement important de bibliothèques.
• STklos est un produit libre du langage Scheme de l'Université de Nice qui est légère et efficace.
• Le logiciel de retouche d'images Gimp inclut un interpréteur Scheme pour scripter (appelé script-fu) certaines manipulations d'image.
• D'autres produits se trouvent sur la schemers.org FAQ

Liens externes

• Une collection de ressources.
• Scheme Requests for Implementation (SRFI)
• « Structure and Interpretation of Computer Programs » Abelson et Sussman. Un cours d'exceptionnelle qualité, avec vidéo en ligne[1]. Ce livre dépasse le cadre de l'enseignement du langage, et enseigne les fondements des langages de programmation. Sert de support de cours depuis de nombreuses années au MIT.
• How to Design Programs. Autre cours de Scheme.
• Teach Yourself Scheme. Un autre cours, destiné aux débutants.
• The Scheme Programming Language écrit par R. Kent Dybvig.
• Une bibliothèque d'articles de recherche donne des liens vers les articles originaux qui ont donné naissance au langage.
• Cours de Scheme Quelques cours de scheme basés sur les cours donnés en 1ere année de deug mias
• Cours de scheme en video par Abelson & Sussman du MIT
• Un forum en français sur Scheme

Cet article est une ébauche à compléter concernant l'éducation, vous pouvez partager vos connaissances en le modifiant.

Un Schème est le "squelette" d'une action dans les écrits du psychologue suisse Jean Piaget. Il peut être considéré comme une structure qui se transforme au fur et à mesure qu'elle s'adapte à des situations et données variées.

Le schème d'une action est l'ensemble structuré des caractères généralisables de l'action, c'est à dire qui permettent de répéter la même action ou de l'appliquer à de nouveaux contenus^[1]. Par exemple, le schème de réunions (l'enfant rassemble des cubes/classe les gommettes...)

D’après Kant, les schèmes sont des représentations mentales qui jouent le rôle d’intermédiaire entre les catégories de l’entendement et les phénomènes sensibles.

Notes et références