Commits

Philémon Gardet committed e5b9a94 Merge with conflicts

Merge branch 'master' of bitbucket.org:gconfs/conf-ocaml

Conflicts:
conf/slides/objet.tex

  • Participants
  • Parent commits 2275645, f20c6c1

Comments (0)

Files changed (10)

File conf/main.tex

 \usepackage{graphicx}
 \usepackage{listings}
 \usepackage{rotating}
-\lstset{language=[objective]caml}   
+\lstset{language=[objective]caml}
 
 \include{themeHfo}
 \setcounter{tocdepth}{1}
 \title{OCaml \\ De l'objet à l'utilisation de SDL}
 \author{Philemon 'PhilGekni' Gardet [philglva@gmail.com]}
 \institute{\includegraphics[width=1.8cm]{pics/epita.png}\\\includegraphics[width=2cm]{pics/gconfs.png}}
-\date{11 octobre 2013}
+\date{Vendredi 11 octobre 2013}
 
 \begin{document}
 	\begin{frame}

File conf/slides/conclusion.tex

 \begin{frame}
 	\frametitle{Récapitulatif des notions abordées}
 	\large
-	\begin{center}
-	'OCaml' 'Fonctionnel'
-	'Types' 'Bibliothèques Standard' 'Objet' 'Polymorphisme de Sous-Type' 'Bibliothèque Sdl' 'Application Graphique' 'Modularité' 'Compilation'
-	'Documentation'
-	\end{center}
+        \begin{itemize}
+            \item OCaml
+            \item Fonctionnel
+            \item Types
+            \item Bibliothèques Standard
+            \item Objet
+            \item Polymorphisme de Sous-Type
+            \item Bibliothèque SDL
+            \item Application Graphique
+            \item Modularité
+            \item Compilation
+            \item Documentation
+        \end{itemize}
 \end{frame}
 
 \begin{frame}
 	\frametitle{Quelques liens}
-	\begin{block}{Documentations OCaml}
+	\begin{block}{Documentation OCaml}
 		\begin{itemize}
 			\item http://caml.inria.fr/pub/docs/manual-ocaml-4.01/
 			\item http://caml.inria.fr/pub/docs/manual-ocaml-4.01/libref
 	\end{block}
 	\begin{block}{Documentation ocamlbuild}
 		\begin{itemize}
-			\item http://caml.inria.fr/pub/docs/manual-ocaml-4.01/ocamlbuild.html 
+			\item http://caml.inria.fr/pub/docs/manual-ocaml-4.01/ocamlbuild.html
 		\end{itemize}
 	\end{block}
 \end{frame}
+
+\begin{frame}
+    \begin{center}
+    Merci de votre attention !
+    \end{center}
+\end{frame}
+

File conf/slides/fonctionnel.tex

 		\item Les flottants : 4.2\\
 			~~41.5 +. 0.5
 		\item Les caractères : 'c'\\
-		\item Les chaines de caractères : "abcd"\\
+		\item Les chaînes de caractères : "abcd"\\
 			~~"The " \^~"meaning of " \^~"life"
 			\item Les n-uplets : ( 1, 4.2, "abc", 4 )
 		\item Le unit : ()
 	\framesubtitle{Quelques fonctionnalités du module List}
 	\begin{itemize}
 	
-	\item List.length : retourne la longueur d'une liste.	
+	\item List.length : retourne la longueur d'une liste
 	
-	\item List.append : Autre nom de l'opérateur @.
+	\item List.append : autre nom de l'opérateur @
 	
-	\item List.rev : inverse la liste passée en paramètre.
+	\item List.rev : inverse la liste passée en paramètre
 	
-	\item List.iter : Application une fonction f à chacun des éléments de la liste.
+	\item List.iter : application d'une fonction f à chacun des éléments de la liste
 
-	\item List.map : Renvoie une liste des résultats par l'application d'une fonction f à chacun des éléments de la liste.
+	\item List.map : renvoie une liste des résultats de l'application d'une fonction f à chacun des éléments de la liste
 
 	\end{itemize}
 \end{frame}
 	let name p1 pn = expr
     	\end{lstlisting}
 	\begin{lstlisting}
-let name = 
+let name =
   function p1 -> function pn -> expr
   	\end{lstlisting}
   	\vspace{0.4cm}
 \begin{frame}[fragile]
 	\frametitle{Les fonctions}
 	\framesubtitle{Déclaration récursive}
-	\begin{block}{Déclaration de fonction recursive} 
+	\begin{block}{Déclaration de fonction récursive}
 	  \begin{lstlisting}
-	  let rec facto x = 
+	  let rec facto x =
 	  	if x = 0 then 1 else x * facto(x-1);;
 	  val facto : int -> int = <fun>
 	  \end{lstlisting}
 \begin{frame}[fragile]
 	\frametitle{Les fonctions}
   	\framesubtitle{L'ordre supérieur}
-  	Et si nous faisions des fonctions de fonctions ? 
+  	Et si nous faisions des fonctions de fonctions ?
  	\begin{lstlisting}
   let comp f a b = f a b;;
-  val comp : ('a -> 'b -> 'c) -> 
+  val comp : ('a -> 'b -> 'c) ->
   'a -> 'b -> 'c = <fun>
-  
+
   comp (+) 3 2;;
   - : int = 5
  	\end{lstlisting}
-	Nous retrouvons ici le type polymorphe representé par\\
-	les 'a et 'b qui rassemble tous les types.
+	Nous retrouvons ici le type polymorphe, rassemblant tous les\\
+	les types et representé par les 'a et 'b.
 \end{frame}
 
 \begin{frame}[fragile]
 	 	\begin{block}{Déclaration}
 		\begin{lstlisting}
 		  let incr ?step:(x = 1) r = r + x
-		  
+		
 		  val incr : ?step:int -> int -> int
 		\end{lstlisting}
 		\end{block}
 	\frametitle{Le contrôle conditionnel}
 	\begin{block}{La structure}
 	\begin{lstlisting}
-	  let f a b c = 
+	  let f a b c =
 	    if a
-	     then b 
+	     then b
 	     else c
 
 	  val f : bool -> 'a -> 'a -> 'a
 	\end{lstlisting}
 	\end{block}
-	\begin{block}{Else optionnel pour le type de retour unit}
+	\begin{block}{'else' optionnel pour le type de retour unit}
 	\begin{lstlisting}
 	  let f a =
 	    if a=42
-	      then print_string "42!" 
+	      then print_string "42!"
 	      (* else () *)
 
 	  val f : bool -> unit -> unit -> unit
 		\begin{column}{5cm}
 			\begin{itemize}
 				\item "not" : négation
-				\item "\&\&" : et logique
-				\item "||" : ou logique
+				\item "\&\&" : ET logique
+				\item "||" : OU logique
 				\item "=" : egalité structurelle
-				\item "<>" : negation de "="
+				\item "<>" : négation de "="
 			\end{itemize}
 		\end{column}
 		\begin{column}{5cm}
 			\begin{itemize}
-				\item "<" : inferieur 
-				\item ">" : superieur
-				\item "<=" : inferieur égale
-				\item ">=" : superieur égale
+				\item "<" : inférieur strict
+				\item ">" : supérieur strict
+				\item "<=" : inférieur ou égal
+				\item ">=" : supérieur ou égal
 			\end{itemize}
 		\end{column}
 	\end{columns}
 \begin{frame}[fragile]
 	\frametitle{Le filtrage de motif}
 	\framesubtitle{Généralités}
-	\begin{block}{Expression générale}
+	\begin{block}{La structure}
 		\begin{lstlisting}
   match expr with
      m1 -> expr1
   function
       42 -> true
     | _ -> false
-		\end{lstlisting} 
+		\end{lstlisting}
 		\end{column}
 	\end{columns}
 	\end{block}
   let rec printStrList l = match l with
       [] -> print_string "\n"
     | e::[] -> print_string (e ^ "\n")
-    | e::q -> 
+    | e::q ->
       print_string(e ^ ", ");
       printStrList q
 		\end{lstlisting}
 
 \begin{frame}[fragile]
   	\frametitle{Le filtrage de motif}
-	\framesubtitle{as et when}
+	\framesubtitle{'as' et 'when'}
   	\begin{block}{As}
     	\begin{lstlisting}
-	  let rec fibo = function 
- 	    0 | 1 as n -> n 
- 	  | x -> fibo(x - 1) + fibo(x - 2);; 
+	  let rec fibo = function
+ 	    0 | 1 as n -> n
+ 	  | x -> fibo(x - 1) + fibo(x - 2);;
     	\end{lstlisting}
   	\end{block}
   	\begin{block}{When}
     	\begin{lstlisting}
-  let is_inf = function 
+  let is_inf = function
         x when x < 42 -> true
     	| _ -> false;;
     	\end{lstlisting}
   val a : int * int = (3,7)
   let (b:point) = (3,7);;
   val b : point = (3,7)
-  
-  type stringLabeledIntList = 
+
+  type stringLabeledIntList =
     string * (int list)
 
   type funIntList = (int list) -> int
 	\framesubtitle{Types paramétrés}
 	\begin{lstlisting}
   type ('nameTypeParameter1,
- 	     'nameTypeParameterN) 
-   	    name = 
+ 	     'nameTypeParameterN)
+   	    name =
          typeToDefine
-    
+
   type ('valType) labeledList =
-    string * ('valType list) 
+    string * ('valType list)
 	\end{lstlisting}
 \end{frame}
 
 
 \begin{frame}[fragile]
 	\frametitle{Créer un type}
-	\framesubtitle{Le type somme}
+	\framesubtitle{Types somme}
 	\begin{columns}
 		\begin{column}{5cm}
 			\begin{lstlisting}
     | Heart
     | Diamond
     | Club
-  
-  type card = 
+
+  type card =
     cardColor * cardFigure
 			\end{lstlisting}
 		\end{column}
 	\end{columns}
 \end{frame}
 
+
+\begin{frame}[fragile]
+	\frametitle{Créer un type}
+	\framesubtitle{Types enregistrements}
+	\begin{itemize}
+	\item Déclaration de type:
+		\begin{lstlisting}
+		  type pixel =
+		  {
+		     mutable r:float;
+		     mutable g:string;
+		     b:int;
+		  }
+
+		let p = { r=2.4; g="The Game"; b=255 }
+		\end{lstlisting}
+	\item Accès aux champs et modification de leur valeur :
+		\begin{lstlisting}
+			  p.b;;
+			  -: int = 255
+			  p.g <- "You Lose"
+		\end{lstlisting}
+	\end{itemize}
+\end{frame}
+
+
+
 \begin{frame}[fragile]
 	\frametitle{Les exceptions}
 	\begin{lstlisting}
 		\begin{lstlisting}
   raise Help
   raise (HelpNbErr 451)
-  
+
   invalid_arg "element parameter"
   failwith "uninitialized Graphics"
 		\end{lstlisting}
 			\begin{minipage}{4.2cm}
 				\lstset{basicstyle=\scriptsize}
 				\begin{lstlisting}
-try expr with 
+try expr with
 | Exc1 -> expr1
 | Exc2 (v1,v2) -> expr2
 | Excn -> exprn
 			\begin{minipage}{5cm}
 				\lstset{basicstyle=\scriptsize}
 				\begin{lstlisting}
-try expr with 
+try expr with
 | MyExc -> print_string "lol"
-| Invalid_argument n -> 
+| Invalid_argument n ->
     print_string ("InvArg:"^n)
 | Failure -> exit (-1)
 				\end{lstlisting}

File conf/slides/imperatif.tex

 %\begin{frame}[fragile]
 %  \frametitle{le noyaux imperatif}
 %  \framesubtitle{les entrées-sorties}
-%  les canaux : 
+%  les canaux
 %  \begin{lstlisting}
 %      open_in
 %      open_out
 				\begin{column}{3cm}
 					\begin{lstlisting}
   begin
-    expr1; 
+    expr1;
     .
     .
     .
 				\end{column}
 				\begin{column}{7cm}
 					\begin{lstlisting}
-  ( 
-    expr1; 
+  (
+    expr1;
     .
     .
     .
     \frametitle{Les boucles}
     \begin{block}{La boucle for}
 	\begin{lstlisting}
-	  for nom = expr1 to expr2 do 
+	  for name = expr1 to expr2 do
 	    expr3
 	  done
 
-	  for nom = expr1 downto expr2 do
+	  for name = expr1 downto expr2 do
 	    expr3
 	  done
 	\end{lstlisting}

File conf/slides/intro.tex

 \section*{Introduction}
 \begin{frame}
-	\frametitle{Les languages rationnels}
+	\frametitle{Les langages fonctionnels}
 	\includegraphics[width=9cm]{pics/history.png}
 \end{frame}
 
 \begin{frame}
 	\frametitle{L'OCaml}
 	\begin{itemize}
-		\item OCaml est un language fonctionnel...
-		\item ... mais pas que : Imperatif et orienté objet
+		\item OCaml est un langage fonctionnel...
+		\item ... mais pas que : Imperatif et Orienté Objet
 		\item Interprété mais aussi compilable en natif
 		\item Peut être utilisé avec d'autres langages dans un projet
 	\end{itemize}

File conf/slides/modules.tex

 		\begin{lstlisting}
   open List
 
-  length 
+  length
     (1::3::3::7::[])
 		\end{lstlisting}
 	\end{block}
 	\begin{block}{Sans \textit{open}}
 		\begin{lstlisting}
-  List.length 
+  List.length
     (1::3::3::7::[])
 		\end{lstlisting}
 	\end{block}
 
 (* Class with initialization parameter *)
 class point :
-  int * int -> 
+  int * int ->
     object
       val pos : int * int
       method printCoord : unit -> unit
 	\lstset{basicstyle=\small}
 	\begin{lstlisting}
 (* Class with type parameter *)
-class ['a] storage = 
-  object 
+class ['a] storage =
+  object
     val mutable data : 'a list
-    method addData : 'a -> unit 
+    method addData : 'a -> unit
   end
 	\end{lstlisting}
 \end{frame}
 
 \subsection{La compilation avec ocamlbuild} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \begin{frame}[fragile]
-	\frametitle{Les differents modes d'exécution}
+	\frametitle{Les différents modes d'exécution}
 	\huge
 	\begin{itemize}
-		\item ocaml : Interprétation directe 
+		\item ocaml : Interprétation directe
 		\item ocamlc : Compilation byte-code
 		\item ocamlopt : Compilation native
 	\end{itemize}
 			\item Lister les fichiers sources
 			\item Trouver/Indiquer les chemins d'accès des bibliothèques
 			\item Indiquer les outils de compilation
-			\item Générer les fichiers correspondant à chaque étape de la compilation
+			\item Générer les fichiers correspondants à chaque étape de la compilation
 			\item Gérer les dépendances entre les modules
 		\end{itemize}
 	\end{center}
 	\end{block}
 	\begin{block}{Commande}
 		\begin{lstlisting}
-  # ocamlbuild previousEx.docdir/index.html
+  42sh$ ocamlbuild previousEx.docdir/index.html
 		\end{lstlisting}
 	\end{block}
 \end{frame}
 	\frametitle{Les commentaires de ocamldoc 1/2}
 	\lstset{basicstyle=\scriptsize}	
 	\begin{lstlisting}
-(** The first special comment of the file is the 
+(** The first special comment of the file is the
     comment associated with the whole module.*)
 
 (******************************************************)
-(** Comments like the one above, with more than two 
+(** Comments like the one above, with more than two
     asterisks, are ignored. *)
 
 (** The comment for function f. *)

File conf/slides/objet.tex

 class name parameters =
   object
     (*Attributes*)
-    
+
     (*Methods*)
   end
 		\end{lstlisting}
 	\begin{lstlisting}
 class putListInStack (l:int list) =
   object (self)
-    
+
   val data = Stack.create ()
 
   initializer
     let rec storage = function
       | [] -> ()
-      | e::q -> 
+      | e::q ->
         push e data;
         storage q
     in storage l
 	\frametitle{Attributs polymorphiques}
 	\begin{lstlisting}
 class ['a] name parameters =
-  object 
+  object
   val data = ref []
 
   method add (e:'a) =
     data := e::!data
-  
+
   ...
   end
 	\end{lstlisting}
 
 \subsection{L'héritage} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \begin{frame}[fragile]
-	\frametitle{Syntaxe de l'héritage}
+	\frametitle{Héritage}
 	\begin{lstlisting}
 class childName parameters =
   object
-  inherit motherClass mothersParameters
+  inherit parentClass parentsParameters
 
   end
 	\end{lstlisting}
 	\begin{lstlisting}
 class childName parameters =
   object
-  inherit motherClass mothersParameters 
-    as motherSuper
+  inherit parentClass parentsParameters
+    as superParentClass
 
   end
 	\end{lstlisting}
 \begin{frame}
 	\frametitle{Accès aux méthodes de la classe mère 2/2}
 	\textit{Le type d'une réécriture d'une méthode doit correspondre à celui de la méthode mère.}
+	\textit{Pas de surcharge de fonction en OCaml}
 	\lstinputlisting[firstline=16, lastline=28]{code/heritage.ml}
 \end{frame}
 \subsection{Le polymorphisme de sous-type} %%%%%%%%%%%%%%%%%%%%%%%%%%%
 	Réutilisons les class point et colored\_point.
 	\begin{lstlisting}
 let f (o:point) = o#setCoord 4 2
-let test = 
+let test =
   ((new colored_point (4,2) 255):>point)
 
 test#print;

File conf/slides/sdl.tex

 			\begin{block}{L'initialisation de base}
 				\lstset{basicstyle=\small}
 				\begin{lstlisting}
-  Sdl.init [`EVERYTHING] 
+  Sdl.init [`EVERYTHING]
 				\end{lstlisting}
 			\end{block}
 			\begin{block}{L'initialisation et ouverture d'une fenêtre}
 				\begin{lstlisting}
   Sdl.init [`EVERYTHING]
 
-  let screen = 
-   Sdlvideo.set_video_mode 
+  let screen =
+   Sdlvideo.set_video_mode
    ~w ~h ~bpp [`HWSURFACE]
 				\end{lstlisting}
 			\end{block}
 			\end{block}
 		\end{column}
 		\begin{column}{3.3cm}
-			\begin{block}{types d'initialisation}
+			\begin{block}{Types d'initialisation}
 				\begin{itemize}
 					\item `AUDIO
 					\item `CDROM
 		\includegraphics[width=3cm]{pics/rect.png}
 	\end{minipage}
 	\begin{minipage}{0.4\textwidth}
-		\begin{block}{Position et dimention}
+		\begin{block}{Position et dimension}
 			\lstset{basicstyle=\footnotesize}
 			\begin{lstlisting}
   type rect = {
     mutable r_y : int;
     mutable r_w : int;
     mutable r_h : int;
-  } 
+  }
 			\end{lstlisting}
 		\end{block}
 	\end{minipage}\end{center}
 
 \begin{frame}[fragile]
 	\frametitle{Le chargement d'image}
-	\begin{block}{Charger/Sauver une image .bmp}
+	\begin{block}{Charger/Sauvegarder une image .bmp}
 		\begin{lstlisting}
   val load_BMP : string -> surface
 
   let c = ((255,255,255):color)
 		\end{lstlisting}
 	\end{block}
-	\begin{block}{Fonctions de convertion}
+	\begin{block}{Fonctions de conversion}
 		\begin{lstlisting}
-  val map_RGB : surface -> ?alpha:int -> 
+  val map_RGB : surface -> ?alpha:int ->
     color -> int32
   val get_RGB : surface -> int32 -> color
-  val get_RGBA : surface -> int32 -> 
+  val get_RGBA : surface -> int32 ->
     color * int
 		\end{lstlisting}
 	\end{block}
 	\end{block}
 	\begin{block}{Modification de la surface}
 		\begin{lstlisting}
-  val get_pixel : surface -> x:int -> 
+  val get_pixel : surface -> x:int ->
     y:int -> int32
 
-  val put_pixel : surface -> x:int -> 
+  val put_pixel : surface -> x:int ->
     y:int -> int32 -> unit
 		\end{lstlisting}
-		\textit{Existe aussi en version prenant le format color au lieu du int32. Pour cela ajouter le suffixe \_color à la fonction.}
+		\textit{Existe aussi en version prenant le type color au lieu de int32. Pour cela ajouter le suffixe \_color à la fonction.}
 	\end{block}
 \end{frame}
 
 	\begin{center}
 		\includegraphics[width=3.6cm]{pics/surfacesMerge.png}
 	\end{center}
-	\begin{block}{Écraser/faire un fond de couleur}
+	\begin{block}{Écraser/Créer un fond de couleur}
 		\begin{lstlisting}
-  val fill_rect : ?rect:rect -> surface -> 
+  val fill_rect : ?rect:rect -> surface ->
     int32 -> unit
 		\end{lstlisting}
 	\end{block}
 	\begin{block}{Coller une surface sur une autre}
 		\begin{lstlisting}
-  val blit_surface : src:surface -> 
-    ?src_rect:rect ->  dst:surface -> 
+  val blit_surface : src:surface ->
+    ?src_rect:rect ->  dst:surface ->
     ?dst_rect:rect -> unit -> unit
 		\end{lstlisting}
 	\end{block}
 	\end{center}
 	\begin{block}{La surface \og{}Fenêtre utilisateur\fg}
 		\begin{lstlisting}
-  val set_video_mode : w:int -> 
-    h:int -> ?bpp:int -> 
+  val set_video_mode : w:int ->
+    h:int -> ?bpp:int ->
     video_flag list -> surface
-  val get_video_surface : unit -> 
+  val get_video_surface : unit ->
     surface
 		\end{lstlisting}
 	\end{block}
 	\end{center}
 	\begin{block}{Fonction de rafraîchissement}
 		\begin{lstlisting}
-  val update_rect : ?rect:rect -> 
+  val update_rect : ?rect:rect ->
     surface -> unit
-  val update_rects : rect list -> 
+  val update_rects : rect list ->
     surface -> unit
 		\end{lstlisting}
 	\end{block}
 	\lstset{basicstyle=\footnotesize}
 	\begin{lstlisting}
 val create_RGB_surface_format : surface ->
-  [ `ASYNCBLIT | `HWSURFACE | `SRCALPHA 
+  [ `ASYNCBLIT | `HWSURFACE | `SRCALPHA
   | `SRCCOLORKEY | `SWSURFACE ] list ->
   w:int -> h:int -> surface
 
-val create_RGB_surface : 
-  [ `ASYNCBLIT | `HWSURFACE | `SRCALPHA 
+val create_RGB_surface :
+  [ `ASYNCBLIT | `HWSURFACE | `SRCALPHA
   | `SRCCOLORKEY | `SWSURFACE ] list ->
   w:int -> h:int -> bpp:int ->
   rmask:int32 -> gmask:int32 -> bmask:int32 ->
   val wait_event : unit -> event
 		\end{lstlisting}
 	\end{block}
-	\begin{block}{Traite la file des derniers événements}
+	\begin{block}{Traiter la file des derniers événements}
 		\begin{lstlisting}
   val poll : unit -> event option
 		\end{lstlisting}
 \end{frame}
 
 \begin{frame}[fragile]
-	\frametitle{Les differents types d'événement}
+	\frametitle{Les différents types d'événements}
 	\lstset{basicstyle=\small}
 	\begin{lstlisting}
 type event =
 			\begin{lstlisting}
   type mousemotion_event = {
     mme_which : int;
-    mme_state : 
+    mme_state :
       Sdlmouse.button list;
     mme_x : int;
     mme_y : int;
 			\begin{lstlisting}
   type mousebutton_event = {
     mbe_which : int;
-    mbe_button : 
+    mbe_button :
       Sdlmouse.button;
     mbe_state : switch_state;
     mbe_x : int;
 	\frametitle{Boucle Principale}
 	\begin{lstlisting}
 let update () =
-  let ticks = (*17ms -> 60fps *) 
-    17 + Sdltimer.get_ticks () 
+  let ticks = (*17ms -> 60fps *)
+    17 + Sdltimer.get_ticks ()
   in
   updateEvent();
   updateDisplay();
-  while (Sdltimer.get_ticks ()) <= ticks do 
+  while (Sdltimer.get_ticks ()) <= ticks do
     () done
 	\end{lstlisting}
 \end{frame}
 \begin{frame}[fragile]
 	\frametitle{Gestion des événements}
 	\begin{lstlisting}
-let updateEvent () = 
+let updateEvent () =
   match Sdlevent.poll () with
   | None -> ()
-  | Some (Sdlevent.KEYDOWN key) -> 
+  | Some (Sdlevent.KEYDOWN key) ->
     keyDownManager key
-  | Some (Sdlevent.MOUSEBUTTONDOWN button) -> 
+  | Some (Sdlevent.MOUSEBUTTONDOWN button) ->
     buttonDownManager button
   | Some Sdlevent.QUIT -> Sdl.quit ()
   | _ -> ()
 	\frametitle{Modification et déplacement des élements visuels}
 	\lstset{basicstyle=\scriptsize}
 	\begin{lstlisting}
-val blit_surface : src:surface -> ?src_rect:rect -> 
+val blit_surface : src:surface -> ?src_rect:rect ->
   dst:surface -> ?dst_rect:rect -> unit -> unit
 	\end{lstlisting}
-	\textit{Soit displayData une file de fonctions Sdlvideo.blit\_surface dont tout les paramètres sont renseignés sauf le unit final}
+	\textit{Soit displayData une file de fonctions Sdlvideo.blit\_surface dont tous les paramètres sont renseignés sauf le unit final}
 	\lstset{basicstyle=\normalsize}
 	\begin{lstlisting}
-let updateDisplay () = 
+let updateDisplay () =
   while not (is_empty displayData) do
     (take displayData) ()
   done

File conf/slides/struDonnees.tex

-
-\section{Quelques structures de données}
-\subsection{Les enregistrements}
-
 \begin{frame}
 	\begin{center}
-		\huge 
+		\huge
 		Les structures de données
 	\end{center}
 \end{frame}
 
 
+\section{Quelques structures de données}
 \begin{frame}[fragile]
-	\frametitle{Enregistrements}
+	\frametitle{Les références}
+	Une référence est considérée comme l'équivalent (selon l'INRIA) des pointeurs en OCaml.\\
 	\begin{itemize}
-	\item Déclaration de type: 
+	\item Déclaration
 		\begin{lstlisting}
-		  type pixel = 
-		  { 
-		     mutable r:float; 
-		     mutable g:string; 
-		     b:int;
-		  } 
-		
-		let p = { r=2.4; g="The Game"; b=255 }
+		  let a = ref 0
 		\end{lstlisting}
-	\item Accès et modification des champs de valeur:
+	\item Utilisation
 		\begin{lstlisting}
-			  p.b;;
-			  -: int = 255
-			  p.g <- "You Lose"
-		\end{lstlisting}
-	\end{itemize}
-\end{frame}
-
-
-\begin{frame}[fragile]
-	\frametitle{Les références}
-	Une référence est considérée comme l'équivalent (selon l'INRIA) des pointeurs en OCaml.\\
-	Déclaration:
-	\begin{lstlisting}
-		  let a = ref 0
-
-	\end{lstlisting}
-	Utilisation:
-	\begin{lstlisting}
 		  !a ;;
 		  - : int = 0
 		  a := !a + 1 ;;
 		  - : unit = ()
-	\end{lstlisting}
+		\end{lstlisting}
+	\end{itemize}
 
 \end{frame}
 
 \begin{frame}[fragile]
 	\frametitle{Les vecteurs}
 	\framesubtitle{Copie et valeurs partagées}
-	\begin{block}{Soit une copie simple}
 	\begin{lstlisting}
 	let v = Array.make 3 1;;
 	val v : int array = [|1; 1; 1|]
 	m;;
 	-: int array = [|1; 1; 1|]
 	\end{lstlisting}
-	\end{block}
 \end{frame}
 
 \begin{frame}[fragile]
 	
 	\item Array.iter
 
-	\item Array.map 
+	\item Array.map
 
 	\item Array.iteri
 

File conf/themeHfo.tex

 	\hspace{0,3cm}
 	GConfs - Conférence OCaml
 	\hspace{0.3cm}
-	Philémon GARDET 
-	\hspace{0,3cm} 
+	Philémon GARDET
+	\hspace{0,3cm}
 	\large
 	\insertframenumber/\inserttotalframenumber
 }