1. Introduction
2. Syntaxe
3. Types et opérations élémentaires
4. Enregistrements et references
5. Entrées sorties
   
   
6. Fonctions
7. Variantes et filtrage
8. Exceptions
9. Mise au point
   
   
10. Polymorphisme
11. Modules
12. Compilation séparée

1. Mise en oeuvre
   1. Mode compilé
   2. Mode interprété
2. Mode Emacs
3. Petits exemples (1, 2, 3, 4)
   
   
4. La commande cat
5. La Calculette
6. La commande wc
   
   
7. Utilisation de la librairie Set
8. Polynômes

(* Cela est un commentaire (* et ceci un commentaire à 
   l'intérieur d'un commentaire *) sur plusieurs lignes *)

    [| 0; 1; 3 |] : int array
    [| true; false |] : bool array

    fun x -> x.(0) : 'a array -> 'a
    fun t k x = t.(k) <- x : 'a array -> int -> 'a -> unit

    Array.create : int -> 'a -> 'a array

    fun (x, y, z) -> x : ('a * 'b * 'c) -> 'a

    fst : 'a * 'b -> 'a
    snd : 'a * 'b -> 'b

     let plus x y = x + y : int -> int -> int
     let plus (x, y) = x + y : int * int -> int    

    plus 1 3

    let rec fact n = if n > 1 then n * fact (n -1) else 1;;

    let rec ping n = if n > 0 then pong (n - 1) else "ping"
    and pong n = if n > 0 then ping (n - 1) else "pong";;

type monnaie = {nom : string; valeur : float}
let x = {nom = "euro"; valeur =  6.55957}
x.valeur

type 'a info = {nom : string; valeur : 'a}
fun x -> x.valeur;;
- : 'a info -> 'a

    type personne = {nom : string; mutable âge : int}

# let p = {nom = "Paul"; âge = 23};;
val p : personne = {nom="Paul"; âge=23}
# let anniversaire x = x.âge <- x.âge + 1;;
val anniversaire : personne -> unit = <fun>
# p.nom <- "Clovis";;
Characters 0-17:
The label nom is not mutable

   type 'a boîte = { mutable contenu : 'a };;

    # let compose f g = fun x -> f (g x);;
    val compose : ('a -> 'b) -> ('c -> 'a) -> ('c -> 'b)
    # let plus_deux = compose succ succ;;

    # let symétrique f x y = f y x;;
    val symétrique : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c

    (fun x y -> x + y) 1 3

let rec puissance f n =
    if n <= 0 then fun x -> x
    else  let g = puissance f (n - 1) in fun x -> f (g x);;
val puissance : ('a -> 'a) -> int -> 'a -> 'a

let plus u v = puissance (  succ )  u  v
let fois u v = puissance (( + ) u)  v  0
let puis u v = puissance (( * ) u)  v  1

let marge = puissance (fun x -> "."^x);;
val marge : int -> string -> string 

type 'a peut_être = Voilà of 'a | Pas_encore;;
type carte = Carte of int | Valet | Dame | Roi;;

type 'a liste = Vide | Cellule of 'a contenu
and 'a contenu = {tête : 'a; reste : 'a liste}

    let rec longueur = function 
      Vide -> 0
    | Cellule (tête, reste) -> 1 + longueur reste

    function Voila ({valeur = Carte x} as z, _) -> z.nom

exception Perdu
let rec cherche_la_clé k = function
    (h, v) :: t -> if h = k then v else cherche_la_clé k t
  | [] -> raise Perdu

let k =
  try cherche_la_clé "Georges" [ "Louis", 14; "Georges", 5;]
  with Perdu -> 10;;

#trace nom-de-fonction;;
#untrace nom-de-fonction;;
#untrace_all;;

#install_printer imprimeur;;
#remove_printer imprimeur;;

let identité x = x;;
  : int -> int 
  : string -> string
  : 'a * 'a -> 'a * 'a
  : 'a -> 'a

let identité x = x;;
  : 'a -> 'a

    let f = identité in f 1, f true;;

    (fun f -> f 1, f true) identité;;                 Erreur

   let f = identité identité in f 1, f true;;         Erreur

   # let f = identité identité;;
   f : '_a -> '_a 

   # f 1;;

   # f;;
   f : int -> int
   # f true;;                                       Erreur   

     module S =
       struct
         type t = int
         let x = 0
         let f x = x+1
       end

        ... (S.f S.x : S.t) ...

        open S
        ... (f x : t) ...

     module T =
       struct
         module R = struct let x = 0 end
         let y = R.x + 1
       end

    module type MA_SIGNATURE = sig ... end

    S.x;;           Erreur ``S.x is unbound''
    S.y + 1;;       Erreur ``S.y is not of type int''

module Euro = (Float : MONNAIE);;
module Dollar = (Float : MONNAIE);;

let euro x = Euro.prod x Euro.un;;
Euro.plus (euro 10.0) (euro 20.0);;
Euro.plus (euro 50.0) Dollar.un;;        Erreur

  sig
    type t = Euro.t
    val plus: t -> t -> t
  end

module Plus = (Euro : PLUS with type t = Euro.t);;
Plus.plus Euro.un Euro.un;;

 module A =
   (struct contenu de a.ml end : sig contenu de a.mli end)
 module B = struct contenu de b.ml end

     module T = functor(S : SIG) ->
       struct
         type u = S.t * S.t
         let y = S.g(S.x)
       end

    module T1 = T(S1)
    module T2 = T(S2)

    (T1.y : T2.u)

module type BANQUE =            (* vue du banquier *)
  sig
    type t
    type monnaie
    val créer : unit -> t
    val dépôt : t -> monnaie -> monnaie
    val retrait : t -> monnaie -> monnaie
  end;;

module type CLIENT =            (* vue donnée au client *)
  sig
    type t
    type monnaie
    val dépôt : t -> monnaie -> monnaie
    val retrait : t -> monnaie -> monnaie
  end;;    

module Banque_au_porteur (M : MONNAIE) :
    BANQUE with type monnaie = M.t =
  struct
    type monnaie = M.t
    type t = { mutable solde : monnaie }
    let zéro = M.prod 0.0 M.un and neg = M.prod (-1.0)

    let créer() =  { solde = zéro }
    let dépôt c x =
      if x > zéro then c.solde <- M.plus c.solde x; c.solde
    let retrait c x =
      if c.solde > x then dépôt c (neg x) else c.solde
  end;;

module Poste = Banque_au_porteur (Euro);;

module Client : CLIENT
      with type monnaie = Poste.monnaie
      with type t = Poste.t 
  =  Poste;;

let mon_ccp = Poste.créer ();;
Poste.dépôt mon_ccp (euro 100.0);;
Client.dépôt mon_ccp (euro 100.0);;

module Citybank = Banque_au_porteur (Dollar);;
let mon_compte_aux_US = Citybank.créer()
Citybank.dépôt mon_ccp;;                          Erreur
Citybank.dépôt mon_compte_aux_US (euro 100.0);;   Erreur

module Banque_centrale = Banque_au_porteur (Euro);;
module Poste = Banque_au_porteur (Euro);;