\chapterimage{caml} \chaptertext{Un tutoriel très très léger pour débuter avec OCAML} \chapter{CAML pour l'impatient} \caml \section{Installation et utilisation} Pour tous les O.S. il existe des distributions de CAML \emph{clé-en-main} sur le page de Jean Mouric: \href{http://pagesperso-orange.fr/jean.mouric/}{http://pagesperso-orange.fr/jean.mouric/}. Pour les utilisateurs de Emacs, vous pouvez charger le mode tuareg: \href{http://www.emacswiki.org/emacs/TuaregMode}{http://www.emacswiki.org/emacs/TuaregMode}. CAML sous Emacs avec le mode tuareg: \begin{figure} \begin{center} \includegraphics[width=\linewidth]{caml1} \end{center} \end{figure} CAML sous JavaCaml: \begin{figure} \begin{center} \includegraphics[width=\linewidth]{caml2} \end{center} \end{figure} Pour utiliser l'interpréteur dans un terminal, on utilisera \verb+ledit+ qui permet d'avoir quelques fonctionnalités comme l'accès à l'historique par les flèches: \begin{lstlisting}[caption={}] $ ledit ocaml \end{lstlisting} \section{Quelques ressources électroniques} \begin{itemize} \item Une passionnante introduction à OCAML par un de ses papas... \href{http://caml.inria.fr/pub/distrib/books/llc.pdf}{http://caml.inria.fr/pub/distrib/books/llc.pdf} \item Le manuel de référence de CAML par Xavier \textsc{Leroy} et Pierre \textsc{Weis}: \href{http://caml.inria.fr/pub/distrib/books/manuel-cl.pdf}{http://caml.inria.fr/pub/distrib/books/manuel-cl.pdf} \item Une introduction à CAML: \href{http://fr.wikibooks.org/wiki/Objective\_Caml}{http://fr.wikibooks.org/wiki/Objective\_Caml} \item Ouvrage de référence CAML: \href{http://www.pps.jussieu.fr/Livres/ora/DA-OCAML/}{http://www.pps.jussieu.fr/Livres/ora/DA-OCAML/} \item Ressources CAML: \href{http://caml.inria.fr/resources/index.fr.html}{http://caml.inria.fr/resources/index.fr.html} \item Un tutoriel en français: \href{http://www.ocaml-tutorial.org/tutoriel\_objective\_caml}{http://www.ocaml-tutorial.org/tutoriel\_objective\_caml} \end{itemize} \section{Les nombres} Nous utiliserons dans tout le document la version basique de CAML (en fait OCAML (c'est-à-dire CAML avec des modules pour faire de la programmation orientée objet) ou CAML Light (c'est la version de base que nous utiliserons)) sans charger de modules complémentaires sauf éventuellement pour créer des graphiques ou travailler sur certaines listes. Nous travaillerons en mode \emph{toplevel} c'est-à-dire que nous compilerons automatiquement de manière interactive. Pour se repérer, ce que nous taperons sera précédé d'un \# et ce que renverra CAML sera précédé le plus souvent d'un -. On peut travailler avec des entiers: \begin{lstlisting}[caption={}] # 1+2;; - : int = 3 \end{lstlisting} Vous remarquerez que CAML répond que le résultat de 1+2 est un entier (\verb+int+) égal à 3. En effet, CAML est adepte de l'\emph{inférence de type}, c'est-à-dire qu'il devine quel type de variable vous utilisez selon ce que vous avez tapé. Nous en reparlerons plus bas. Les priorités des opérations sont respectées. En cas d'ambiguïté, un parenthésage implicite à gauche est adopté: \begin{lstlisting}[caption={}] # 1+2*3;; - : int = 7 # 1-2+3;; - : int = 2 # 1-(2+3);; - : int = -4 # (1+2)*3;; - : int = 9 \end{lstlisting} La division renvoie le quotient entier bien sûr: \begin{lstlisting}[caption={}] # 11/3;; - : int = 3 # 11/3*2;; - : int = 6 # 11/(3*2);; - : int = 1 \end{lstlisting} On peut utiliser \verb+mod+ pour le reste entier: \begin{lstlisting}[caption={}] # 7 mod 2;; - : int = 1 # 7/2;; - : int = 3 # 7-7/2*2;; - : int = 1 \end{lstlisting} Enfin, les entiers sont de base compris entre $-2^{31}$ et $2^{31}-1$ sur un processeur 32 bits et entre $-2^{63}$ et $2^{63}-1$ sur un processeur 64 bits. \begin{lstlisting} # max_int;; - : int = 4611686018427387903 \end{lstlisting} On peut travailler avec des nombres écrits dans des bases différentes en les faisant précéder de \verb+0b+ pour la notation binaire, \verb+0o+ pour la notation octale et \verb+0x+ pour la notation hexadécimale: \begin{lstlisting} # 0xa;; - : int = 10 # 0xa0;; - : int = 160 # 0b1011;; - : int = 11 \end{lstlisting} Les nombres non entiers sont de type \emph{float}. Ils sont représentés en interne par deux entiers:~une \emph{mantisse} $m$ et un exposant $n$ tel que le nombre flottant soit $m\times 2^{n}$. En externe, il apparaît sous forme décimale, le séparateur étant le point. \begin{lstlisting}[caption={}] # 1.;; - : float = 1. \end{lstlisting} Attention alors aux opérations: \begin{lstlisting}[caption={}] # 3.14 + 2;; Characters 0-4: 3.14 + 2;; ^^^^ Error: This expression has type float but an expression was expected of type int \end{lstlisting} Cela indique que vous avez utilisé l'addition des entiers pour ajouter un entier à un flottant. CAML en effet n'effectue pas de conversion implicite et demande que celle-ci soit explicite. Cela peut apparaître comme contraignant mais permet l'inférence de type qui évite nombre de \og bugs\fg{}. Les opérations arithmétiques sur les entiers doivent donc être suivies d'un point: \begin{lstlisting}[caption={}] # 1. +. 2.1 ;; - : float = 3.1 # 1.2 +. 2.1 ;; - : float = 3.3 # 1./.2.;; - : float = 0.5 # 1.5e-5 *. 100. ;; - : float = 0.0015 # sqrt(2.);; - : float = 1.41421356237309515 # 3.**2.;; - : float = 9. # log(2.);; - : float = 0.693147180559945286 # exp(1.);; - : float = 2.71828182845904509 # cos(0.);; - : float = 1. # cos(2.*.atan(1.));; - : float = 6.12303176911188629e-17 # sin(2.*.atan(1.));; - : float = 1. # 1./.0.;; - : float = infinity \end{lstlisting} Il existe des moyens de convertir un entier en flottant: \begin{lstlisting}[caption={}] # float(1) +. 3.1;; - : float = 4.1 # float 1 +. 3.1;; - : float = 4.1 \end{lstlisting} et inversement: \begin{lstlisting}[caption={}] # int_of_float(sqrt(2.));; - : int = 1 \end{lstlisting} Il ne faut pas confondre \verb+int_of_float+ et \verb+floor+ \begin{lstlisting}[caption={}] # floor(2.1);; - : float = 2. # int_of_float(2.1);; - : int = 2 # floor(-2.1);; - : float = -3. # int_of_float(-2.1);; - : int = -2 \end{lstlisting} \section{Les autres types de base} \subsection{Les booléens} Ils sont bien sûr au nombre de deux:~\verb+true+ et \verb+false+. Nous en aurons besoin pour les tests. Les fonctions de comparaison renvoient un booléen. On peut combiner des booléens avec \verb+not+, \verb+&+ et \verb+or+: \begin{lstlisting}[caption={}] # 3>2;; - : bool = true # 3 == 2;; - : bool = false # (3>2) && (3=2);; - : bool = false # (3>2) || (3=2);; - : bool = true # (3>2) && not(3=2);; - : bool = true # (3>2) && not(3=2) && (0<1 || 1>0);; - : bool = true \end{lstlisting} On peut utiliser \verb+3 = 2+ ou \verb+3 == 2+ mais cela mérite attention pour les valeurs qui ne sont pas de type booléen ou entier: \begin{lstlisting}[caption={}] # let n = 1;; val n : int = 1 # let m = 1;; val m : int = 1 # n = m;; - : bool = true # n == m;; - : bool = true \end{lstlisting} mais \begin{lstlisting}[caption={}] # let x = 1.0;; val x : float = 1. # let y = 1.0;; val y : float = 1. # x = y ;; - : bool = true # x == y ;; - : bool = false \end{lstlisting} L'égalité structurelle \verb+=+ explore leur structure alors que l'égalité physique \verb+==+ teste si les deux valeurs occupent la même zone mémoire. \subsection{Les chaînes de caractères} En anglais:~\emph{string}. On les entoure de guillemets vb+"+ et on les concatène avec \verb+^+: \begin{lstlisting}[caption={}] # "Tralala "^"pouet pouet";; - : string = "Tralala pouet pouet" \end{lstlisting} \subsection{Les caractères} En CAML:~\emph{char}. On les utilisera surtout pour la cryptographie. Il sont entrés entre accents aigus: \begin{lstlisting}[caption={}] # 'a';; - : char = 'a' \end{lstlisting} On peut faire des aller-retours caractère/code ASCII : \begin{lstlisting}[caption={}] # int_of_char 'a';; - : int = 97 # char_of_int 97;; - : char = 'a' \end{lstlisting} \section{Les n-uplets} Entre parenthèses, ils permettent de grouper plusieurs valeurs qui peuvent être de types différents: \begin{lstlisting} # (1,"1",1.0,'1');; - : int * string * float * char = (1, "1", 1., '1') \end{lstlisting} \section{Listes et tableaux} Il existe un type tableau (ou vecteur) comme dans de nombreux langages. Sa longueur est fixée lors de sa création ce qui permet d'avoir accès à ses composantes: \begin{lstlisting}[caption={}] # let t = [|1;2;3|] ;; val t : int array = [|1; 2; 3|] # t.(2) ;; - : int = 3 \end{lstlisting} Il existe un type liste qui est chaînée et dont le longueur est donc dynamique mais on n'a accès qu'à son premier élément comme nous le verrons plus tard. On a cependant un opérateur binaire de concaténation \verb+@+: \begin{lstlisting}[caption={}] # let liste = [1;2;3] ;; val liste : int list = [1; 2; 3] # 0::liste ;; - : int list = [0; 1; 2; 3] # [1;2] @ [3;4];; - : int list = [1; 2; 3; 4] \end{lstlisting} Attention! L'inférence de type a ses petites manies: \begin{lstlisting}[caption={}] # [1; "deux" ; 3.0];; Characters 4-10: [1; "deux" ; 3.0];; ^^^^^^ Error: This expression has type string but an expression was expected of type int # [1; 2 ; 3.0];; Characters 8-11: [1; 2 ; 3.0];; ^^^ Error: This expression has type float but an expression was expected of type int \end{lstlisting} \section{Création de types} On n'insistera pas sur ce point pour l'instant. Voyons juste un exemple simple: \begin{lstlisting}[caption={}] # type couleur = Trefle | Carreau | Coeur | Pique ;; type couleur = Trefle | Carreau | Coeur | Pique # [Trefle ; Carreau] ;; - : couleur list = [Trefle; Carreau] \end{lstlisting} \section{Les déclarations} \subsection{Cas général} C'est comme en maths...mais en anglais! Donc \emph{Soit} se dit \emph{Let}: \begin{lstlisting}[caption={}] # let x=3*2;; val x : int = 6 # 2+x;; - : int = 8 # let pi=acos(-1.);; val pi : float = 3.14159265358979312 # sin(pi/.2.);; - : float = 1. \end{lstlisting} Le nom des identificateurs doit commencer par une lettre minuscule. \subsection{Déclarations locales} On peut définir \emph{localement} une variable, c'est-à-dire que sa portée ne dépassera pas l'expression où elle a été définie: \begin{lstlisting}[caption={}] # let x = 3 in x + 1 ;; - : int = 4 \end{lstlisting} La définition est bien locale: \begin{lstlisting}[caption={}] # x ;; Characters 0-1: x ;; ^ Error: Unbound value x \end{lstlisting} \begin{lstlisting}[caption={}] let (x,y) = (1,2) in x + y ;; - : int = 3 \end{lstlisting} \subsection{Déclarations simultanées} On utilise \verb+and+ qu'il ne faudra donc pas confondre avec \verb+&+ ou bien on peut utiliser un n-uplet : \begin{lstlisting}[caption={}] # let x=3 and y=5;; val x : int = 3 val y : int = 5 # x+y;; - : int = 8 # let (a,b)=(3.,5.);; val a : float = 3. val b : float = 5. \end{lstlisting} \section{Fonctions} Une expression fonctionnelle est un paramètre formel (le nom de la variable) suivi d'un corps qui est une expression. On peut créer des fonctions avec \verb+function+: \begin{lstlisting}[caption={}] # let delta = function | (a,b,c) -> b*b-4*a*c;; val delta : int * int * int -> int = # delta(1,1,1);; - : int = -3 \end{lstlisting} Notez le \verb+val delta : int * int * int -> int = + qui indique que la fonction construite...est une fonction (\verb++) qui va de $\bbz^3$ dans $\bbz$. On peut de manière plus standard (informatiquement parlant~!) définir la fonction par son expression générale: \begin{lstlisting}[caption={}] # let discriminant(a,b,c)=b*b-4*a*c;; val discriminant : int * int * int -> int = # discriminant(1,1,1);; - : int = -3 \end{lstlisting} On peut disjoindre des cas: c'est le fameux \textbf{filtrage par motif} (\og pattern matching\fg{}) \begin{lstlisting}[caption={}] # let sina = function | 0. -> 1. | x -> sin(x)/.x;; val sina : float -> float = # sina(0.);; - : float = 1. # sina(0.1);; - : float = 0.998334166468281548 \end{lstlisting} On peut rendre le paramètre du filtrage explicite: \begin{lstlisting}[caption={}] let rec factorielle n = match n with | 0 -> 1 | n -> n * factorielle (n-1);; \end{lstlisting} On peut travailler avec autre chose que des nombres: \begin{lstlisting}[caption={}] # let mystere = function | (false,true) -> true | (true,false) -> true | _ -> false;; val mystere : bool * bool -> bool = \end{lstlisting} Le tiret \verb+_+ indique \og dans tous les autres cas\fg{}. On peut aussi créer des fonctions \emph{polymorphes}, c'est-à-dire qui ne travaillent pas sur des types de variables particuliers. \begin{lstlisting}[caption={}] let composee(f,g) = function | x ->f(g(x));; val composee : ('a -> 'b) * ('c -> 'a) -> 'c -> 'b = \end{lstlisting} Ici, $f$ est toute fonction transformant un type de variable $a$ en un type de variable $b$ et $g$ une fonction transformant un type de variable $c$ en un type de variable $a$. La fonction composée transforme bien un type de variable $c$ en un type de variable $b$. Si nous reprenons la fonction définie précédemment: \begin{lstlisting}[caption={}] let carre = function | x -> x*.x;; val carre : float -> float = # composee(sina,carre);; - : float -> float = # composee(sina,carre)(3.);; - : float = 0.04579094280463962 \end{lstlisting} \section{If...then...else} On peut utiliser une structure conditionnelle pour définir une fonction: \begin{lstlisting}[caption={}] let valeur_abs(x)= if x>=0 then x else -x;; val valeur_abs : int -> int = \end{lstlisting} \section{Fonctions récursives} C'est une fonction construite à partir d'elle-même. On utilise la même syntaxe que pour une fonction simple mais on fait suivre le \verb+let+ d'un \verb+rec+: \begin{lstlisting}[caption={}] let rec factorielle = function | 0 -> 1 | n -> n*factorielle(n-1);; val factorielle : int -> int = let rec fact(n)= if n=0 then 1 else n*fact(n);; val fact : int -> int = \end{lstlisting} \section{Définition locale de fonctions} \begin{lstlisting} let nb_sol(a,b,c) = let delta(a,b,c) = b*b - 4*a*c in if delta(a,b,c) = 0 then 1 else if delta(a,b,c) < 0 then 0 else 2;; \end{lstlisting} \section{Récursion terminale} \begin{lstlisting}[caption={}] let rec succ = function |0 -> 1 |n -> 1 + succ(n-1) ;; val succ : int -> int = # succ(100000);; - : int = 100001 # succ(1000000);; Stack overflow during evaluation (looping recursion?). \end{lstlisting} On arrive à la limite de la pile. \begin{lstlisting}[caption={}] let succ(n) = let rec local = function | (0,acc) -> acc | (n,acc) -> local(n-1,1 + acc) in local(n,1);; val succ : int -> int = # succ(100000000);; - : int = 100000001 \end{lstlisting} \textsf{Caml} peut dérécursifier les récursions terminales et n'utilise plus sa pile qui ne peut donc plus être saturée. \section{Au cas zoù, on peut programmer en impératif} \subsection{Type unit} Il existe des fonctions qui jouent le rôles des procédures dans des langages impératifs et sont à effets de bords. \textsf{Ocaml} étant typé, il y a un type pour ces fonctions: \verb+unit+. \begin{lstlisting}[caption={}] # print_string "Tralala" ;; Tralala- : unit = () \end{lstlisting} Une autre action extra-fonctionnelle est la modification en place d'un vecteur à l'aide de \verb+<-+: \begin{lstlisting}[caption={}] # let v = [|1;2;3|];; val v : int array = [|1; 2; 3|] # v.(2) <- 37 ;; - : unit = () # v ;; - : int array = [|1; 2; 37|] \end{lstlisting} On évitera ce genre d'action extra-fonctionnelle dans la mesure du possible. \subsection{Références} Même si \textsf{Caml} fait une incursion dans la programmation impérative, il la clarifie un peu en obligeant à distinguer le nom d'une référence et son contenu. On ne pourra pas écrire \verb|x := x + 1| comme en C par exemple. La référence est crée avec \verb+ref+ et son contenu est accessible en faisant précéder son étiquette d'un \verb+!+: \begin{lstlisting}[caption={}] # let x = ref 0 ;; val x : int ref = {contents = 0} # x ;; - : int ref = {contents = 0} # x + 1 ;; Characters 0-1: x + 1 ;; ^ Error: This expression has type int ref but an expression was expected of type int # !x + 1 ;; - : int = 1 # x := !x + 3 ;; - : unit = () # x ;; - : int ref = {contents = 3} # !x ;; - : int = 3 \end{lstlisting} On remarque au passage qu'une réaffectation est bien du type \verb+unit+. \subsection{Boucles} La syntaxe est usuelle mais il faut faire attention à la distinction référence/contenu: \begin{lstlisting}[caption={}] (* POUR *) # let som_ent(n) = let s = ref 0 in for i=1 to n do s := !s + i done; !s;; val som_ent : int -> int = # som_ent(5) ;; - : int = 15 (* TANT QUE *) # let som_ent_w(n) = let s = ref 0 in let i = ref 0 in while (!i <= n) do begin s := !s + !i; incr i; end done; !s;; val som_ent_w : int -> int = # som_ent_w(5) ;; - : int = 15 \end{lstlisting} %%% Local Variables: %%% TeX-master: "Poly_Alg_Ana_info1" %%% End: