Programmation Scheme/Notions élémentaires

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche


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[modifier | modifier le wikicode]

Spécifier[modifier | modifier le wikicode]

Pour résoudre un problème on devra d’abord spécifier les informations qui entreront en jeu dans sa résolution, à savoir :

  1. Les données, celles qui sont fournies avant l'exécution du programme et qui serviront de base aux calculs.
  2. Les résultats que renverront ces calculs.
  3. Les relations qui lient ces données avec les résultats.

Désigner[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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.

(...) ;Un commentaire sur une ligne
(...) ;Un autre
(...) ;sur trois
(...) ;lignes.

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 :

(+ 7 9)

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 :

(> 1 5)

Va renvoyer #f (faux), car 1 n’est pas plus grand que 5.

La différence peut s'exprimer avec le not :

(not (= 5 13))

Va renvoyer vrai car 5 est différent de 13.

Les booléens[modifier | modifier le wikicode]

  • 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 :

(not(and a b))=(or((not a)(not b))

et

(not (or a b))=(and(not a)(not b))

Les caractères[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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