# Programmation Scheme/Notions élémentaires

* Introduction
* Notions élémentaires
* Syntaxe de base
* Grammaire de base
* La boucle d'évaluation
* Variables globales et variables locales
* Récursivité
* Introduction
* Notions élémentaires
* Syntaxe de base
* Grammaire de base
* La boucle d'évaluation
* Variables globales et variables locales
* Récursivité
[ Modifier le sommaire ]
Scheme est un langage de programmation fonctionnelle qui procède de façon algorithmique, c'est-à-dire qu’il établit une méthode propre à la résolution d'un problème en détaillant les étapes de calcul. L'intérêt étant de le rendre utilisable pour toute donnée considérée.

## Expressions élémentaires
### Spécifier

Pour résoudre un problème on devra d’abord spécifier les informations qui entreront en jeu dans sa résolution, à savoir :
* Les données, celles qui sont fournies avant l'exécution du programme et qui serviront de base aux calculs.
* Les résultats que renverront ces calculs.
* Les relations qui lient ces données avec les résultats.

### Désigner

Pour pouvoir faire référence dans le programme à une information ou une valeur prédéfinie on lui attribuera d’abord un nom, généralement en utilisant des lettre (x, y, z...) ou un mot permettant à l'utilisateur de comprendre facilement à quoi il renvoie.

### Typer

Toute information peut être aussi caractérisée par un type, à savoir un domaine de valeur (Z, N, R...) associé à un ensemble d'opérations possibles sur ce domaine (+, -, /...). L'un des intérêt de Scheme est d’être "dynamiquement typé", c'est-à-dire que l'interpréteur n'exigera pas que l’on fournisse le type de chaque information (contrairement à Java par exemple), mais il le "déduira" lui-même au moment de l'exécution selon les opérations effectuées.
* Exemple de définition
* (define n 1) ; n va prendre la valeur 1.

## Notation élémentaire

Tout d’abord le " ; ", il permet d'insérer les commentaires dans un programme : toute la ligne sur la droite ne sera pas considérée par le compilateur, mais il en faut un à chaque ligne.
Scheme utilise la notation préfixée, c'est-à-dire que les opérateurs sont placés devant les opérandes correspondants. Par exemple pour écrire 7+9, en Scheme on écrira :
Les différents opérateurs sont : +, -, *, quotient (division entière), remainder (reste) La comparaison peut se faire avec >, >=, <, <= et =. Ces opérations renverront des booléens, par exemple :
Va renvoyer #f (faux), car 1 n’est pas plus grand que 5.
La différence peut s'exprimer avec le not :
Va renvoyer vrai car 5 est différent de 13.

## Les booléens

* Notation :
Un booléen appartient au domaine B et ne peut prendre que deux valeurs:
Vrai : #t ; (true) Faux : #f ; (false)
* Opérations :
Il est possible d’utiliser les opérateur logiques : and, or et not (et, ou et non).
Ex : On peut exprimer la dualité De Morgan en Scheme, pour rappel ¬(a . b) = ¬a ∨ ¬b et ¬(a ∨ b) = ¬a . ¬b) :
Ce qui donne :
et

## Les caractères

Les caractères sont définis sur le domaine C (l'ensemble des caractères).
* Notation :
    #\a ; un "a"
    #\A ; un "A"
    #\. ; un point (est aussi un caractère)
    #\space ; un espace
    #\newline ; aller à la ligne
* Opérations possibles :
    char>?, char=>?, char<?, char<=? et char=? est utilisé pour comparer deux caractères d’après leur ordre alphabétique. :L'opération renverra un booléen (#t ou #f) selon si la comparaison demandée est vraie ou fausse.
    Par exemple : (char<? #\f #\g) renverra #t, f est plus petit que g dans l’ordre alphabétique.
    Une variante qui ne tient pas compte de la classe (majuscule ou minuscule) est aussi possible:
    char-ci=?, char-ci<?, char-ci>?, char-ci>=?, char-ci<=? .

## Les chaînes

Domaine C$^*$
* Notation :
    On utilise les "" pour exprimer une chaîne : "Voici une chaîne". Attention "a" n’est pas la même chose que #\a, une chaîne peut contenir un seul caractère.
    Pour utiliser un " dans une chaîne on placera un \ devant : "Voici une \"chaîne\"".
    Et pour utiliser un \ il suffira de placer un autre \ devant : "Voici un \\ dans une chaîne".
* Comparaison de chaînes :
    On utilisera string<?, string>?, string=>?, string=<?, string=?
    L'opération renverra un booléen selon la longueur des deux chaînes considérées.
* Concaténation de chaînes :
    Permet de mettre deux chaînes bout à bout grâce à l'opérateur : string-append.
    La ligne suivante renvoie "abracadabra":
    (string-append "abra" "cadabra")
Introduction < ↑ > Syntaxe de base