langage de modules

algorithmique/cours/algo.txt

@@ -192,7 +192,7 @@ Prédicats
 	Définition : Une proposition dont la valeur de vérité dépend de la valeur
     d’une ou plusieurs variables
 
-**Exemple** : “n est pair” : vrai pour n = 4 mais faux pour n = 9
+**Exemple** : ``n est pair`` : vrai pour n = 4 mais faux pour n = 9
 
 
 Axiome
@@ -284,3 +284,9 @@ la taille des données, on s’intéresse à la façon dont augment f(n) lorsque
 on va montrer que f(n) n'augmente pas plus vite qu’une autre fonction
 g(n). Du point de vue mathématique, on dit que la fonction f est dominée
 asymptotiquement par la fonction g ce qui se note f = O(g)
+
+- Complexité temporelle : c’est le nombre d’op«erations effectuées par
+  une machine qui exécute l’algorithme.
+
+- Complexité spatiale : c’est le nombre de positions mémoire utilisées par
+  une machine qui exécute l’algorithme.

algorithmique/cours/donnees.txt

@@ -328,6 +328,27 @@ Les types produits nommés
 
 On les appelle enregistrements, dictionnaires ou tables de hachage.
 
+::
+
+        algorithme monAlgorithme
+        // déclaration d'un enregistrement
+        enregistrement Personne
+        chaine nom;
+        chaine prenom;
+        entier age;
+        réel taille;
+        finenregistrement
+        ...
+        Personne[50] t;
+        début
+        // Initialisation
+        t[0].nom <- "Duchmol";
+        t[0].prenom <- "Robert";
+        t[0].age <- 24;
+        t[0].taille <- 1.80;
+        ...
+        fin
+
 .. code-block:: ocaml
 
     # type adresse = { rue : string ; ville : string ; cp : int};;
@@ -341,6 +362,9 @@ On les appelle enregistrements, dictionnaires ou tables de hachage.
     };;
     # let v1 = { a = 1 ; b = false ; c = 'r'};;
 
+
+
+
 -  les sommes (constructeurs)
 
 .. code-block:: ocaml

algorithmique/cours/modules.txt

@@ -167,3 +167,76 @@ Il faut définir auparavant un type spécifique appelé `date`
     arguments :
       d: date
       description: la date dont on veut calculer le lendemain
+
+Le langages des modules
+-------------------------
+
+.. code-block:: ocaml
+
+    module type PILE = (* signature (interface) du module *)
+    sig
+        type ’a t
+        val create : unit -> ’a t
+        val push : ’a -> ’a t -> unit
+        val pop : ’a t -> ’a
+    end
+
+    (* implémentation du module *)
+    module Pile : PILE = (* le module est restreint
+    par la signature PILE *)
+    struct
+        type ’a t = ’a list ref
+        let create () = ref []
+        let push x p = p := x::!p
+        let pop p = match !p with [...]
+        let rec print p = match p with [...]
+    end
+
+- `struct .. end` introduit une collection de définitions, valeurs, types ou modules.
+   C'est une **structure**.
+
+- `module Nom = struct .. end` permet de donner un nom à cette structure et
+  c'est ça un module. C'est une structure nommée.
+
+- `sig ... end` introduit une signature de module : une interface pour un module.
+
+On restreint souvent une structure par une signature pour "cacher" certaines
+définitions. Une signature de module fournit une **interface** entre l'extérieur
+et l'intérieur d'un module.
+
+En dehors du module, on accède à ses composants grâce à la notation pointée
+
+.. code-block:: ocaml
+
+    let p = Pile.create()
+    Pile.push 45 p
+
+Les foncteurs
+--------------
+
+Si un langage possède un langage de modules, on peut aller plus loin : on peut
+considérer un module comme étant une expression de base du langage.
+
+- La signature d'un module peut être considérée comme le type du module
+- La structure du module peut être considéré comme sa valeur
+
+Quel est l'intérêt ? On peut alors définir des **foncteurs**.
+
+foncteur
+
+    "fonction" d'une structure vers une autre structure.
+    On peut ainsi paramétrer un module par un autre module.
+
+.. code-block:: ocaml
+
+    module Nom (M1 :S1 ) (M2 :S2 ) (M3 :S3 ) ... =
+    struct
+    ...
+    end
+
+On applique un foncteur à des paramètres modules, pour
+obtenir un nouveau module :
+
+.. code-block:: ocaml
+
+    module M = F (Titi) (Toto)