Page d'accueil
encyclopedie-enligne.com en page d'accueil| Page d'accueil |
encyclopedie-enligne.com en page d'accueil |
|||||
| Liste Articles: [0-A] [A-C] [C-F] [F-J] [J-M] [M-P] [P-S] [S-Z] | Liste Catégories | Une page au hasard | Pages liées | ||||||
 |
| Cet article fait partie de la série Langages de programmation |
| Langages orientés objet |
| Ada 95 - C++ - C# Common lisp object system Delphi - Eiffel - Java - Nice |
| Langages impératifs |
| APL - ASP Assembleur BASIC - C - Pascal Perl - PHP - Python |
| Langages fonctionnels |
| ML/OCaml
- Lisp/Common Lisp Forth - Logo - Scheme |
| Langages déclaratifs |
| Clips - Prolog |
| Voir aussi |
| Conception - Codage Tests - Optimisations |
Scheme 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 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 permettent 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 toutes les implémentations 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.
A 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 capacité qu'a un programme d'agir sur lui-même.
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)
Scheme est avec Common Lisp le Lisp le plus populaire. Le langage est défini par le document R5RS.
Les principales implémentations en sont:
