algo avancée

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

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)
 -------------------------------