Charte pour l'écriture de programmes en Scheme

Cours « Programmation récursive »
Cycle L d'informatique -- LI101
Université Pierre et Marie Curie

Revision: 1.50

Ce document précise comment présenter les programmes à écrire lors des travaux sur machine encadrés (TME) associés au cours « processus d'évaluation ». Ces programmes sont à remettre électroniquement en fin de chaque séance de TME et participent à la note de contrôle continu.

La méthode d'envoi de ces programmes, sous la forme d'un compte-rendu de TME, est détaillée plus bas.

Les règles de présentation ici décrites sont sous-tendues par des principes plus généraux qui se retrouvent dans tous les autres contextes de programmation de licence d'informatique quoique, bien sûr, chaque fois adaptés au génie des langages de programmation employés. Les règles particulières de ce document ne visent qu'à organiser les TME de licence du 1er semestre de 1ère année de l'UPMC et à optimiser la bonne appréciation de votre travail.

1 Présentation des programmes

Les programmes sont écrits dans un langage de programmation et comme tels se doivent de respecter les usages de ce langage. Le cours utilise Scheme comme langage de programmation et, plus particulièrement, DrScheme comme environnement de développement de ces programmes.

À chaque séance de TME, vous aurez à constituer un fichier (nommé par exemple tpi.scm) dans lequel vous écrirez tous les programmes demandés à cette séance de TME.

À chaque exercice de TME est associé un programme qui est composé de commentaires, de fonctions et de tests.

Chaque programme sera présenté suivant les normes classiques (voir la carte de référence de Scheme et les exemples ci-après).

renfoncement gauche

Les programmes sont présentés avec les bons alignements afin de permettre une lecture et relecture aisées. [Il existe une commande dans le menu Scheme / Reindent all pour ce faire. De plus, le curseur se positionne exactement là où il faut écrire quand on passe à la ligne (et si ce n'est pas là où vous l'escomptiez c'est qu'il y a une erreur avant), la touche de TABulation permet de renfoncer correctement la ligne courante.]
passage à la ligne pour les paramètres des formes spéciales (if, cond, begin, let, let*).
commentaires

Les commentaires sont préfixés par des points-virgules dont le nombre indique la portée du commentaire.
blancs et passages à la ligne Ne pas mettre de blanc entre une parenthèse ouvrante et le premier mot d'une liste. Ne pas passer à la ligne quand on ferme une parenthèse (les parenthèses fermantes ne se lisent pas, on les tape mais on ne les regarde jamais, les renfoncements gauches (ou indentations en jargon) suffisent à appréhender la structure des programmes. Ne pas non plus écrire une définition sur une seule ligne même si la définition est très courte!
etc.

Chaque programme sera suivi de ses tests. Ces tests seront exécutables et se présenteront sous la forme d'une expression (verifier fonction ...) où fonction est le nom de la fonction qui est testée. Dans le cas où l'on vous demande plusieurs fonctions en même temps, ce groupe de fonctions porte un nom, visible dans le menu associé au bouton « Tester » et c'est ce nom qu'il faut utiliser après verifier.

Les tests généraux de bon emploi seront complétés de tests aux limites (sur la liste vide, sur zéro, etc.) Les tests pourront utiliser (cf. carte de références pour plus de détails):

la fonction erreur pour signaler plus précisément la raison de l'échec. Cette dernière prend comme premier argument le nom de la fonction erronée suivie d'une chaîne de caractères précisant la nature de l'erreur.
la fonction erreur? qui prend une fonction et ses arguments et renvoie vrai si l'application de cette fonction sur ses arguments conduit à une erreur.
la forme spéciale verifier qui prend le nom d'une fonction suivie d'une suite d'expressions de tests.

1.1 Un exemple commenté

Ce qui suit n'est qu'un exemple! La version HTML de cet exemple possède des annotations que votre souris peut dévoiler si elle se faufile au-dessus de ces zones sensibles.

;;; Exercice 1: la factorielle

;;; fact: nat -> nat
;;; (fact n) calcule la factorielle de n.

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

;;; Les tests associés à la factorielle.

(verifier fact
  (fact 1) == 1
  (fact 2) == 2
  (fact 4) == 24 )

;;; DIFFICULTÉS RENCONTRÉES
;;; écrire - n et non -n
;;; écrire (- n 1) et non (- 1 n) ni (-1 n)

;;; Exercice 2: l'itérateur map

;;; map: (alpha -> beta) * LISTE[alpha] -> LISTE[beta]
;;; (map f l) rend la liste dont les termes sont les images
;;; par f des termes de la liste l.

(define (map f liste)
  ;; reduce: (alpha * beta -> beta) * beta * LISTE[alpha] -> beta
  ;; reduce(f, fin, l) = f(e1, f(e2, ... f(en, fin) ...)) avec l = (e1 e2 ... en)
  (define (reduce f fin liste)
    (if (pair? liste)
        (f (car liste)                   ; f est binaire
           (reduce f fin (cdr liste)) )
        fin ) )
  ;; composer: alpha * LISTE[beta] -> LISTE[beta]
  ;; (composer e r) ajoute l'image de e par f à r
  (define (composer element resultat)
    (cons (f element) resultat) )
  (reduce composer '() liste) )

;;; Tests.

;;; identite: alpha -> alpha
;;; la fonction identité
(define (identite x)
  x )

(verifier map
  (map identite '(a b c d)) == (append '(a b) '(c d))
  (map car '((a 1)(b 2)(c 3)(d 4))) == (list 'a 'b 'c 'd) )

2 Divers

Ce document existe en version PDF (ce qui s'imprime mieux).

Vous devez, pour tous les cours, TD ou TME ainsi qu'aux examens, porter sur vous la carte de référence de Scheme.

Si vous avez des questions ou des remarques sur ce document, faites-le nous savoir . Merci!

Ce document a été traduit de L^AT_EX par H^EV^EA.