Profondeur de champ
Programmation Scheme/Grammaire de base
La base de la programmation Scheme est la définition de procédures.
Une procédure de base est de la forme
 ("opération_primitive" "expression1" "expression2" … "expression_n")
où "opération_primitive" est une procédure prédéfinie. À la place d'une opération primitive, on peut aussi utiliser une procédure définie préalablement.
Les arguments de la procédures sont écrits les uns à la suite des autres, séparés par un ou plusieurs espaces, voire même des sauts de ligne. Ce sont des expressions qui peuvent être des constantes, des variables ou elles-mêmes des procédures.
Quelques opérations primitives.
Pour quitter l'interpréteur Scheme, il faut taper codice_1.
Opérations sur les nombres.
On remarque de fait que Scheme utilise la notation préfixée (parfois appelée « notation polonaise », bien que celle-ci soit sans parenthèse). Par exemple, l'expression infixée « 1+2+3 » donne, en notation préfixée, « (+ 1 2 3) ».
Notons également que codice_17 désigne la fraction formelle ; pour effectuer l'opération, il faut écrire codice_18 (le résultat étant… codice_17).
Opérations sur les listes.
 (cons 'a '(b))
 "⇒ (a b)"
 (list 'a 'b)
 "⇒ (a b)"
 (car '(a b))
 "⇒ a"
 (cdr '(a b))
 "⇒ (b)"
Si l'on utilise codice_25 et que le deuxième élément n'est pas une liste, cela crée alors une « liste pointée »
 (cons 'a 'b)
 "⇒ (a . b)"
 (cons 'a '(b))
 "⇒ (a b)"
 (cons '(a) 'b)
 "⇒ ((a) . b)"
En fait, codice_25 construit des paires (cf "infra"), et le second élément de la paire n'est pas nécessairement une liste.
L'opération codice_23 sur liste pointée renvoit l'élément à la gauche du point, codice_24 renvoit l'élément à la droite du point.
Opérations sur les variables.
Pour mettre une expression "expr" dans une variable "var", on utilise codice_31 :
 (define "var" "expr")
en notation « infixée », cela revient à écrire « "var" = "expr" ».
Soit une expression "expr" contenant des variables "var1", "var2", … , "var_n". Pour mettre cette expression dans une variable "fct" et en faire une fonction, on utilise aussi codice_31 :
 (define ("fct" "var1" … "var_n") "expr")
Cela revient à écrire, en notation infixée :
Pour l'évaluer en attribuant des valeurs constantes "cst1", "cst2", …, "cst_n" à ces variables (c'est-à-dire en notation infixée calculer "fct"("cst1", "cst2", …, "cst_n")), on écrit :
 ("fct" "cst1" … "cst_n")
Structures de contrôle.
Exécution conditionnelle.
L'exécution conditionnelle se fait avec l'opération primitive codice_33. Dans l'expression
alors l'expression "expr" est éxecutée si "booléen" est vrai (codice_35), elle n'est pas exécutée sinon. Ainsi
 (if #t '(a))
 "⇒ (a)"
 (if #f '(a))
Si l'on met deux expressions codice_36, alors "expr1" est évaluée si "booléen" est vrai et "expr2" est évaluée si "booléen" est faux — cela équivaut, en langage infixé, à « codice_37 ». Ainsi
 (if #t '(a) '(b))
 "⇒ (a)"
 (if #f '(a) '(b))
 "⇒ (b)"
Bien sûr, tel quel, cela ne présente d'intérêt que si "booléen" est une expression dont l'évaluation donne un booléen. Les opérations primitives donnant des booléens sont appelées « prédicats » (voir ci-après).
On peut aussi utiliser l'opération perimitive codice_38 ; celle-ci admet plusieurs booléens :
 (cond
 ("booléen1" "expr1")
 ("booléen2" "expr2")
 ("booléen_n" "expr_n")
 (else "expr_sinon"))
L'expression "expr1" est évaluée si "booléen1" est codice_35, "expr2" est évaluée si "booléen2" est codice_35, …, "expr_n" est évaluée si "booléen_n" est codice_35 . C'est l'équivalent du "« case of »" de certains langages. La dernière expression, introduite par codice_42, est évaluée si toutes les autres sont fausses ; elle est optionnelle.
Prédicats.
Les principaux prédicats sont :
Par ailleurs, on dispose des opérateurs logiques classiques codice_55 ("ou" logique), codice_56 ("et" logique), codice_57 ("non" logique).
Boucle.
Scheme ne possède pas de structure de boucle. Le problème est traité par la récursivité (voir plus loin).
Il existe toutefois un opérateur codice_58 qui applique une fonction successivement à une liste d'arguments.
 scheme> (map sqrt '(1 2 3 4 5))
 "⇒ (1 1.4142135623730951 1.7320508075688772 2 2.23606797749979)
Exemples.
 scheme> (+ 1 2 3 4)
 "⇒ 10"
 scheme> (- 1 2 3)
 "⇒ -4"
 scheme> (/ 1 2 3)
 "⇒ 1/6"
 scheme> (+ 1 (* 2 2))
 "⇒ 5"
 scheme> (expt (cos (/ 3.1416 2)) 2)
 "⇒ 0.4999981633974483"
 '(1 2 3 4) / (quote (1 2 3 4))
 (list 1 2 3 4)
 (cons 1 (cons 2 (cons 3 (cons 4 ()))))
 scheme> (define (double x) (* 2 x))
 scheme> (double 3)
 "⇒ 6"
Paires et listes.
Si l'on représente les paires comme des boîtes à deux cases, alors on a les équivalences suivantes entre listes et paires :
On voit que la liste codice_60 est en fait une paire de paires.
Si on représente les paires comme les nœuds d'un arbre, on a la représentation suivante.
 scheme>'(a . ())
 "⇒(a)"
 scheme>'(a . (b . ()))
 "⇒(a b)"
À l'origine, le Lisp a été écrit pour les IBM 704. Une paire était alors représentée par deux valeurs : une adresse et une partie décrémentale, d'où les acronymes :
Notez que codice_23 se prononce tel quel (à l'anglaise) et que codice_24 se prononce approximativement « cadeur » ou « coudeur » ( ou ). Dans le jargon du MIT, on utilise le verbe "to cdr down" dans le sens « examiner les éléments d'une liste un par un » (codice_25 a quant à lui donné le verbe "to cons up").
Les opérateurs codice_23 et codice_24 peuvent être composés :
 scheme> (caar '((1 2) 3))
 "⇒ 1"
 scheme> (cddr '(1 2 3))
 "⇒ (3)"
 scheme> (cadr '(1 2 3))
 "⇒ 2"
 scheme> (cdar '((1 2) 3))
 "⇒ (2)"
Importance de la grammaire.
Le Lisp, dont est dérivé Scheme, a été conçu essentiellement en tant que formalisme, dans le sens : représentation formelle et systématique des données et instructions. À l'inverse de nombreux langages qui proposent de nombreuses instructions avec pour chaque une syntaxe adaptée à leur utilisation, Lisp et Scheme proposent une grammaire, une manière systématique de représenter les données et les instructions, sous forme d'expressions symboliques ou « S-expressions ».
Cela en a fait un outil de choix pour le travail sur l'intelligence artificielle, puisque l'on s'intéresse là à la possibilité d'apprentissage, au développement de nouvelles fonctionnalité plus qu'à un "corpus" préétabli d'instructions.
Si l'on résume la grammaire, on a :
Le tableau ci-dessous, inspiré de indique des exemples de syntaxe ; les exemples sont séparés par un tube « | ».

Photographie/Fabricants/Olympus/Olympus SP-510 UZ

Olympus
Photographie/Fabricants/Panasonic/Panasonic Lumix DMC-LX2

Photographie/Fabricants/Hewlett-Packard/Hewlett-Packard Photosmart E327

Histoire de l'Europe/Glossaire
Ce glossaire a pour but de donner une brève explication pour chaque notion, personne, lieu ou événement important dans l'histoire de l'Europe, ainsi que de renvoyer vers la partie correspondante dans le wikilivre.

Histoire de l'Europe/Glossaire/A
= Ab =
Histoire de l'Europe/Glossaire/C
=Ca=
= Co =

Histoire de l'Europe/Glossaire/N
=Na=
Histoire de l'Europe/Glossaire/L
=Lu=
Histoire de l'Europe/Glossaire/R
=Re=
= Ro =

Histoire de l'Europe/Glossaire/P
=Po=
= Pr =

Photographie/Fabricants/Leica/Leica C-LUX 1

Commentaires.
Construit sur une base Panasonic mais avec un traitement d'images Leica

Photographie/Fabricants/Leica/Leica V-LUX 1

Commentaires.
Appareil conçu à partir du Panasonic DMC-FZ50

Matsushita
Photographie/Fabricants/Sony/Sony Cyber-shot DSC-F717

Néerlandais/Dans le secondaire/les pays
Il faut bien sûr adapter cette liste en fonction du niveau et des nationalités des élèves. Il faudra bien sûr ne pas demander aux élèves de retenir le nom de tout les pays du monde.

Néerlandais/Avancé/Se présenter
Néerlandais/Dans le secondaire/les langues

Langues.
En néerlandais les langues sont toujours "des mots neutres": "het" Nederlands, "het" Frans etc.

Néerlandais/Dans le secondaire/Exercices/les pays et les langues