\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 = <fun>

# delta(1,1,1);;
- : int = -3
\end{lstlisting}


Notez le \verb+val delta  : int * int * int ->  int = <fun>+ qui indique
que la  fonction construite...est une fonction (\verb+<fun>+)  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 = <fun>

# 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 = <fun>

# 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 = <fun>
\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 = <fun>
\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 = <fun>

# composee(sina,carre);;
- : float -> float = <fun>

# 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 = <fun>
\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 = <fun>

let rec fact(n)=
      if n=0 then 1
      else n*fact(n);; 
    val fact : int -> int = <fun>
\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 = <fun>

# 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 = <fun>

# 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 = <fun>

# 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 = <fun>

# som_ent_w(5) ;;
- : int = 15
\end{lstlisting}



        
%%% Local Variables: 
%%% TeX-master: "Poly_Alg_Ana_info1"
%%% End: 

