Ce fichier contient des corrections  apporter aux livres "Le langage
Caml" et "Manuel de rfrence du langage Caml", par Pierre Weis et
Xavier Leroy, Interditions, 1993.

------------------------ Le langage Caml ------------------------

Page 3, ligne 14: rtablir l'accord:

  ... de ne pas lire, car elles sont compliques et pas indispensables
  pour la suite, ...


Page 50, section "Les tours de Hanoi": une deuxime rgle du jeu
est de ne dplacer qu'un seul disque  la fois.


Page 110, ligne 12: lire:

  ... transfre nombre_de_caractres__transfrer dans ...


Page 184: remplacer la dfinition de la fonction
"dfinition_de_nom_de_procdure" par:

  and dfinition_de nom_de_procdure =
     try
       assoc nom_de_procdure !procdures_dfinies
     with Not_found ->
       failwith ("procdure inconnue: " ^ nom_de_procdure);;


Page 187: remplacer les dfinitions des fonctions "analyse_programme"
et "analyse_phrase" par:

  let rec analyse_programme = function
      [< analyse_phrase ph; analyse_programme p >] -> ph :: p
    | [< 'Symbole `.` >] -> []

  and analyse_phrase = function
      [< 'Mot "pour"; 'Mot s; paramtres variables;
         suite_d'ordres ordres >] ->
       Pour (s, {Paramtres = variables; Corps = ordres})
    | [< ordre ord >] -> Ordre ord


Page 195: ajouter un ";;"  la fin de la premire ligne du fichier
hello.ml (en haut de la page). hello.ml doit contenir:

  let message = "Bonjour, tout le monde!";;
  print_string message;;
  print_newline();;


Page 197: remplacer la boucle d'interaction (en bas de la page) par:

  let flux_d'entre = stream_of_channel std_in in
  let flux_lexmes = analyseur_lexical flux_d'entre in
  while true do
    print_string "? "; flush std_out;
    try
      excute_programme(analyse_programme flux_lexmes)
    with
      Parse_error ->
        print_string "Erreur de syntaxe"; print_newline()
    | Failure s ->
        print_string "Erreur  l'excution: "; print_string s;
        print_newline()
  done;;


Page 206, septime ligne en partant du bas de la page: lire
"alex__analyseur_lexical" au lieu de "alex__anaylseur_lexical".


Page 234: remplacer la dfinition de la fonction "lire_symbole" par:

  let rec lire_symbole position flux =
    match flux with
      [< '(`!`|`$`|`%`|`&`|`*`|`+`|`-`|`.`|`/`|`:`|
           `;`|`<`|`=`|`>`|`?`|`@`|`^`|`|`|`~` as c) >] ->
        if position < string_length tampon then
          set_nth_char tampon position c;
        lire_symbole (position + 1) flux
    | [< >] ->
        sub_string tampon 0 (min position (string_length tampon));;


Page 370, premire ligne: les exceptions "Conflit" et "Circularit"
sont dclenches par la fonction "unifie", et non pas "unify" comme
indiqu.


Page 387, bas de la page: la dfinition correcte des fonctions
"fst" et "snd" est la suivante:

  let first x y = x
  and second x y = y;;
  let fst paire = paire first
  and snd paire = paire second;;


--------------- Manuel de rfrence du langage Caml ---------------

Page 77, section 7.4: la partie prlude d'une dfinition de grammaire est
termine par %} et non pas }%. Autrement dit, une dfinition de grammaire
est de la forme:

  %{
    prlude
  %}
    dclarations
  %%
    rgles
  %%
    pilogue


Page 121: ajouter la description suivante de la nouvelle fonction
"copy_vect":

  value copy_vect : 'a vect -> 'a vect

    copy_vect v renvoie une copie du tableau v, c'est--dire un
    nouveau tableau contenant les mmes lments que v.


Pages 123--135: la bibliothque d'utilitaires contient trois nouveaux
modules: "set" (ensembles), "map" (tables d'associations) et "baltree"
(arbres binaires quilibrs). Les descriptions de ces modules sont
donnes  la fin de ce fichier. Pour des raisons de place, ces modules
ne sont pas disponibles dans la version PC 8086.


Page 127, description de "do_table": supprimer la phrase

        La mme liaison peut tre prsente plusieurs fois  f.

  La fonction do_table de Caml Light 0.6 applique la fonction  chaque
  liaison une et une seule fois.


Page 137: la bibliothque "libgraph" de la distribution Caml Light, qui
  implmente les primitives graphiques au-dessus du systme X Windows,
  est maintenant indpendante de la bote  outils RT. Le rpertoire
  contrib/libgraph de la distribution contient toutes informations sur
  l'installation et l'utilisation de cette bibliothque.


Page 139, paragraphe "386": ajouter:

  Les primitives graphiques ne fonctionnent pas si vous lancez Caml Light
   partir de Windows 3, et plus gnralement de tout gestionnaire
  mmoire au standard DPMI.


Page 140: deux couleurs supplmentaires sont prdfinies:

  value background: color
    La couleur du fond de l'cran graphique (gnralement soit
    noir, soit blanc). clear_graph peint l'cran avec cette couleur.

  value foreground: color
    La couleur de trac initiale (gnralement, noir si le fond
    de l'cran est blanc, et blanc si le fond est noir).


Page 151, bas de page: les pilotes graphiques dans le rpertoire
C:\CAML386\DEV ont l'extension .GRD ou .GRN, et non pas uniquement .GRD.


Page 153, bas de page: la version PC 80386 est maintenant compatible
avec Windows 3, et plus gnralement avec les gestionnaires mmoires
au standard DPMI, et non plus seulement VCPI comme avant. 


-------------- Annexe: les nouveaux modules de la bibliothque ----------

set : ensembles sur types ordonns

    Ce module implmente la structure d'ensemble, tant donn un ordre
    total sur les lments de l'ensemble. Toutes les oprations sur
    les ensembles sont purement applicatives: les ensembles ne sont
    pas modifis physiquement. L'implmentation utilise des arbres
    binaires quilibrs, ce qui garantit de bonnes performances: par
    exemple, l'insertion et le test d'appartenance prennent un temps
    logarithmique en la taille de l'ensemble.

  type 'a t

    Le type des ensembles contenant des lments de type 'a.

  value empty: ('a -> 'a -> int) -> 'a t

    L'ensemble vide. La fonction argument est un ordre total sur le
    type des lments. C'est une fonction f  deux arguments telle
    que f e1 e2 vaut zro si les lments e1 et e2 sont gaux, f e1 e2
    est un entier strictement ngatif si e1 est infrieur  e2, et 
    f e1 e2 est un entier strictement positif si e1 est suprieur  e2.
    Exemples: pour le type int, la fonction prefix - est un ordre
    total convenable. Pour le type string, on peut utiliser
    compare_strings.

  value is_empty: 'a t -> bool

    Teste si un ensemble est vide.

  value mem: 'a -> 'a t -> bool

    mem x e teste si x appartient  l'ensemble e.

  value add: 'a -> 'a t -> 'a t

    add x e renvoie un ensemble contenant tous les lments de e, plus
    x. Si x appartient dj  e, e est renvoy tel quel.

  value remove: 'a -> 'a t -> 'a t

    remove x e renvoie un ensemble contenant tous les lments de e,
    sauf x. Si x n'appartient pas  e, e est renvoy tel quel.

  value union: 'a t -> 'a t -> 'a t
  value inter: 'a t -> 'a t -> 'a t
  value diff: 'a t -> 'a t -> 'a t

    Union, intersection et diffrence de deux ensembles.

  value equal: 'a t -> 'a t -> bool

    equal s1 s2 teste si les ensembles s1 et s2 sont gaux,
    c'est--dire contiennent les mmes lments.

  value compare: 'a t -> 'a t -> int

    Ordre total sur les ensembles. Peut servir de fonction d'ordre
    pour faire des ensembles d'ensembles, par exemple.

  value elements: 'a t -> 'a list

    Renvoie la liste des lments de l'ensemble donn. L'ordre dans
    lequel les lments apparaissent dans la liste n'est pas spcifi.

  value iter: ('a -> 'b) -> 'a t -> unit

    iter f e applique f successivement  tous les lments de e. Les
    rsultats des applications sont ignors. L'ordre dans lequel les
    lments de e sont passs  f n'est pas spcifi.

  value fold: ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b

    fold f e a calcule (f xN ... (f x2 (f x1 a))...), o x1 ... xN
    sont les lments de e. L'ordre dans lequel les lments de e sont
    passs  f n'est pas spcifi.


map: tables d'association sur types ordonns.

    Ce module implmente la structure de table d'association (aussi
    appele dictionnaire), tant donn un ordre total sur le type des
    cls. Toutes les oprations sur les tables sont purement
    applicatives: les tables ne sont pas modifis physiquement.
    L'implmentation utilise des arbres binaires quilibrs; en
    consquence, la recherche et l'insertion se font en temps
    logarithmique en la taille de la table.

  type ('a, 'b) t

    Le type des tables dont les cls sont de type 'a et les donnes
    associes de type 'b.

  value empty: ('a -> 'a -> int) -> ('a, 'b) t

    La table vide. La fonction argument est un ordre total sur le
    type des cls. C'est une fonction f  deux arguments telle que f
    c1 c2 vaut zro si les cls c1 et c2 sont gales, f c1 c2 est un
    entier strictement ngatif si c1 est infrieure  c2, et f c1 c2
    est un entier strictement positif si c1 est suprieure  c2.
    Exemples: pour le type int, la fonction prefix - est un ordre
    total convenable. Pour le type string, on peut utiliser
    compare_strings.

  value add: 'a -> 'b -> ('a, 'b) t -> ('a, 'b) t

    add x y t renvoie une table contenant les mmes liaisons que t,
    plus une liaison de x  y. La prcdente liaison de x dans t, si
    elle existe, n'est pas dtruite, mais simplement cache: elle
    rapparat aprs une opration remove. (Ce comportement est
    identique  celui des listes d'associations.)

  value find:'a -> ('a, 'b) t -> 'b

    find x t renvoie la liaison courante de x dans t, c'est--dire la
    donne associe  la cl x dans la table t, ou lve l'exception
    Not_found si x n'est pas li dans t.

  value remove: 'a -> ('a, 'b) t -> ('a, 'b) t

    remove x t renvoie une table contenant les mmes liaisons que t,
    moins la liaison courante de x. La prcdente liaison de x, si
    elle existe, rapparat. t est renvoye sans modifications si x
    n'est pas li dans t.

  value iter: ('a -> 'b -> 'c) -> ('a, 'b) t -> unit

    iter f t applique f successivement  toutes les liaisons de t.
    Les rsultats des applications sont ignors. f reoit la cl en
    premier argument et la donne associe en second. L'ordre dans
    lequel les liaisons sont passes  f n'est pas spcifi. f ne
    reoit que des liaisons courantes: les liaisons caches par des
    liaisons plus rcentes ne sont pas passes  f.


baltree : arbres binaires quilibrs

    Ce module implmente la structure d'arbres binaires quilibrs sur
    des types munis d'une fonction d'ordre. Toutes les oprations sur
    les arbres binaires sont purement applicative: les arbres ne sont
    pas modifis physiquement. Les modules set (ensembles) et map
    (tables d'association) sont drivs de ce module. Au contraire de
    set et map, ce module donne un accs direct  l'implmentation des
    arbres binaires. Il est donc d'emploi plus dlicat et s'adresse
    aux utilisateurs avertis.

  type 'a t = Empty | Node of 'a t * 'a * 'a t * int

    Le type des arbres contenant des lments de type 'a. Empty est
    l'arbre vide (ne contenant aucun lment).

  type 'a contents = Nothing | Something of 'a

    Ce type est utilis par les fonctions modify et split pour
    reprsenter la prsence ou l'absence d'un lment dans un arbre.

  value add: ('a -> int) -> 'a -> 'a t -> 'a t

    add f x a insre l'lment x dans l'arbre a. f est une fonction
    d'ordre sur les lments de l'arbre: f y doit renvoyer 0 si x et y
    sont gaux (ou quivalents), un entier strictement ngatif si x
    est infrieur  y, et un entier strictement positif si x est
    suprieur  y. L'arbre a est renvoy tel quel s'il contient dj
    un lment quivalent  x, c'est--dire un lment y tel que f y
    vaut 0. L'ordre f doit tre cohrent avec les ordres utiliss
    pour construire a  l'aide des fonctions add, remove, modify ou
    split.

  value contains: ('a -> int) -> 'a t -> bool

    contains f a teste si a contient un lment satisfaisant f,
    c'est--dire un lment x tel que f x vaut 0. f est une fonction
    d'ordre sur les lments de a qui doit vrifier les proprits
    dcrites ci-dessus pour la fonction add. L'ordre f peut tre plus
    grossier (identifier davantage d'lments) que les ordres utiliss
    pour construire a, mais il doit tre cohrent avec eux.

  value find: ('a -> int) -> 'a t -> 'a

    find se comporte comme contains, sauf que find f a renvoie
    l'lment x tel que f x vaut 0, ou dclenche l'exception Not_found
    si l'arbre ne contient aucun lment qui convienne.

  value remove: ('a -> int) -> 'a t -> 'a t

    remove f a renvoie l'arbre a priv de son lment x tel que f x
    vaut 0. f est une fonction d'ordre avec les mmes contraintes que
    pour add. Si a ne contient aucun lment satisfaisant f, il est
    renvoy tel quel. Si a contient plusieurs lments satisfaisant f,
    un seul est enlev.

  value modify: ('a -> int) -> ('a contents -> 'a contents) -> 'a t -> 'a t

    Fonction gnrale d'insertion, de modification et de destruction
    sur les arbres. modify f g a parcours a  la recherche d'un
    lment x satisfaisant f. f est une fonction d'ordre avec les
    mmes contraintes que pour add. Si l'arbre contient un tel lment
    x, g est applique  l'argument Something x; si g renvoie Nothing,
    l'lment x est supprim; si g renvoie Something y, l'lment y
    est mis  la place de x dans l'arbre. (Il faut que x et y soient
    quivalents, en particulier que f y soit gal  0.) Si l'arbre ne
    contient aucun x satisfaisant f, g est applique  Nothing; si g
    renvoie Nothing, l'arbre a est renvoy sans changements; si g
    renvoie Something x, l'lment x est insr dans l'arbre. (Il
    faut que f x soit gal  0.) Les fonctions add et remove sont des
    cas particuliers lgrement plus efficaces de modify.

  value split: ('a -> int) -> 'a t -> 'a t * 'a contents * 'a t

    split f a renvoie un triplet (inf, e, sup) o inf est un arbre
    contenant tous les lments x de a tels que f x est strictement
    ngatif, sup est un arbre contenant tous les lments x de a tels
    que f x est strictement positif, et e est soit Something x si a
    contient un lment x tel que f x est 0, soit Nothing dans le cas
    contraire.

  value compare: ('a -> 'a -> int) -> 'a t -> 'a t -> int

    Compare deux arbres. Le premier argument f est une fonction de
    comparaison sur les lments de l'arbre: f e1 e2 doit renvoyer
    zro si e1 et e2 sont gaux, un entier strictement
    ngatif si e1 est infrieur  e2, et un entier strictement positif
    si e1 est suprieur  e2. compare f t1 t2 compare les lments de
    t1 et t2 par ordre lexicographique sur les franges des arbres.
