diff --git a/algo/AlgoApprofondie/cours/donnees.txt b/algo/AlgoApprofondie/cours/donnees.txt
index 96507b8..109ae9b 100644
--- a/algo/AlgoApprofondie/cours/donnees.txt
+++ b/algo/AlgoApprofondie/cours/donnees.txt
@@ -468,6 +468,7 @@ Les piles
 - FIFO : "first in first out"
 
 
+
 Traduction d'une structure de données dans une autre
 -----------------------------------------------------
 
@@ -730,8 +731,10 @@ On les appelle enregistrements, dictionnaires ou tables de hachage.
 
 
 
--  les types sommes (constructeurs) : modélisation de domaines finis
+les types sommes
+~~~~~~~~~~~~~~~~
 
+appelés aussi type construits, ou types algébriques
 
 .. code-block:: ocaml
 
@@ -748,12 +751,83 @@ On les appelle enregistrements, dictionnaires ou tables de hachage.
     Ent of int | Reel of float | Cplx of float × float
     Ent, Reel, Cplx sont les constructeurs du type.
 
+Les arbres
+----------
+
+Structure de données construite sur un type somme récursif.
+
+arbre binaire :
+
+.. code-block:: ocaml
+
+    type arbre = Vide | Noeud of int * arbre * arbre
+    let a =
+        Noeud(10,
+        Noeud(2,Noeud(8,Vide,Vide),Vide),
+        Noeud(5,Noeud(11,Vide,Vide),Noeud(3,Vide,Vide)));;
+
+arbre binaire polymorphe :
+
+
+.. code-block:: ocaml
+
+    type ’a arbre = Vide | Noeud of ’a * ’a arbre * ’a arbre;;
+    let b = Noeud(10,Noeud(5,Vide,Vide),Vide);;
+    let c = Noeud(’f’,Vide,Noeud(’a’,Vide,Noeud(’g’,Vide,Vide)));;
+
+- parcours d’un arbre binaire
+- itérateurs sur un arbre binaire
+- taille d'un arbre
+
+arbre n-aire::
+
+    type ’a arbre = Vide | Noeud of ’a * ’a arbre list;;
+
+- transformation d'un arbre en un autre
+- arbre ordonné (arbre de recherche)
+- équilibrage des arbres de recherche
+
+
+Un arbre binaire est ordonné (ou de recherche) par rapport à une relation
+d’ordre quelconque si :
+
+- c’est l’arbre vide (Vide)
+- c’est un arbre non-vide Noeud(x,g,d) et
+
+1. les éléments du sous-arbre gauche g sont inférieurs à la racine x
+2. la racine x est inférieure aux éléments du sous-arbre droit d
+3. les sous-arbres g et d sont eux-mêmes ordonnés
+
+::
+
+	let a1 =
+	Noeud(5, Noeud(2, Vide, Vide),
+	Noeud(20, Noeud(10, Noeud(6, Vide, Vide),
+	Noeud(14,Vide, Vide)),
+	Noeud(21,Vide,Vide)));;
+
+.. image:: _static/AbreOrdonne.png
+
+Recherche d'un élément dans un arbre ordonné
+---------------------------------------------
+
+La structure ordonnée des arbres binaires de recherche permet d’effectuer
+la recherche d’un élément avec une compléxité en moyenne de O(log n)
+
+::
+
+    let rec recherche elt abr =
+    match abr with
+    | Vide -> false
+    | Noeud (x,_,_) when x = elt -> true
+    | Noeud (x,g,_) when elt < x -> recherche elt g
+    | Noeud (_,_,d) -> recherche elt d
+    ;;
+
 Autres structures de données complexes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-- arbres
 - graphes
 - dates
-
 - le parcours de graphes
 - les calculs de dates
diff --git a/algo/AlgoApprofondie/cours/fonctions.txt b/algo/AlgoApprofondie/cours/fonctions.txt
index 90340ae..0ac871c 100644
--- a/algo/AlgoApprofondie/cours/fonctions.txt
+++ b/algo/AlgoApprofondie/cours/fonctions.txt
@@ -3,6 +3,20 @@
 Définitions par filtrage
 --------------------------
 
+::
+
+    type formule = Vrai | Faux | Conjonction of formule * formule
+
+
+le fitrage permet un examen par cas sur les valeurs construites::
+
+    let rec evalue = function
+        | Vrai -> true
+        | Faux -> false
+        | Conjonction (Faux, _) | Conjonction (_, Faux) -> false
+        | Conjonction (f1, f2) -> evalue f1 && evalue f2;;
+
+
 Lorsqu'un argument est passé à un ensemble de clauses :
 
 - la première clause qui filtre l'argument est exécutée, les autres sont
diff --git a/algo/tronCommun/fonctions.txt b/algo/tronCommun/fonctions.txt
index 316477a..5e1c12b 100644
--- a/algo/tronCommun/fonctions.txt
+++ b/algo/tronCommun/fonctions.txt
@@ -69,6 +69,9 @@ Description d'une procédure
 En programmation impérative, un programme est une suite d’instructions qui font
 évoluer l’état mémoire, le résultat est dans l’état final de la mémoire.
 
+Une procédure n'est rien d'autre qu'une fonction dont le résultat est de
+type unit
+
 - une procédure peut prendre des paramètres
 - elle modifie l'état courant du système
 
@@ -329,7 +332,16 @@ en cours d'exécution ni ne réalise d'effets de bord. Elle renvoie
 En programmation fonctionnelle, programme est un ensemble de définitions de fonctions,
 un résultat est l'application d’une fonction à une structure de données effective.
 
-- composant de base : la fonction
+Les fonctions en programmation fonctionelles vont en réalité beaucoup plus loin, justifiant
+le nom de programmation fonctionnelle.
+
+- elles sont des valeurs de première classe c'est-à-dire des valeurs pouvant être créées par des calculs,
+  passées en argument à des
+  fonctions ou retournées, comme n'importe quelles autres valeurs.
+- une fonction peut être une expression comme une autre, alors anonyme
+- une application partielle peut être définie (curryfication)
+
+-  base : la fonction
 - opération de base : l’application
 
 .. raw:: latex
diff --git a/algo/tronCommun/programme.txt b/algo/tronCommun/programme.txt
index b7eeee1..0197190 100644
--- a/algo/tronCommun/programme.txt
+++ b/algo/tronCommun/programme.txt
@@ -32,93 +32,21 @@ programme :
 2. communiquer avec des fichiers,
 3. communiquer avec d'autres programmes.
 
-Les expressions
-----------------
-
-expression
-
-    Une expression est une valeur caculée du langage, une opération arithmétique
-    qui retourne une valeur (entier, texte, valeur logique...).
-    C'est donc une suite sémantiquement correcte de **valeurs de base** et **d'opérateurs**
-
-Par exemple, la ligne suivante est une expression effectuant une addition::
-
-    5 + 6
-
-Expressions à partir de types de base
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Autres exemples d'expressions :
-
-- 5 est une expression de type int
-- 4.5 est une expression de type float
-- 'c' est une expression de type char
-- true est une expression de type bool
-- print ('c') est une expression de type None
-- raw_input est une expression de type string
-
-Les expressions se complexifient avec la complexification des données et des traitements,
-mais le principe de l'expressivité d'un langage reste le même.
-
-
-.. ifconfig:: exercice
-
-    **Exercice** :
-    Le parenthésage et les opérateurs booléens::
-
-        Variables A, B, C, D, E en Booléen
-        Variable X en Entier
-        Début
-        Lire X
-        A <- X > 12
-        B <- X > 2
-        C <- X < 6
-        D <- (A ET B) OU C
-        E <- A ET (B OU C)
-        Ecrire D, E
-        Fin
-
-    **Que valent D et E si X = 3 ?**
-
-
-.. ifconfig:: correction
-
-    **Correction** : D sera VRAI alors que E sera FAUX
-
-
-
-
 Les déclarations
 -----------------
 
-Un autre exemple d'expression :
+déclarations. affectations par valeur ? par référence ? Bien faire la
+différence entre les deux.
 
-.. raw:: latex
+**déclaration par référence**
+
+.. code-block:: ocaml
+
+    let x = ref 1;;
+    print_int !x;;
+    x := !x + 1;;
+    print_int !x;;
 
-    \begin{algorithm}
-    \caption{Exemple d'expression}
-    \begin{algorithmic}[1]
-    \BState \emph{sortie}: $l$ \Comment{C'est l'expression calculée renvoyée}
-    \ForAll {$v \in V(G)$}
-    \State $l(v) \leftarrow \infty$
-    \EndFor
-    \State $l(u) \leftarrow 0$
-    \Repeat
-    \For {$i \leftarrow 1, n$}
-    \State $min \leftarrow l(v_i)$
-    \For {$j \leftarrow 1, n$}
-    \If {$min > e(v_i, v_j) + l(v_j)$}
-    \State $min \leftarrow e(v_i, v_j) + l(v_j)$
-    \State $p(i) \leftarrow v_j$
-    \EndIf
-    \EndFor
-    \State $l(i) \leftarrow min$
-    \EndFor
-    \State $changed \leftarrow l \not= l’$
-    \State $l \leftarrow l$
-    \Until{$\neg changed$}
-    \end{algorithmic}
-    \end{algorithm}
 
 Exemple de déclarations :
 
@@ -341,6 +269,122 @@ Exercices : algorithmes sur les affectations
         >>> c
         '42312'
 
+Les expressions
+----------------
+
+expression
+
+    Une expression est une valeur caculée du langage, une opération arithmétique
+    qui retourne une valeur (entier, texte, valeur logique...).
+    C'est donc une suite sémantiquement correcte de **valeurs de base** et **d'opérateurs**
+
+Par exemple, la ligne suivante est une expression effectuant une addition::
+
+    5 + 6
+
+La séquence s'écrit avec le traditionnel point-virgule, comme
+dans::
+
+    x := 1; 2 + !x
+
+expression séquentielle::
+
+    3 * (x := 1; 2 + !x)
+
+
+Un autre exemple d'expression :
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Exemple d'expression}
+    \begin{algorithmic}[1]
+    \BState \emph{sortie}: $l$ \Comment{C'est l'expression calculée renvoyée}
+    \ForAll {$v \in V(G)$}
+    \State $l(v) \leftarrow \infty$
+    \EndFor
+    \State $l(u) \leftarrow 0$
+    \Repeat
+    \For {$i \leftarrow 1, n$}
+    \State $min \leftarrow l(v_i)$
+    \For {$j \leftarrow 1, n$}
+    \If {$min > e(v_i, v_j) + l(v_j)$}
+    \State $min \leftarrow e(v_i, v_j) + l(v_j)$
+    \State $p(i) \leftarrow v_j$
+    \EndIf
+    \EndFor
+    \State $l(i) \leftarrow min$
+    \EndFor
+    \State $changed \leftarrow l \not= l’$
+    \State $l \leftarrow l$
+    \Until{$\neg changed$}
+    \end{algorithmic}
+    \end{algorithm}
+Expressions à partir de types de base
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Autres exemples d'expressions :
+
+- 5 est une expression de type int
+- 4.5 est une expression de type float
+- 'c' est une expression de type char
+- true est une expression de type bool
+- print ('c') est une expression de type None
+- raw_input est une expression de type string
+
+Les expressions se complexifient avec la complexification des données et des traitements,
+mais le principe de l'expressivité d'un langage reste le même.
+
+
+.. ifconfig:: exercice
+
+    **Exercice** :
+    Le parenthésage et les opérateurs booléens::
+
+        Variables A, B, C, D, E en Booléen
+        Variable X en Entier
+        Début
+        Lire X
+        A <- X > 12
+        B <- X > 2
+        C <- X < 6
+        D <- (A ET B) OU C
+        E <- A ET (B OU C)
+        Ecrire D, E
+        Fin
+
+    **Que valent D et E si X = 3 ?**
+
+
+.. ifconfig:: correction
+
+    **Correction** : D sera VRAI alors que E sera FAUX
+
+Les instructions
+----------------
+
+Dans les langages impératifs, expressions et instructions sont deux catégories syntaxiques bien distinctes : une
+conditionnelle, if-then-else ou une boucle for n'est pas acceptée en position d'expression, et
+inversement certaines expressions ne sont pas autorisées en position d'instruction.
+
+En OCaml , il n'y a pas de telle distinction expression/instruction : il n'y a
+que des expressions. Ainsi on peut écrire::
+
+    1 + (if x = 0 then 2 else 3)
+
+
+exemple d'expression de base::
+
+    # let x = 5;;
+    val x : int = 5
+    # 1 + (if (x == 0) then  3 else 6);;
+    - : int = 7
+
+exemple de présence d'instruction dans notre expression de base::
+
+    # 1 + (if (x == 0) then (let b=5 in b) else (let a=2 in a));;
+    - : int = 3
+
 Interaction avec l'utilisateur
 ------------------------------
 
@@ -379,6 +423,14 @@ Il est possible de communiquer de la manière suivante avec un programme :
 			print("bonjour, je m'appelle " + prenom.capitalize())
 
 
+
+Pour résumer en ocaml, nous avons vu
+
+-  qu'un programme est une suite d'expressions et de déclarations ;
+-  que les variables introduites par le mot clé let ne sont pas modifiables ;
+-  qu'il n'y a pas de distinction entre expressions et instructions.
+
+
 La REPL (boucle d'interaction)
 -------------------------------