From 48524d751af660f7b98e799e88cfe07b6b287d1e Mon Sep 17 00:00:00 2001
From: gwen <gremond@cadoles.com>
Date: Sat, 29 Apr 2017 23:14:45 +0200
Subject: [PATCH] langage de modules

---
 algorithmique/cours/algo.txt    |  8 +++-
 algorithmique/cours/donnees.txt | 34 ++++++++++++---
 algorithmique/cours/modules.txt | 73 +++++++++++++++++++++++++++++++++
 3 files changed, 109 insertions(+), 6 deletions(-)

diff --git a/algorithmique/cours/algo.txt b/algorithmique/cours/algo.txt
index bc1aeb9..9c26138 100644
--- a/algorithmique/cours/algo.txt
+++ b/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.
diff --git a/algorithmique/cours/donnees.txt b/algorithmique/cours/donnees.txt
index 0b6397c..b1e12b6 100644
--- a/algorithmique/cours/donnees.txt
+++ b/algorithmique/cours/donnees.txt
@@ -4,15 +4,15 @@ Les structures de données
 .. glossary::
 
     ATD
-        
+
         Abstract Data Type, structure de données abstraites.
-        La représentation des données est forcément un choix. 
-        Il est impossible de rendre compte globalement d'un élément du réel, 
+        La représentation des données est forcément un choix.
+        Il est impossible de rendre compte globalement d'un élément du réel,
         il faut en faire une interprétation abstraite.
 
-**Exemple**: 
+**Exemple**:
 
-- Un être humain peut être représenté par les données présentes dans sa 
+- Un être humain peut être représenté par les données présentes dans sa
   carte d'identité. Mais un être humain n'est pas sa carte d'identité.
 - Un être humain peut être représenté par les données présentes dans ses préférences
   de surf sur internet. Mais un être humain **n'est pas** l'ensemble de ses logs de surf sur le net.
@@ -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
diff --git a/algorithmique/cours/modules.txt b/algorithmique/cours/modules.txt
index 5ec9ae7..ba5d0f7 100644
--- a/algorithmique/cours/modules.txt
+++ b/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)