\documentclass[twoside]{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage{actes,alltt,url,graphicx}
\usepackage[french]{babel}
\usepackage{mflogo} 
\usepackage{tikz}

% macros
\newcommand{\ocaml}{OCaml}
\newcommand{\camllight}{Caml Light}
\newcommand{\asymptote}{\textsf{Asymptote}}
\newcommand{\mlpost}{\textsc{Mlpost}}
\newcommand{\metapost}{\MP}
\newcommand{\fmpost}{\textit{functional} \metapost}
\newcommand{\metafont}{\MF}
\newcommand{\nomdetikz}{\textsf{TikZ}}
\newcommand{\pstricks}{\textsf{PSTricks}}
\newcommand{\dia}{\textsf{Dia}}
\newcommand{\xfig}{\textsf{Xfig}}
\newcommand{\postscript}{PostScript}
\newcommand{\mlpictex}{mlP\hspace{-0.2em}\raisebox{-0.2em}{i}\hspace{-0.1em}c\hspace{-0.1em}\TeX}

\title{Faire bonne figure avec \mlpost}

\author{R. Bardou$^1$
        \& J.-C. Fillitre$^1$
        \& J. Kanig$^1$
        \& S. Lescuyer$^1$}

\titlehead{Faire bonne figure avec \mlpost}%  a droite (page impaire)

\authorhead{Bardou \& Fillitre \& Kanig \& Lescuyer}% a gauche (page paire)

\affiliation{\begin{tabular}{rr} 
\\ 1:  ProVal / INRIA Saclay -- le-de-France
\\     91893 Orsay Cedex, France
\\     LRI / CNRS -- Universit Paris Sud
\\     91405 Orsay Cedex, France
\\     {\tt \{bardou,filliatr,kanig,lescuyer\}@lri.fr} 
\end{tabular}}

\begin{document}
\setcounter{page}{1}
\maketitle

\begin{abstract}
  Cet article prsente \mlpost, une bibliothque \ocaml\ de dessin
  scientifique. Elle s'appuie sur \metapost, qui permet notamment
  d'inclure des fragments \LaTeX\ dans les figures. \ocaml\ offre une
  alternative sduisante aux langages de macros \LaTeX, aux langages
  spcialiss ou mme aux outils graphiques. En particulier,
  l'utilisateur de \mlpost\ bnficie de toute l'expressivit
  d'\ocaml\ et de son typage statique. Enfin \mlpost\ propose un style
  dclaratif qui diffre de celui, souvent impratif, des outils existants.
\end{abstract}

% TODO ? : expliquer comment fait \metapost pour inclure du \LaTeX

% TODO : expliquer les labels

\section{Introduction}

Lors de la rdaction de documents  nature scientifique (articles,
cours, livres, etc.), il est trs souvent ncessaire de raliser des
figures. Ces figures permettent d'agrmenter le texte en illustrant
aussi bien les objets dont il est question dans le document que les
liens qui existent entre eux et facilitent ainsi leur comprhension.
Elles sont donc un composant fondamental au caractre didactique de
tels documents, mais leur ralisation est souvent fastidieuse. En
particulier, il est souvent ncessaire d'y inclure des lments mis en
forme par \LaTeX\ (formules, etc.), ce que bon nombre de logiciels de
dessin ne permettent pas. Ainsi, on peut souhaiter raliser un schma
tel que celui-ci
\begin{center}
  \includegraphics{yannick1.mps}
\end{center}
en attachant de l'importance au fait que des expressions comme
$a_1+s_1-1$ apparaissent exactement comme dans le corps du document.
Il existe plusieurs familles d'outils pour raliser des figures 
intgrer dans un document \LaTeX~:
\begin{itemize}
\item des interfaces graphiques disposant d'une sortie \LaTeX, telles
  que \dia~\cite{dia} ou \xfig~\cite{xfig} ;
\item des bibliothques \LaTeX, telles que \pstricks~\cite{pstricks}
  ou encore \nomdetikz~\cite{tikz} ; 
\item des outils externes en ligne de commande, tel que
  \metapost~\cite{metapost}.
\end{itemize}

% Il faudrait d'ailleurs dj que ces logiciels de dessin soient vectoriels
% ce qui n'est pas forcment le cas.

Chaque famille a ses avantages et ses inconvnients. Les interfaces
graphiques sont les plus accessibles, notamment pour un placement
rapide et intuitif des diffrents lments de la figure, mais
l'intgration de texte mis en forme par \LaTeX\ est dlicate. Dans le
cas de \xfig\ et de \dia, la taille des lments \LaTeX\ n'est pas
connue lors de l'dition de la figure ; en outre, dans le cas de \dia,
l'intgration de \LaTeX\ dans une figure ncessite de l'exporter sous
forme de macros \nomdetikz\ et d'diter le rsultat.

%% TODO : RAPPELER QUE PSTRICKS NE MARCHE PAS AVEC PDFLATEX !
Les bibliothques \LaTeX\ telles que \pstricks\ ou \nomdetikz\ offrent
l'intgration la plus naturelle avec \LaTeX. En particulier, elles
permettent de combiner arbitrairement lments graphiques et textes
\LaTeX\ 
\begin{tikzpicture}[baseline=(a.base)]
\path[use as bounding box] 
  (0,0) node[draw,style=dashed] (a) {comme ceci};
\draw[->] (a) .. controls +(-2cm,1cm) and +(-2cm,-0cm) .. (a);
\end{tikzpicture}.
En revanche, elles demandent d'apprendre un certain nombre de
macros et de notations et souffrent surtout des dfauts inhrents 
\LaTeX~:
\begin{itemize}
\item des erreurs dtectes uniquement  l'interprtation, peu claires
  et parfois mal localises ;
\item un langage \emph{de programmation} peu commode (syntaxe obscure,
  absence de typage, code difficile  structurer).
\end{itemize}
Ces inconvnients sont notamment un frein au dveloppement de
bibliothques de haut niveau au dessus de ces langages ainsi qu' la
rutilisation de figures.

\metapost\ se prsente comme une alternative  ces bibliothques
\LaTeX, en proposant un langage de programmation  part entire
spcialis dans la construction de figures contenant des lments
\LaTeX. Il permet notamment de manipuler symboliquement la taille et
la position de ces lments et de les relier de manire implicite par
des quations. En revanche, le langage de \metapost\ s'inspire de
celui de \metafont~\cite{metafont} et prsente,  l'exception de la
syntaxe, les dfauts soulevs ci-dessus. La figure~\ref{fig:metapost}
donne un exemple de programme/figure ralis avec \metapost.
\begin{figure}[t]
\vspace*{1em}
\begin{minipage}{.3\linewidth}
  \includegraphics{figmp.mps}
\end{minipage}
\begin{minipage}{.7\linewidth}
\small
\begin{alltt}
  vardef koch(expr A,B,n) =
    save C; pair C; C = A rotatedaround(1/3[A,B], 120);
    if n>0:
      koch( A,        1/3[A,B], n-1);
      koch( 1/3[A,B], C,        n-1);
      koch( C,        2/3[A,B], n-1);
      koch( 2/3[A,B], B,        n-1);
    else:
      draw A--1/3[A,B]--C--2/3[A,B]--B;
    fi;
  enddef;
  z0=(4cm,0); z1=z0 rotated 120; z2=z1 rotated 120;
  koch( z0, z1, 4 ); koch( z1, z2, 4 ); koch( z2, z0, 4 );
\end{alltt}
\end{minipage}
\caption{Exemple de figure \metapost}\label{fig:metapost}
\end{figure}
% Dans un souci d'exhaustivit, nous devons aussi mentionner
% \asymptote~\cite{asymptote}, galement un langage ddi  la cration
% de figures. Nous n'allons pas rentrer dans les dtails de cet outil
% car nous ne considrons plus les langages ddis par la suite.

Une alternative sduisante aux solutions prcdentes consiste 
utiliser un langage de programmation existant. Ainsi l'utilisateur n'a
pas  apprendre un langage spcialis et il bnficie d'autre part de
tous les avantages d'un langage de programmation moderne : erreurs
dtectes  la compilation, types de donnes complexes, structuration, etc.
Toute la difficult rside alors dans la manipulation des lments
\LaTeX, notamment la prise en compte de leur taille dans l'laboration
de la figure. Si on considre la famille des langages fonctionnels, on
peut citer au moins deux exemples de telle intgration :
\begin{itemize}
\item \mlpictex~\cite{mlpictex} est\footnote{ notre connaissance,
    \mlpictex\ n'est plus distribu.} un ensemble de macros \LaTeX\ permettant
  d'inclure du code \camllight\ arbitraire dans un document \LaTeX.
  Ce code s'appuie sur une bibliothque de dessin
  \postscript~\cite{postscript} et peut 
  faire rfrence  des lments \LaTeX, ainsi qu' leur taille.

\item \fmpost~\cite{fmpost} est une bibliothque
  Haskell~\cite{haskell} produisant du 
  code \metapost. C'est une approche lgre qui rutilise les
  capacits graphiques de \metapost\ et substitue Haskell au langage
  de programmation de \metapost.
\end{itemize}

Cet article prsente \mlpost, un outil qui adopte l'approche de
\fmpost\ en utilisant \ocaml~\cite{ocaml} comme langage hte. La
premire partie 
de l'article prsente les choix de conception de \mlpost\  travers un
certain nombre d'exemples. La seconde partie dtaille ensuite
l'architecture logicielle de \mlpost.
\mlpost\ est librement distribu  l'adresse
\url{http://mlpost.lri.fr}. 
Toutes les figures de cet article ont t faites avec \mlpost, 
l'exception des exemples pour \metapost\ et \nomdetikz.

%%% CONS

% pas de baseline

% pas de mlange entre LaTeX et les graphiques

\section{Principes et exemples}\label{exemples}

\subsection{Principes}

\paragraph{Botes.}
Les briques de base de \mlpost\ sont les \textit{botes} : une bote
est un moyen d'encapsuler n'importe quel lment de dessin au sein
d'un contour, qui peut tre effectivement trac ou non. On peut
construire la bote vide, des botes avec du \LaTeX\ arbitraire, etc.
Ces botes peuvent ensuite tre manipules : imbrication arbitraire,
placement  une position prcise, alignement de plusieurs botes,
flches reliant plusieurs botes entre elles, cration de tableaux,
etc. Plusieurs botes peuvent aussi tre regroupes au sein d'une
seule afin de pouvoir les dplacer ensemble.  L'exemple suivant montre
deux botes simples, la deuxime tant dplace un centimtre vers la
droite en utilisant la fonction \verb|shift|.

\medskip
\begin{minipage}{0.2\linewidth}
  \includegraphics{simple.mps}
\end{minipage}
\begin{minipage}{0.8\linewidth}
\small\begin{ocaml}
[ Box.draw (Box.tex "\\LaTeX");
  Box.draw (Box.shift (Point.pt (cm 1., zero)) (circle (empty ()))) ]
\end{ocaml}
\end{minipage}

\medskip\noindent
Une figure \mlpost\ est simplement une liste de commandes de
dessin. Ci-dessus, elle est rduite  deux occurrences de
\texttt{Box.draw}, la commande qui dessine une bote.
% Notez que par dfaut, le contour de la bote contenant du \LaTeX n'a
% pas t trac, alors que celui de la bote vide a t trac.

\paragraph{Placement relatif.}
Un principe que nous avons suivi lors de la conception de \mlpost{}
est de favoriser un placement relatif des objets plutt qu'absolu.
Ceci permet d'obtenir des figures plus robustes. En effet, imaginons
que l'on veuille placer une bote $A$  \emph{droite} d'une bote $B$.
Une premire possibilit serait de spcifier les positions
approximativement, par exemple en donnant les abscisses 0 cm pour $A$
et 2 cm pour $B$. Cependant, si on change d'avis sur le contenu de
$A$ et que la taille de cette bote change, $A$ risque alors de se
superposer  $B$. Il faut alors replacer toutes les botes de la
figure manuellement. Pour viter a, \mlpost\ propose diverses
mthodes pour placer les botes \emph{les unes par rapport aux
  autres}. On gagne alors du temps lors de la cration et lors des
modifications de la figure.  L'exemple suivant utilise l'alignement
horizontal \verb|hbox|, o l'argument optionnel \texttt{padding}
permet de spcifier l'espacement horizontal entre deux botes :

\medskip
\begin{minipage}{0.2\linewidth}
  \includegraphics{align.mps}
\end{minipage}
\begin{minipage}{0.8\linewidth}
\small\begin{ocaml}
[ Box.draw (Box.hbox ~padding:(cm 1.) 
                     [Box.tex "\\LaTeX"; circle (empty ())]) ]
\end{ocaml}
\end{minipage}

\medskip\noindent Nous revenons plus en dtail sur les botes et leur
implmentation dans la section~\ref{subsec:boxes}.

\paragraph{Persistance.}
Un autre choix que nous avons fait est celui de la
persistance~\cite{persistance} : 
lorsqu'un attribut d'une bote (positionnement, couleur, etc.) est
modifi, on obtient une nouvelle bote, identique  la premire sauf
en l'attribut chang. En faisant le choix de structures de donnes
persistantes, nous permettons  l'ancienne bote, avec ses attributs
inchangs, d'tre prserve et encore accessible. Ainsi, on peut
rutiliser plus facilement une bote  plusieurs endroits
du dessin, avec des attributs diffrents. Dans l'exemple suivant, on a
utilis trois instances de la mme bote \texttt{b}, dont le contour
est trac pour la deuxime.

\medskip
\begin{minipage}{0.2\linewidth}
  \includegraphics{persistance.mps}
\end{minipage}
\begin{minipage}{0.8\linewidth}
\small\begin{ocaml}
let b = 
  Box.hbox ~padding:(cm 1.) [Box.tex "\\LaTeX"; circle (empty ())] in
[ Box.draw (Box.vbox [b; set_stroke Color.black b; b]) ]
\end{ocaml}
\end{minipage}

%TODO exemple ici qui introduit les noms des boites et les avantages /
%inconvnients de la persistance

\subsection{Exemples}

Dans cette section, nous montrons quelques applications immdiates des
botes de \mlpost. 

% blocs mmoire (listes, etc.) -- JCF
% introduire Box.vblock
% introduire les noms de boites
\paragraph{Reprsentation de la mmoire.}
Un besoin rcurrent lorsque l'on enseigne l'algorithmique ou les
concepts lis  un langage de programmation consiste  illustrer
la structure des donnes en mmoire par des schmas de la forme
\begin{center}
  \includegraphics{list123.mps}
\end{center}
Deux lments sont ncessaires : le dessin des blocs d'une part et le
dessin des pointeurs d'autre part. Pour raliser les blocs, on utilise
la fonction \texttt{Box.hblock} qui aligne des botes horizontalement,
leur donne une hauteur commune et trace leur contour. Voici un exemple
:

\medskip
\begin{minipage}{0.15\linewidth}
  \includegraphics{simple_block.mps}
\end{minipage}
\begin{minipage}{0.8\linewidth}
\small\begin{ocaml}
let b = Box.hblock ~pos:`Bot [Box.tex "a"; Box.tex "b"; Box.tex "C"] in
[ Box.draw b ]
\end{ocaml}
\end{minipage}

\medskip\noindent  l'aide de \texttt{Box.hblock}, on peut facilement
crire une fonction \texttt{cons} qui construit un bloc de taille 2,
dont le premier lment contient un texte \LaTeX\ arbitraire
\texttt{hd} et le second est soit vide, soit le symbole $\bot$, selon
la valeur du boolen \texttt{tl} :
\begin{ocaml}
let cons hd tl =
  let p1 = Box.tex ~name:"hd" hd in
  let p2 = Box.tex ~name:"tl" (if tl then "" else "\\ensuremath{\\bot}") in
  Box.hblock [p1; p2]
\end{ocaml}
L'argument optionnel \texttt{\~{}name} permet de nommer les
sous-botes, de manire  pouvoir y accder facilement par la suite.

crivons maintenant une fonction \texttt{pointer\_arrow} pour
matrialiser les pointeurs. Il s'agit de tracer une flche entre deux
botes donnes \texttt{a} et \texttt{b}. Pour cela, on commence par
construire un chemin \texttt{p} reliant les centres de \texttt{a} et
\texttt{b}, que l'on tronque  l'endroit o il intersecte le bord de la bote
\texttt{b} (avec la fonction \texttt{Path.cut\_after}). Puis on trace
l'origine de la flche  l'aide d'un chemin rduit  un point (le
centre de \texttt{a}) et la flche proprement dite  l'aide du chemin
\texttt{p}.

\medskip
\begin{minipage}{0.2\linewidth}
  \includegraphics{block_arrow.mps}
\end{minipage}
\begin{minipage}{0.8\linewidth}
\small\begin{ocaml}
let pointer_arrow a b =
  let p = pathp [Box.ctr a; Box.ctr b] in
  let p = Path.cut_after (Box.bpath b) p in
  let pen = Pen.scale (bp 4.) Pen.circle in
  Command.draw ~pen (pathp [Box.ctr a]) ++ draw_arrow p
\end{ocaml}
\end{minipage}
%XXX virer ++ ?

\medskip\noindent On utilise ici le symbole infixe \texttt{++} qui
permet de concatner des commandes de dessin. On utilise d'autre
part \texttt{bp}, qui est une unit propre  \metapost, proche du
point \postscript.

Nous avons maintenant tous les lments ncessaires pour crire une
fonction \texttt{draw\_list} qui prend en argument une liste \ocaml\
de fragments \LaTeX\ et ralise l'illustration correspondante. On
commence par construire les diffrents blocs constituant la liste :
\begin{ocaml}
let draw_list l =
  let rec make = function
    | [] -> []
    | [x] -> [cons x false]
    | x :: l -> cons x true :: make l in
\end{ocaml}
Puis on aligne ces blocs avec \texttt{Box.hbox}, en insrant de
l'espace horizontal avec l'option \texttt{padding} :
\begin{ocaml}
  let l = hbox ~padding:(bp 30.) (make l) in
\end{ocaml}
Pour dessiner les pointeurs, il suffit de parcourir la liste des
botes (qui ont t places) et d'utiliser la fonction
\texttt{pointer\_arrow} prcdente sur chaque paire de botes
conscutives :
\begin{ocaml}
  let rec arrows = function
    | [] | [_] -> nop
    | b1 :: (b2 :: _ as l) -> 
        pointer_arrow (Box.get "tl" b1) (Box.get "hd" b2) ++ arrows l in
\end{ocaml}
On utilise ici la fonction \texttt{Box.get} qui permet de rcuprer
une sous-bote par son nom. On accde ainsi aux botes nommes
respectivement \verb!"hd"! et \verb!"tl"! qui ont t cres par la
fonction \texttt{cons} puis encapsules dans d'autres botes par les
fonctions d'alignement.
Enfin, on dessine les botes avec \texttt{Box.draw}, puis les flches
avec la fonction \texttt{arrows} :
\begin{ocaml}
  [ Box.draw l; arrows (Array.to_list (Box.elts l)) ]
\end{ocaml}
On peut tester avec
\begin{ocaml}
  draw_list (List.map (fun n -> Printf.sprintf "$\\sqrt{%d}$" n) [1;2;3;4])
\end{ocaml}
qui donne bien le rsultat attendu :
\begin{center}
  \includegraphics{another_list.mps}
\end{center}

% De manire gnrale, les
% fonctions \texttt{Box.tex} et \texttt{Box.box}, ainsi que toutes les
% autres fonctions de cration de botes, disposent d'arguments
% optionnels \texttt{dx} et \texttt{dy} permettant de spcifier les
% marges sparant le contenu du contour de la bote. 

\paragraph{Diagrammes de classes.}
Avec la fonction \texttt{Box.vblock}, analogue pour l'alignement
vertical de la fonction
\texttt{Box.hblock} introduite ci-dessus, il est facile
de dessiner des diagrammes UML. Supposons que l'on veuille dessiner
des schmas de classes tels que :
\begin{center}
  \includegraphics{uml_client.mps}
\end{center}
Pour cela, introduisons une fonction \texttt{classblock} qui attend le
nom de la classe ainsi que la liste des attributs et des mthodes. 
\begin{ocaml}
let classblock name attr_list method_list = 
  let vbox = Box.vbox ~pos:`Left in
  Box.vblock ~pos:`Left ~name
  [ tex ("{\\bf " ^ name ^ "}");
    vbox (List.map tex attr_list); vbox (List.map tex method_list) ]
\end{ocaml}
Ici, le nom \texttt{name} de la classe est utilis  la fois pour
dsigner le schma dans le diagramme (l'argument labelis \url{~name}
de \texttt{Box.vblock}) et comme titre du schma cr. Les attributs
et les mthodes sont aligns verticalement indpendamment, puis on
aligne le titre et les deux nouvelles botes obtenues en les
encadrant\footnote{Notez qu'au contraire de {\tt hbox} et {\tt vbox}, les
fonctions {\tt hblock} et {\tt vblock} tracent par dfaut le contour
de leurs sous-botes.}.  On peut maintenant s'en servir pour dessiner un
petit diagramme de classes :

\medskip
\begin{minipage}{0.35\linewidth}
  \includegraphics{uml.mps}
\end{minipage}
\begin{minipage}{0.6\linewidth}
\small\begin{ocaml}
let a = classblock "BankAccount" 
          [ "balance : Dollars = $0$"] 
          [ "deposit (amount : Dollars)"; 
            "withdraw (amount : Dollars)" ] in
let b = classblock "Client" 
          [ "name : String"; "address : String" ] [] in
let diag = Box.vbox ~padding:(cm 1.) [a;b] in
[ Box.draw diag; 
  box_label_arrow ~pos:`Left (Picture.tex "owns") 
    (get "Client" diag) (get "BankAccount" diag) ]
\end{ocaml}
\end{minipage}
\vspace{1em}

Ici, on a d'abord cr deux schmas de classe avec la fonction
\texttt{classblock}. Ces schmas sont ensuite aligns verticalement,
et une flche avec une tiquette est dessine entre ces deux classes
avec \texttt{box\_label\_arrow}. Le code pour cette figure est
conceptuellement trs simple, ne contient aucun placement absolu et ne
dpasse pas les 15 lignes de code.

% automate -- RB
\paragraph{Automates.}\label{sec:automates}
La thorie des langages est un domaine o l'on a  rapidement besoin de
dessiner des automates. Illustrons une faon 
d'utiliser \mlpost\ dans ce but. Nous allons dfinir les fonctions 
suivantes :
\begin{itemize}
\item \texttt{state} pour crer un tat ;
\item \texttt{final} pour transformer un tat en un tat final ;
\item \texttt{initial} pour dessiner une flche entrante sur un tat initial ;
\item \texttt{transition} pour dessiner une transition d'un tat  un autre ;
\item \texttt{loop} pour dessiner une transition d'un tat vers lui-mme.
\end{itemize}
On choisit de reprsenter les tats par des botes \mlpost.  La
fonction \texttt{state} est juste une sp\-ci\-ali\-sa\-tion de la
fonction {\tt Box.tex}  un contour circulaire, dfinie par
l'application partielle suivante:
\begin{ocaml}
let state = Box.tex ~style:Circle ~stroke:(Some Color.black)
\end{ocaml}
Le paramtre \texttt{stroke} permet de spcifier si le contour doit
tre trac et, le cas chant, dans quelle couleur. De manire
similaire, la fonction \texttt{final} est une spcialisation de la
fonction {\tt Box.box} dont le rle consiste  rajouter un cercle
autour d'une bote :
\begin{ocaml}
let final = Box.box ~style:Circle
\end{ocaml}

On peut dj placer des tats, finaux ou non,
et  les  dessiner.   Pour  le  placement,  on  utilise  les  fonctions
d'alignement    horizontal    et    vertical   \texttt{Box.hbox}    et
\texttt{Box.vbox}. On  suit donc le  principe consistant   placer les
objets de faon relative, les uns par rapport aux autres.

\begin{minipage}{0.2\linewidth}
  \includegraphics{automate_1.mps}
\end{minipage}
\begin{minipage}{0.7\linewidth}
\begin{ocaml}
let states = Box.vbox ~padding:(cm 0.8)
  [ Box.hbox ~padding:(cm 1.4)
      [ state ~name:"alpha" "$\\alpha$";
        state ~name:"beta" "$\\beta$" ];
    final ~name:"gamma" (state "$\\gamma$") ] in
[ Box.draw states ]
\end{ocaml}
\end{minipage}

\medskip\noindent On note que l'ensemble des tats est lui-mme une bote,
\texttt{states}, contenant les tats comme autant de sous-botes nommes.

La  fonction \texttt{initial} appose une  flche entrante   un
tat.  Il  s'agit donc  d'une fonction  qui prend le nom d'un tat
\texttt{q}  et qui 
renvoie une commande dessinant une  flche vers \texttt{q}. On pourrait aussi
renvoyer une  bote sans  contour contenant \texttt{q}  et la flche,  ce qui
permettrait   d'utiliser  \texttt{initial}  de   la  mme   faon  que
\texttt{final}.   Cependant, la  bote  obtenue n'aurait  pas la  mme
taille et  la mme forme que  \texttt{q}, ce qui poserait  des problmes pour
placer \texttt{q} ou pour dessiner des transitions vers ou  partir de
\texttt{q}. 
\begin{ocaml}
let initial (states : Box.t) (name : string) : Command.t =
  let q = Box.get name states in
  let p = Box.west q in
  Arrow.draw (Path.pathp [Point.shift p (Point.pt (cm (-0.3), zero)); p])
\end{ocaml}
La fonction  accde   la bote \texttt{q}  par son  nom \texttt{name}
dans la  bote \texttt{states} et dtermine le point d'arrive de la
flche avec \texttt{Box.west}. On pourrait gnraliser cette fonction
pour spcifier la position de la flche.

La fonction \texttt{transition} dessine une flche d'un tat  un
autre. Cette fonction prend deux arguments optionnels \texttt{outd} et
\texttt{ind} pour spcifier, en degrs, la direction sortante et la
direction entrante de la flche. On doit les convertir en vecteurs
directeurs pour les passer\footnote{Nous utilisons ici une
  fonctionnalit d'\ocaml{} qui permet d'accder  des arguments
  optionnels sans spcifier leur valeur par dfaut, sous la forme d'un
  type {\tt option}. Nous passons ensuite directement ces valeurs de
  type {\tt option}, en tant qu'arguments optionnels,  la fonction
  {\tt cpath} par la syntaxe {\tt cpath ?outd ?ind x y}.}  \texttt{cpath}, qui
calcule un chemin allant du bord d'une bote au bord d'une autre
bote. Ce chemin est ensuite donn  la fonction \texttt{Arrow.draw}
qui trace la flche en plaant une tiquette \texttt{tex}  la
position \texttt{pos}.
\begin{ocaml}
let transition states tex pos ?outd ?ind x_name y_name = 
  let x = Box.get x_name states and y = Box.get y_name states in
  let outd = match outd with None -> None | Some a -> Some (vec (dir a)) in
  let ind = match ind with None -> None | Some a -> Some (vec (dir a)) in
  Arrow.draw ~tex ~pos (cpath ?outd ?ind x y) 
\end{ocaml}

La fonction \texttt{loop} est similaire  la fonction
\texttt{transition}, mais elle doit calculer un chemin plus complexe.
En effet, \texttt{cpath} appliqu  deux botes identiques renvoie un
chemin vide et on ne peut donc pas l'utiliser.  la place, on calcule
un point $A$ suffisamment loign de la bote et on trace un chemin
qui part du centre, qui passe par $A$ puis qui revient au centre. On
utilise au passage la fonction \texttt{knotp} qui permet de spcifier
un point avec une tangente, et \texttt{pathk} qui transforme une liste 
de tels points en un chemin.

\begin{minipage}{0.2\linewidth}
  \includegraphics{loop_explain.mps}
\end{minipage}
\begin{minipage}{0.2\linewidth}
\small\begin{ocaml}
let loop states tex name =
  let box = Box.get name states in
  let a = Point.shift (Box.south box) (Point.pt (cm 0., cm (-0.4))) in
  let c = Box.ctr box in
  let p = Path.pathk [
    knotp ~r:(vec (dir 225.)) c;
    knotp a;
    knotp ~l:(vec (dir 135.)) c;
  ] in
  let bp = Box.bpath box in
  Arrow.draw ~tex ~pos:`Bot (cut_after bp (cut_before bp p))
\end{ocaml}
\end{minipage}

Ici encore, on pourrait gnraliser cette fonction
pour spcifier la position de la flche.
On  peut maintenant  dessiner  facilement des  automates en  utilisant
cette bibliothque.

\medskip
\begin{minipage}{0.2\linewidth}
  \includegraphics{automate.mps}
\end{minipage}
\begin{minipage}{0.2\linewidth}
\small\begin{ocaml}
let automate =
  let states = ... in
  [ Box.draw states;
    transition states "a" `Lowleft "alpha" "gamma";
    transition states "b" `Lowright "gamma" "beta";
    transition states "c" `Top ~outd:25. ~ind:335. "alpha" "beta";
    transition states "d" `Bot ~outd:205. ~ind:155. "beta" "alpha";
    loop states "e" "gamma"; initial states "alpha" ]
\end{ocaml}
\end{minipage}


\subsection{Exemples utilisant des calculs en \ocaml}

Cette section illustre l'un des avantages de \mlpost: la capacit de
dessiner directement un objet que l'on a calcul/programm en \ocaml.

% plot -- SL
\paragraph{Graphe de fonction.}
Un exemple simple de dessin rsultant d'un calcul est celui du graphe
d'une fonction.  \mlpost\ fournit un module \texttt{Plot}  cet effet.
La figure suivante montre un exemple basique
d'utilisation de cette extension :

\medskip
\begin{minipage}{0.35\linewidth}
  \includegraphics{graph_sqrt.mps}
\end{minipage}
\begin{minipage}{0.65\linewidth}
\small\begin{ocaml}
let u = cm 1. in
let sk = Plot.mk_skeleton 4 3 u u in
let label = Picture.tex "$y=\\sqrt{x+\\frac{1}{2}}$", 
            `Upleft, 3 in
let f x = sqrt (float x +. 0.5) in
let graph = Plot.draw_func ~label f sk in
[ graph; Plot.draw_simple_axes "$x$" "$y$" sk ]
\end{ocaml}
\end{minipage}

\medskip\noindent La fonction \texttt{mk\_skeleton} permet de construire un
cannevas de 4 units sur 3, qui est l'objet de base de l'extension
\texttt{Plot}. Il est alors possible de dessiner un graphe de fonction
et des axes au sein de ce cannevas, comme illustr ci-dessus.
L'extension dispose de beaucoup d'options (trac de la grille,
affichage des abscisses et ordonnes, diffrents types de graphes de
fonctions) qui permettent de raliser des figures plus complexes,
telle que celle dcrite dans le paragraphe suivant.

\paragraph{Abstractions d'horloges dans un systme synchrone flot-de-donnes.}
L'exemple ci-dessous, ralis par Florence Plateau, 
provient d'un problme rel~\cite{MandelPlateau08} et illustre un
certain nombre des possibilits de l'extension \texttt{Plot}.
%
%
Ainsi les fonctions illustres sur cette figure ont t codes comme des
fonctions \ocaml{} standard. De plus, la ligne intermdiaire dans la
partie situe sous le graphe principal, et dnote par $w_2$,
reprsente les discontinuits de la fonction $f_{w_2}$ du graphe
principal. Cette ligne est calcule \textit{directement}  partir de
la fonction $f_{w_2}$ ; si l'on dcide de changer la fonction
$f_{w_2}$, la ligne $w_2$ sera mise  jour automatiquement. Cela est
galement vrai pour certaines tiquettes de la figure, comme l'abscisse
$[w_2]_5$. Ceci offre une flexiblit trs intressante lors de la
phase de dveloppement d'une telle figure.

\begin{figure}[h]
  \centering
  \begin{center}
    \medskip
    \includegraphics{florence.mps}
  \end{center}
  %\caption{expliquer de quoi a parle}
  \label{fig:florence}
\end{figure}

\paragraph{Bresenham.}
 titre de dernier exemple, supposons que l'on veuille illustrer
l'algorithme de trac de segment de Bresenham~\cite{bresenham}, par
exemple sur le segment reliant le point $(x_1,y_1)=(0,0)$ au point
$(x_2,y_2)=(9,6)$. Pour cela, on commence par stocker le rsultat de
l'algorithme dans un tableau \texttt{bresenham\_data}, tel que
$\texttt{bresenham\_data.(}x\texttt{)}$ donne l'ordonne du point
d'abscisse $x$. 
\begin{ocaml}
let x2 = 9 and y2 = 6
let bresenham_data = Array.create (x2+1) 0 
let () = (* remplissage du tableau a avec l'algorithme de Bresenham *) ...
\end{ocaml}
On peut alors raliser la figure trs facilement,  l'aide de la
fonction \texttt{Box.gridi} fournie par \mlpost, qui construit une
matrice de botes alignes  partir d'une largeur, d'une hauteur et
d'une fonction construisant la bote $(i,j)$,
d'une manire analogue  \texttt{Array.create\_matrix}.

\medskip
\begin{minipage}{0.3\linewidth}
  \includegraphics{bresenham0.mps}
\end{minipage}
\begin{minipage}{0.7\linewidth}
\vspace*{0.8em}
\begin{ocaml}
let width = bp 6. and height = bp 6. in
let g = Box.gridi (x2+1) (y2+1) 
  (fun i j -> 
    let fill = if bresenham_data.(i) = y2 - j 
               then Some Color.red else None in
    Box.rect ?fill (Box.empty ~width ~height ())) in
[ Box.draw g ]
\end{ocaml}
\end{minipage}

\medskip\noindent Les botes sont des botes vides de 6 points de
ct, cres avec \texttt{Box.empty}. Pour les botes correspondant 
des points dessins par l'algorithme de Bresenham, on indique que la
bote doit tre remplie en rouge,  l'aide de l'argument optionnel
\texttt{fill}. 

Pour parachever la figure, on va ajouter des tiquettes indiquant les
coordonnes des deux extrmits du segment. Pour placer une tiquette
 ct de la case $(i,j)$, on rcupre la bote correspondante 
l'aide de \texttt{Box.nth}, puis on rcupre un point particulier de
cette bote (par exemple le point au milieu en bas avec
\texttt{Box.south}), puis enfin on trace l'tiquette avec
\texttt{Command.label}.

\medskip
\begin{minipage}{0.22\linewidth}
\vspace*{0.8em}
\hspace*{-1.4em}\includegraphics{bresenham.mps}
\end{minipage}
\begin{minipage}{0.7\linewidth}\small
\begin{ocaml}
let bresenham = 
  let width = bp 6. and height = bp 6. in
  let g = ... in
  let get i j = Box.nth i (Box.nth (y2-j) g) in
  let label pos s point i j =
    Command.label ~pos (Picture.tex s) (point (get i j)) in
  [ Box.draw g;
    label `Bot "0" Box.south 0 0; label `Bot "$x_2$" Box.south x2 0;
    label `Left "0" Box.west 0 0; label `Left "$y_2$" Box.west 0 y2 ]
\end{ocaml}
\end{minipage}

\section{Architecture logicielle}\label{archi}

La figure~\ref{fig:etapes} montre le fonctionnement de \mlpost.  Tout
d'abord, \mlpost\ est un outil de gnration de fichier \metapost\
sous forme de bibliothque \ocaml.  l'aide de cette bibliothque,
l'utilisateur crit un programme qui,  l'excution, construit un
arbre de syntaxe abstraite \metapost. Cet arbre est imprim dans un
fichier \verb|figure.mp| qui est lu par \metapost\ pour gnrer un ou
plusieurs fichiers \postscript\footnote{Ces fichiers n'ont pas le
  suffixe \texttt{.ps} car il leur manque l'en-tte.}. L'inclusion de
ces figures dans un document \LaTeX{} se fait simplement en utilisant
la commande \verb|\includegraphics| du package \textsf{graphicx}. Pour
compiler le document \LaTeX{} avec {\tt pdflatex}, il suffit de
changer l'extension des figures gnres, ce qu'une option de l'outil
\mlpost{} permet de faire facilement.

\begin{figure}[h]
\begin{center}
\includegraphics{stages.mps}
\end{center}
  \caption{Architecture de \mlpost}\label{fig:etapes}
\end{figure}

Il est important de noter que le fichier \metapost\ de sortie n'est
pas obtenu par {\em compilation} du code source \ocaml, mais
par une \emph{excution} du programme qui construit un arbre de syntaxe
abstraite \metapost. Cette mthode a l'inconvnient qu'une boucle ou
itration dans le programme de dpart sera traduite par une suite de
commandes obtenues par le droulement de la boucle, et non par une
construction de boucle du langage cible. Ceci tant dit, dans notre
cas, le cot supplmentaire est faible, puisque \metapost\ droule
galement les boucles dans les fichiers \postscript\ de sortie.

% schma de l'architecture
\begin{figure}[ht]
  \begin{center}
    ~\\[0.5em]
    \includegraphics{architecture.mps} 
  \end{center}
  \vspace*{-1em}
  \caption{Architecture de \mlpost}\label{fig:archi}
\end{figure}

L'architecture gnrale de \mlpost{} est schmatise en
figure~\ref{fig:archi}. Au niveau le plus bas se trouvent les interfaces
correspondant aux types primitifs de \metapost. Ce sont ces objets qui sont
{\it in fine} traduits en du code \metapost, et nous les dcrivons de manire
plus dtaille dans la section~\ref{subsec:types}. La couche intermdiaire
contient des lments que nous estimons tre de bas niveau mais qui ne sont
pas prsents dans \metapost : ils sont propres  \mlpost\ et ont t
construits  partir de la couche infrieure. Les sections~\ref{subsec:boxes}
et \ref{subsec:arrows} reviennent plus en dtail sur deux de ces modules,
respectivement \texttt{Box} et \texttt{Arrow}.
Enfin, on trouve au plus haut niveau des modules tels que
le module \texttt{Plot} prsent dans la section prcdente.
L'intgralit des modules de \mlpost\ est empaquete dans un module
\texttt{Mlpost}, afin de ne pas polluer l'espace de noms d'\ocaml.

\subsection{Types primitifs de \metapost}\label{subsec:types}

La couche de bas niveau de \mlpost\ est une interface fidle  \metapost. Elle
comporte tous les types de base de \metapost~:

\begin{description}

  \item[Le type numrique (module \texttt{Num})] reprsente des longueurs.
    En premire approximation, ce type pourrait tre assimil au type
    \texttt{float} d'\ocaml, 
    mais certaines valeurs, telle que  la taille d'un lment \LaTeX, ne sont
    connues qu' l'interprtation du fichier \metapost.  La plupart des
    calculs sont donc effectus de 
    manire symbolique et le type \texttt{Num.t} doit donc tre abstrait.

  \item[Le type point (module \texttt{Point})] reprsente des points
    dans l'espace  deux dimensions. Pour les mmes raisons que les
    numriques, les points ne sont pas simplement des paires de flottants, mais
    doivent tre reprsents de manire symbolique. Le type
    \texttt{Point.t} est galement utilis pour reprsenter les vecteurs.

  \item[Les chemins (module \texttt{Path})] sont des lignes reprsentes par
    des courbes de Bzier. Ils sont  la base de tout dessin \metapost. Toutes
    les possibilits de construction de chemin dans \metapost\ ont t
    interfaces. On peut dessiner des lignes droites ou des lignes courbes en
    prcisant les points de contrle, la tension de la courbe, etc.
    
  \item[Les transformations (module \texttt{Transform})] permettent
    d'appliquer une transformation linaire  un objet quelconque. Il est
    ainsi possible de dplacer des objets, les redimensionner,
    les faire pivoter ou encore combiner toutes ces transformations.

  \item[Les plumes (module \texttt{Pen})] permettent de choisir 
    l'paisseur et la forme du stylo utilis pour dessiner les
    chemins.

  \item[Les figures (module \texttt{Picture})] permettent de
    rassembler plusieurs lments graphiques en un seul, qu'il
    s'agisse d'lments \LaTeX\ ou de commandes de dessin arbitraires.
    Le type \texttt{Picture.t} permet de traiter
    une figure arbitrairement complexe comme un objet de base que l'on
    peut copier, transformer, etc.
    Le module \texttt{Picture} permet galement de dcouper une figure
     l'aide d'une surface dcrite par un chemin clos
    (\textit{clipping}). 

\end{description}
Les autres types \metapost\ (chanes de caractres, boolens, couleurs)
sont directement reprsents en \ocaml. L'interface de \mlpost\ contient
aussi un module \texttt{Command} qui dfinit le type des commandes
\metapost : commandes de dessin, de remplissage, itrations,  squences,
etc.

\paragraph{Dpendances circulaires.}
La ralisation de ces modules de bas niveau prsente quelques
difficults. Premirement, la plupart des modules prsents sont {\em
  a priori} mutuellement rcursifs : par exemple, les transformations
s'appliquent  tous les autres objets, donc chaque module contient une
fonction
\begin{ocaml}
  val transform : Transform.t -> t -> t
\end{ocaml}
o le type \texttt{t} reprsente le type principal du module en
question.  D'un autre ct, les transformations sont elles-mmes
construites  l'aide de numriques et de points:
\begin{ocaml}
  val shifted : Point.t -> t
\end{ocaml}
o \texttt{t} est le type des transformations.  Des dpendances
circulaires existent aussi entre types et sont aggraves par la
reprsentation symbolique des objets (par exemple, les projections
\texttt{xpart} et \texttt{ypart} du module \texttt{Point} doivent
retourner des numriques et non des flottants).

Nous souhaitons raliser ces diffrents modules dans des fichiers
diffrents mais \ocaml\ ne permet pas de dpendances
circulaires entre des fichiers. Notre solution consiste  dfinir tous
les \emph{types} dans un seul fichier \texttt{types.mli}.
Chaque module fait maintenant rfrence  ce fichier. Par exemple,
dans le fichier \texttt{path.ml}, qui fournit l'implmentation du
module \texttt{Path}, on trouvera
\begin{ocaml}
  type t = Types.path
\end{ocaml}
La dpendance circulaire entre les modules est ainsi casse de manire trs
classique. 
En revanche, on souhaite cacher l'existence du module \texttt{Types} 
pour les deux raisons suivantes : 
\begin{itemize}
\item la clart des messages d'erreur ;
\item la clart de la documentation gnre par \texttt{ocamldoc}.
\end{itemize}
On souhaite donc rtablir la circularit entre les modules
au sein de l'interface du module \texttt{Mlpost}.
Pour cela, on crit un unique fichier
\texttt{mlpost.mli} qui contient les dfinitions des signatures des
modules  exporter :

\medskip
\begin{minipage}{0.33\textwidth}
\begin{ocaml}
module rec Num : sig
  type t
  ...
end
and Point : sig
  type t
  val xpart : t -> Num.t
  ...
end
and Path : sig
  type t
  ...
end
...
\end{ocaml}
\end{minipage}
\begin{minipage}{0.65\textwidth}
  \includegraphics{deps.mps}
\end{minipage}

Toutes ces signatures sont dclares de manire mutuellement
rcursive. La signature de \texttt{Point} peut ainsi faire rfrence 
\texttt{Path} et inversement.  On notera que les types tels que
\texttt{Point.t} sont maintenant abstraits dans l'interface, rendant
invisible l'existence du module \texttt{Types}.  Par ailleurs, les
implmentations de ces modules sont contenues dans des fichiers
indpendants \texttt{num.ml}, \texttt{point.ml}, etc., qui sont
compils avec l'option {\tt -for-pack Mlpost}.  Cet agencement est en
outre trs pratique pour la documentation de l'API : c'est uniquement
le fichier \texttt{mlpost.mli} qui sert d'entre  l'outil
\texttt{ocamldoc}.

\paragraph{Hash-consing et traduction vers \metapost.}

Le choix d'une reprsentation symbolique de la plupart des objets impose
des efforts supplmentaires pour minimiser l'utilisation de la mmoire
et la taille des fichiers \metapost\ de sortie. En effet, l'arbre de
syntaxe abstraite (AST) contient beaucoup de n\oe uds identiques mais
construits de manire diffrente, qui prennent donc inutilement de la
place aussi bien en mmoire que dans le fichier \metapost\ gnr. C'est
d'autant plus gnant que \metapost\ devra lire ce fichier et passera
donc davantage de temps sur des calculs rpts.

Pour y remdier, nous utilisons la technique du {\em
hash-consing}~\cite{ConchonFilliatre06wml} applique  l'arbre de syntaxe
abstraite. Cette technique permet de partager des valeurs structurellement
gales. Elle utilise une table de hachage globale qui stocke toutes les valeurs
dj cres. Avant de crer un nouvel objet, on regarde dans cette table si un
objet structurellement gal existe dj. Pour que le calcul de la valeur de
hachage soit efficace, chaque (sous-)terme
vient avec sa valeur de hachage. Le partage ralis est maximal, ce
qui permet de substituer l'galit physique (\texttt{==})  l'galit
structurelle (\texttt{=}). 

Cette technique diminue l'utilisation de la mmoire, mais ne change rien {\em a
priori}  la taille des fichiers gnrs. La structure hash-conse {\em
ralise} le partage, mais elle ne sait pas quels sont les n\oe uds
effectivement 
utiliss au moins deux fois. Pour cela, on ralise un simple parcours
en profondeur de la structure, en comptant les occurrences de chaque
n\oe ud.  Il est nanmoins
possible de rencontrer une nouvelle fois un sous-n\oe ud d'une structure,
comme le montre l'exemple ci-dessous :

\begin{center}
\includegraphics[scale=1.5]{sharing.mps}
\end{center}

\noindent Dans cette configuration, le n\oe ud $f$ est rellement utilis deux
fois, alors que le n\oe ud $e$ n'est utilis qu'une seule fois, par le
n\oe ud $d$, mme si celui-ci est utilis deux fois  son tour.
Autrement dit, on comptabilise pour chaque n\oe ud le nombre de
flches incidentes.

Aprs cette analyse, la gnration du fichier \metapost\ devient trs simple :
il suffit de traverser de nouveau l'arbre de syntaxe abstraite et,
quand on visite un n\oe ud 
qui est utilis au moins deux fois,  on construit une dfinition
\metapost\ pour cet objet. Il faut nanmoins
prendre en compte les particularits syntaxiques de \metapost\ telles que la
prcdence inhabituelle des oprateurs arithmtiques et la restriction de
l'application de certaines constructions  des variables. De cette faon, on
arrive  avoir du code \metapost\ relativement petit\footnote{En l'absence de
boucles \texttt{for} et de macros dans le code \metapost, nous avons observ,
sans avoir fait de tests trs exhaustifs, une taille du code gnr du
mme ordre de grandeur que celle du code \metapost\ crit  la main.},
malgr la dlgation des calculs  \metapost. 

\subsection{Botes}\label{subsec:boxes}

Comme nous l'avons illustr dj maintes fois, les botes de \mlpost\
peuvent tre rduites  de simples objets \LaTeX\ ou bien tre
constitues d'un ensemble d'autres botes. Le type des botes est donc
un type rcursif de la forme suivante :
\begin{ocaml}
type t =
  { name : string option;
    width : Num.t;  height : Num.t; pen : Pen.t option; ...
    desc : desc; }
    
and desc = 
  | Emp
  | Pic of Picture.t
  | Grp of t array * t Smap.t
\end{ocaml}
Chaque bote est ventuellement nomme (champ \texttt{name}), possde
un certain nombre d'attributs (position, taille, couleur, bordure,
remplissage, etc.) et sa nature est donne par le champ \texttt{desc}.
Ce dernier indique s'il s'agit d'une bote vide, d'une image ou bien
d'une bote composite. Dans ce dernier cas, les sous-botes sont
contenues dans un tableau, qui est accompagn d'une table (ralise
par le module \texttt{Smap}) permettant un accs plus rapide  une 
sous-bote par son nom.

Le dessin d'une bote est immdiat. On trace d'une part son contour et
d'autre part son contenu. Ce dernier est soit
une bote atomique directement dessine  l'aide de
\texttt{Command.draw\_pic}, soit une bote composite dont le dessin
est tout simplement obtenu en dessinant rcursivement chaque sous-bote.

Pour raliser les diverses fonctions de placement, on commence par
crire une fonction de translation d'une bote par un vecteur donn :
\begin{ocaml}
  Box.shift : Point.t -> Box.t -> Box.t
\end{ocaml}
Cette fonction est naturellement rcursive sur la structure de la
bote. Il est important de noter que cette fonction renvoie une
\emph{nouvelle} bote, sans altrer son argument (les botes sont
persistantes). Une fois cette fonction donne, il est ais de raliser
les fonctions \texttt{Box.hbox}, \texttt{Box.hblock}, etc.

\subsection{Flches} \label{subsec:arrows} %% RB

\metapost\ ne propose qu'un seul type de flche.
Une flche \metapost\ suit  un chemin arbitraire   mais son trac est
limit aux diffrents styles de trait (plume et pointills) et la tte
de flche est toujours la mme : 
\begin{center}
\includegraphics{arrow_metapost.mps}
\end{center}
Avec \mlpost, l'utilisateur peut crer ses propres catgories de
flches  l'aide du module \texttt{Arrow}. Celui-ci propose deux types :
\begin{itemize}
\item  Le  type \texttt{head}  dcrit  comment  dessiner  une tte  de
  flche.   Les  lments de  type  \texttt{head}  sont des  fonctions
  prenant en argument la position et la direction de la tte de flche
  et renvoyant une commande dessinant la tte de flche.
\item Le  type abstrait \texttt{kind} dcrit une  catgorie de flche.
  Une catgorie dcrit les diffrents lments dans le dessin d'une
  flche, les ttes de flche pouvant en ralit tre places
  n'importe o le long de la flche.
  Pour construire une nouvelle catgorie, on  part de  la catgorie
  vide et on  ajoute des traits et des ttes.
\end{itemize}
La  fonction  \texttt{draw}  permet   de  dessiner  une  flche  d'une
catgorie donne  en suivant un  chemin donn. Les flches  sont alors
dessines  en   utilisant  les   primitives  de  \metapost.    Ceci  a
l'inconvnient  d'utiliser   plus  de  ressources   mais   permet
d'imaginer de nombreuses catgories de flches.

On peut en particulier retrouver les flches de \metapost. On part d'un
corps vide et on 
lui ajoute un trait normal sur  toute la longueur.  On ajoute enfin une tte
triangulaire remplie, et on obtient :

\medskip
\begin{minipage}{0.2\linewidth}
  \includegraphics{arrow_simple.mps}
\end{minipage}
\begin{minipage}{0.2\linewidth}
\begin{ocaml}
let kind =
  Arrow.add_head ~head:Arrow.head_triangle_full
    (Arrow.add_line Arrow.empty) in 
[ Arrow.draw ~kind (...path...) ]
\end{ocaml}
\end{minipage}

\medskip
La  section~\ref{sec:automates}  contient   une  figure  dcrivant  le
fonctionnement de la fonction \texttt{loop}. Pour les besoins de cette
figure, on  a cr un  type de flche  spcial, compos d'un  dbut et
d'une fin en pointills et avec une tte place diffremment :
\begin{center}
\includegraphics{arrow_loop_explain.mps}
\end{center}
Le code permettant d'obtenir cette  catgorie de flche est le suivant
:
\begin{ocaml}
let kind =
  Arrow.add_belt ~point:0.9
    (Arrow.add_line ~dashed:Dash.evenly ~to_point:0.1
       (Arrow.add_line ~dashed:Dash.evenly ~from_point:0.9
          (Arrow.add_line ~from_point:0.1 ~to_point:0.9
             Arrow.empty)))
\end{ocaml}

\section{Conclusion}\label{conclusion}

Nous avons prsent \mlpost, une bibliothque \ocaml\ au dessus de
\metapost. Nous esprons avoir convaincu le lecteur des avantages que la
prsentation sous forme de bibliothque apporte : familiarit avec le
langage pour les programmeurs \ocaml, typage fort, des
constructions de programmation de haut niveau, des dessins rsultants
de calculs arbitraires, etc.  
\mlpost\ fournit volontairement un nombre restreint de primitives, car
l'utilisateur peut aisment construire des
extensions au dessus de \mlpost. En cela, \mlpost\ diffre de
bibliothques \LaTeX\ telles que \nomdetikz\ ou \pstricks, o de trs
nombreuses fonctionnalits sont fournies mais o il est trs difficile
d'en ajouter pour qui ne matrise pas \TeX.

L'une des forces de \mlpost\ est de proposer un style dclaratif, l
o la majorit des bibliothques graphiques propose un style
impratif. Ceci permet en particulier un \emph{partage} immdiat de
sous-lments dans une ou plusieurs figures.
Une autre force de \mlpost\ est le typage statique directement hrit
d'\ocaml. On vite ainsi l'immense majorit des erreurs  l'excution
de \metapost, souvent cryptiques. Il reste nanmoins les erreurs
ventuellement contenues dans les extraits de \LaTeX\ ou les erreurs
de nature gomtrique telles que le remplissage d'un chemin en forme
de 8. Nous pourrions envisager d'utiliser des types \ocaml\ plus
prcis, par exemple pour distinguer les chemins clos et non clos ou
encore les points et les vecteurs.

Il reste une fonctionnalit intressante de \metapost\ qui n'est pas
interface dans \mlpost~: la rsolution d'quations linaires.  Il y a
deux raisons  cela. D'une part, les quations servent souvent au
placement implicite, et \mlpost\ fournit une alternative sous la forme
de fonctions d'alignement de botes. D'autre part, la rsolution
d'quations de \metapost\ procde de manire imprative et il n'est
pas simple de l'intgrer dans le contexte dclaratif qui est le ntre.
Ceci tant dit, il serait intressant d'explorer des mthodes de
placement plus automatiques que celles que nous proposons, par exemple
inspires de la manire dont \TeX{} mets en page lignes, pages et
paragraphes.

Enfin, il est important de noter que \mlpost\ n'est pas li 
\metapost\ de manire intrinsque. On pourrait facilement ajouter une
sortie \nomdetikz, ou mme directement une sortie \postscript\ 
condition d'utiliser une technique similaire  celle de \metapost\
pour l'inclusion de \LaTeX.

\medskip
\noindent
\begin{center}
  \includegraphics[width=0.3\textwidth]{ford.mps}

\medskip
\begin{minipage}{0.7\textwidth}
  \begin{center}
    \bf Remerciements
  \end{center}
  \centering Les auteurs tiennent  remercier Florence Plateau,
  Yannick Moy et Claude March pour leur contribution  \mlpost,
  Sylvie Boldo pour la suggestion du titre de l'article et les
  relecteurs pour leurs remarques.
\end{minipage}

\medskip
  \includegraphics[angle=180,width=0.3\textwidth]{ford.mps}
\end{center}

% La bibliographie
% N'oubliez pas de l'inclure lors de votre soumission.
\bibliographystyle{plain}
\bibliography{./biblio}

\vfill

\pagebreak
\thispagestyle{colloquetitle}
\cleardoublepage
\end{document}

% Local Variables:
% coding: iso-latin-1
% ispell-local-dictionary: "francais"
% End: