\documentclass{report}
\usepackage{newcent}
\usepackage{pifont}
\usepackage[dvips]{color}

\parindent 0pt
\pagestyle{plain}
\topmargin0cm
\headheight0pt
\headsep0pt
\textwidth16.5cm
\textheight23cm
\footskip1cm
\oddsidemargin0cm
\evensidemargin0cm

\renewcommand{\labelitemi}{\textcolor{blue}{\ding{228}}}
\renewcommand{\labelitemii}{\textcolor{blue}{\ding{169}}}
\renewcommand{\labelitemiii}{\textcolor{blue}{\ding{72}}}
\renewcommand{\arraystretch}{1.1}
\begin{document}
\begin{center}
\vbox{\hrule\vskip2pt\hrule\bf\large\vskip \baselineskip
{\sl MlDoC }\\
Version 1.0 \\
OCaML Documentation System \\
Written by \\
Stefan Bosse (sbosse@physik.uni-bremen.de) \\
\vskip \baselineskip
\hrule\vskip2pt\hrule}
\end{center}
\vfill \eject
The {\sl MlDoC }system is a powerfull but 'simple as needed' documentation tool 
for ML programming projects. With {\sl MlDoC }, a document is divided in the 
document head, sections, subsections, units and subunits. Subunits can be used 
in all parts up, and the lowest structure elements are generic paragraph 
elements like lists or text attributes. {\bf This document you are currently 
reading is of course written and printed with the {\sl MlDoC }System. }\\
The table below shows an overview about {\sl MlDoC }and it's capabilities. 
\vskip 2\baselineskip
\begin{center}
  \begin{tabular}{|p{2.2cm}|p{2.2cm}|p{2.2cm}|p{2.2cm}|p{2.2cm}|p{2.2cm}|}\hline
    \multicolumn{6}{|c|}{\textcolor{red}{\sc Document structure }}\\\hline\hline
    {\bf Document head }&{\bf Sections }&{\bf Subsections }&{\bf Units }&{\bf 
    Subunits }&{\bf Paragraph elements }\\\hline
    Title &Package &Module &ML-Function &Named Paragraph &Text Attributes 
    \\\hline
    TOC &Program &C-Lib &ML-Type &Interface &Ordered List \\\hline
    &&&ML-Value &Example &Unordered List \\\hline
    &&&ML-Class &&Table \\\hline
    &&&ML-Module &&Name \\\hline
    &&&C-Interface &&Link \\\hline
    &Generic S1 &Generic S2 &Generic S3 &Generic S4 &Special Interfaces \\\hline
    Intro &Intro &Intro &Intro &Intro &\\\hline
    \end{tabular}
  \end{center}
\vskip 2\baselineskip
It's not necessary to use all structure depths starting with the document head. 
For example you can start with the {\sl ML-Function }unit in a small standalone 
document. The units are compareable with common manual pages. \\
Units are sub document headers, and subunits and introductions can be placed 
everywhere in the document. \\
The document structure is organized in the way {\sl OCaML }structures 
libraries, modules and values, classes and sub modules. But {\sl MlDoC }can 
also be used to provide documentation for programs, C libraries or other nice 
things you want to write about. For these purposes, generic sections, units and 
subunits can be used. \\
The {\sl Special interface }element is used to show ML-function, value, type 
and sub module interfaces with an unique look, mostly embedded in the {\sl 
Interface }subunit. \\
All document commands are preceeded with a dot and followed by one or two 
uppercase characters. This is a formatting language which is similar to {\sl 
TROFF }macros. Each dot command must have an antidot command to close a partial 
environment. For example, an ordered list like 
\vskip \baselineskip
\begin{minipage}{.9\textwidth}\vbox{
  \begin{enumerate}
    \item Line 1 
    \item Line 2 
    \item ... 
    \end{enumerate}
  }\end{minipage}
\vskip \baselineskip
is coded with the following commands: 
\vskip 2\baselineskip
\halign{
  \hskip3em#\hfil\cr
   \cr
  {\tt \hskip 1em.OL } \cr
  {\tt \hskip 1em \hskip 1em .LI Line 1 .IL } \cr
  {\tt \hskip 1em \hskip 1em .LI Line 2 .IL } \cr
  {\tt \hskip 1em \hskip 1em .LI ... .IL } \cr
  {\tt \hskip 1em .LO } \cr
  {\tt \hskip 1em \hfil} \cr 
  }

  \vskip 2\baselineskip
  The antidot command is build with the reversed order of the two characters from 
  the dot command. There is one excpetion: text attributes and some special 
  commands. They all have only one uppercase character. 
  \vfill \eject
  \vbox{\hsize \textwidth
\hrule
\vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad \hfill
  \label{MlDoCdotcommands}\textcolor{blue}{\sc {\sl MlDoC dot commands }} \hfill
  \quad \vrule}\hrule}

  \vskip \baselineskip
  In this section, all available dot commands are described. They are sorted into 
  these groups: 
  \vskip \baselineskip
  \begin{minipage}{.9\textwidth}\vbox{
\begin{enumerate}
  \item Section headers 
  \item Subsection headers 
  \item Unit headers 
  \item Subunit headers 
  \item Interfaces 
  \item Generic paragraph elements 
  \item Text elements and attributes 
  \end{enumerate}
}\end{minipage}
  \vskip \baselineskip
  \vfill \eject
  \vbox{\hsize \textwidth
\hrule
\vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
  \label{Sectionheaders}\textcolor{blue}{\sc {\sl Section headers }} \hfill 
  \textcolor[rgb]{.0,.7,.0}{\sc  MlDoC dot commands}\quad \vrule}\hrule}

  \vskip \baselineskip
  Sections together with subsections are used to structure the complete manual 
  document. 
  \vskip 2\baselineskip
  \begin{center}
\begin{tabular}{|p{3.3cm}|p{1.8cm}|p{1.5cm}|p{3.3cm}|}\hline
  \multicolumn{4}{|c|}{\textcolor{red}{\sc Available sections }}\\\hline\hline
  {\bf Name }&{\bf begin }&{\bf end }&{\bf Comment }\\\hline
  Package &{\tt .PK }&{\tt .KP }&Name argument required \\\hline
  Program &{\tt .PR }&{\tt .RP }&Name argument required \\\hline
  Generic Section S1 &{\tt .S1 }&{\tt .1S }&Name argument required \\\hline
  \end{tabular}
\end{center}
  \vskip 2\baselineskip
  The {\sl Name }command must follow the {\sl section }command immediately. Here is 
  a short example for a new {\sl Package }section in the document: 
  \vskip 2\baselineskip
  \vbox{\hfil
\vbox{\hrule
  \hbox{\vrule\qquad
    \textcolor{blue}{\rule[-.55em]{0pt}{1.7em}\sc Programming Example}
    \quad\vrule}
  \hrule}
}
  \nobreak\vskip \baselineskip\nobreak
  \halign to \textwidth{
\textcolor[rgb]{.58,.76,1.0}{\strut\vrule width 5pt#}\tabskip=0pt plus 1fil& 
  #\hfil& #&\hfil#\hfil& 
  \tabskip=0pt#\cr
 &&&\cr 
& {\tt \hskip 1em.PK } &&& \cr
& {\tt \hskip 1em \hskip 1em .NA Standard Library .AN } &&& \cr
& {\tt \hskip 1em \hskip 1em ... } &&& \cr
& {\tt \hskip 1em .KP } &&& \cr
& {\tt \hskip 1em \hfil} &&& \cr 
}
  
    \vskip 2\baselineskip
    Packages can be ML-Libraries or other kinds of programming environments. 
    \vfill \eject
    \vbox{\hsize \textwidth
  \hrule
  \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
\label{Subsectionheaders}\textcolor{blue}{\sc {\sl Subsection headers }} \hfill 
\textcolor[rgb]{.0,.7,.0}{\sc  MlDoC dot commands}\quad \vrule}\hrule}
  
    \vskip \baselineskip
    Subsections are used to group for example functions, values or other ML things. 
    Commonly, a subsection is a part of a section. 
    \vskip 2\baselineskip
    \begin{center}
  \begin{tabular}{|p{3.3cm}|p{1.8cm}|p{1.5cm}|p{3.3cm}|}\hline
\multicolumn{4}{|c|}{\textcolor{red}{\sc Available subsections }}\\\hline\hline
{\bf Name }&{\bf begin }&{\bf end }&{\bf Comment }\\\hline
ML-Module &{\tt .MD }&{\tt .DM }&Name argument required \\\hline
C-Library &{\tt .CY }&{\tt .YC }&Name argument required \\\hline
Generic Subsection S2 &{\tt .S2 }&{\tt .2S }&Name argument required \\\hline
\end{tabular}
  \end{center}
    \vskip 2\baselineskip
    \vfill \eject
    \vbox{\hsize \textwidth
  \hrule
  \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
\label{Unitheaders}\textcolor{blue}{\sc {\sl Unit headers }} \hfill 
\textcolor[rgb]{.0,.7,.0}{\sc  MlDoC dot commands}\quad \vrule}\hrule}
  
    \vskip \baselineskip
    Units are commonly known as manual pages. They are part of a subsection. 
    \vskip 2\baselineskip
    \begin{center}
  \begin{tabular}{|p{3.3cm}|p{1.8cm}|p{1.5cm}|p{3.3cm}|}\hline
\multicolumn{4}{|c|}{\textcolor{red}{\sc Available units }}\\\hline\hline
{\bf Name }&{\bf begin }&{\bf end }&{\bf Comment }\\\hline
ML-Function &{\tt .FU }&{\tt .UF }&Name argument required \\\hline
ML-Type &{\tt .TP }&{\tt .PT }&Name argument required \\\hline
ML-Value &{\tt .MV }&{\tt .VM }&Name argument required \\\hline
ML-Class &{\tt .CL }&{\tt .LC }&Name argument required \\\hline
ML-Module &{\tt .MD }&{\tt .DM }&Name argument required \\\hline
C-Interface &{\tt .CI }&{\tt .IC }&Name argument required \\\hline
Generic Unit S3 &{\tt .S3 }&{\tt .3S }&Name argument required \\\hline
\end{tabular}
  \end{center}
    \vskip 2\baselineskip
    \vfill \eject
    \vbox{\hsize \textwidth
  \hrule
  \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
\label{Subunits}\textcolor{blue}{\sc {\sl Subunits }} \hfill 
\textcolor[rgb]{.0,.7,.0}{\sc  MlDoC dot commands}\quad \vrule}\hrule}
  
    \vskip \baselineskip
    Subunits are special paragraphs. They can be used in all structure elements above. 
    \vskip 2\baselineskip
    \begin{center}
  \begin{tabular}{|p{3.3cm}|p{1.8cm}|p{1.5cm}|p{3.3cm}|}\hline
\multicolumn{4}{|c|}{\textcolor{red}{\sc Available subunits (paragraphs) 
}}\\\hline\hline
{\bf Name }&{\bf begin }&{\bf end }&{\bf Comment }\\\hline
Named Paragraph &{\tt .PA }&{\tt .AP }&Name argument optional \\\hline
Interface &{\tt .IN }&{\tt .NI }&Name argument optional \\\hline
Example &{\tt .EX }&{\tt .XE }&Name argument optional \\\hline
Preformatted text &{\tt .\{ }&{\tt .\} }&\\\hline
Generic Subunit S4 &{\tt .S4 }&{\tt .4S }&Name argument required \\\hline
\end{tabular}
  \end{center}
    \vskip 2\baselineskip
    Except for a generic subunit, the name argument {\tt .NA XXX .AN }is optional and 
    can be used for a further description head. \\
    The interface subunit is used to wrap function, value, type or other interfaces. 
    This subunit is used in conjunction with the 
    \vskip \baselineskip
    \begin{minipage}{.9\textwidth}\vbox{
  \begin{itemize}
\item ML-Function 
\item ML-Value 
\item ML-Type (abstract types) 
\item ML-Structure 
\item ML-Module 
\item ML-Class 
\item C-Function/variables 
\end{itemize}
  }\end{minipage}
    \vskip \baselineskip
    special interfaces. See 
    \fbox{\small {\sc Special Interfaces} (p. \pageref{SpecialInterfaces})} for more 
    details. The {\sl example }and the {\sl preformatted }text subunits are used to 
    display source code or other example lines in a new centered paragraph. The {\sl 
    example }subunit is put in a box. The {\sl preformatted }subunit can spawn several 
    pages. 
    \vfill \eject
    \vbox{\hsize \textwidth
  \hrule
  \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
\label{SpecialInterfaces}\textcolor{blue}{\sc {\sl Special Interfaces }} \hfill 
\textcolor[rgb]{.0,.7,.0}{\sc  MlDoC dot commands}\quad \vrule}\hrule}
  
    \vskip \baselineskip
    The special interfaces are used to show ML or C functions, types, submodules and 
    values. Only the content must be given by the user, not the alignment. Commonly, 
    they are collected in an interface subunit. 
    \vskip 2\baselineskip
    \begin{center}
  \begin{tabular}{|p{3.3cm}|p{1.8cm}|p{1.5cm}|p{3.3cm}|}\hline
\multicolumn{4}{|c|}{\textcolor{red}{\sc Available special interfaces 
}}\\\hline\hline
{\bf Name }&{\bf begin }&{\bf end }&{\bf Subarguments ($*$$=$optional, 
$\#$$=$multiple) }\\\hline
ML-Function &{\tt .IF }&{\tt .FI }&Name, RetVal ($\#$), Arg ($\#$), Val 
($*$$\#$) \\\hline
ML-Value &{\tt .IV }&{\tt .VI }&Name, Arg ($\#$) \\\hline
ML-Type (type list) &{\tt .IT }&{\tt .TI }&Name, Arg ($\#$) \\\hline
ML-Structure (type) &{\tt .IS }&{\tt .SI }&Name, Arg ($*$$\#$) \\\hline
ML-Module &{\tt .IM }&{\tt .MI }&Name, other specials \\\hline
ML-Class &{\tt .CS }&{\tt .SC }&Name, Arg [$*$$\#$], Obj \\\hline
ML-Class method &{\tt .MT }&{\tt .TM }&Name, Arg \\\hline
C-Header &{\tt .CH }&{\tt .HC }&\\\hline
C-Function &{\tt .CF }&{\tt .FC }&Name, Arg ($\#$) , RetVal \\\hline
C-Variable &{\tt .CV }&{\tt .VC }&Name, Arg \\\hline
\end{tabular}
  \end{center}
    \vskip 2\baselineskip
    The followinf subarguments used only in special interfaces, except the {\sl Name }
    command and the {\sl Comment }command: 
    \vskip 2\baselineskip
    \begin{center}
  \begin{tabular}{|p{3.3cm}|p{3.3cm}|p{1.8cm}|p{1.5cm}|}\hline
\multicolumn{4}{|c|}{\textcolor{red}{\sc Available subarguments }}\\\hline\hline
{\bf Name }&{\bf Description }&{\bf begin }&{\bf end }\\\hline
Name &Name of function,... &{\tt .NA }&{\tt .AN }\\\hline
Comment &Placed before the special interface &{\tt .($*$ }&{\tt .$*$) }\\\hline
RetVal &Return value of a function (uncurried subvalue) &{\tt .RV }&{\tt .VR }
\\\hline
Arg &Argument of a function (curried value) &{\tt .AR }&{\tt .RA }\\\hline
Val &Value argument of a function (uncurried subvalue) &{\tt .AV }&{\tt .VA }
\\\hline
Obj &Class object &{\tt .OB }&{\tt .BO }\\\hline
\end{tabular}
  \end{center}
    \vskip 2\baselineskip
    Either the curried value form {\bf or }the uncurried value form must be used for 
    the function interface. \\
    Here is an example for an interface with functions: 
    \vskip 2\baselineskip
    \vbox{\hfil
  \vbox{\hrule
\hbox{\vrule\qquad
  \textcolor{red}{\rule[-.55em]{0pt}{1.7em}\sc Programming Interface: {\sl 
  Function interfaces }}\quad\vrule}
\hrule}
  }
    \nobreak\vskip \baselineskip\nobreak
    {
  \nobreak\vskip .5\baselineskip 
  \halign{

\textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
&&&& \cr
$[$ & {\it ret1 }: int $*$ & & &{$\gg$\it The first return argument $\ll$}\cr
& {\it ret2 }: bool  & $]=$ & {\bf myfun1 }&{$\gg$\it The second one. $\ll$}\cr
& & & \hskip 10pt  $^\sim$arg1 : float $\rightarrow$&{$\gg$\it The first fun 
arg $\ll$}\cr
& & & \hskip 10pt  $^\sim$arg2 : string list &{$\gg$\it The second one. $\ll$}
\cr
}
  \halign{

\textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
&&&& \cr
$[$ & {\it ret1 }: bool  & $]=$ & {\bf myfun2 } & \cr
& & & \hskip 10pt {\it arg1 }: float $*$ & \cr
& & & \hskip 10pt {\it arg2 }: string list  & \cr
}
  \halign{
\textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # & #\hfill \cr
&&\cr
\textcolor{red}{${\rm\#}$include} &$<$ {\bf sys/io.h }$>$& \cr}
  \halign{

\textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
&&&&\cr
&int  & {\bf cfun }$($&float arg1 ,  & \cr
& & &char arg2 $);$ & \cr
}
  \halign{\textcolor{red}{\strut\vrule width 5pt\hskip 20pt #} & # \cr
  &\cr
  & {$\gg$\it The first value interface $\ll$}\cr}
  \halign{

\textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil  & \qquad # \cr
&&\cr
\textcolor{red}{val} {\bf myval }: 
& arg1 : string  $\rightarrow$ &{$\gg$\it The arg string $\ll$} \cr
& arg2 : int  $\rightarrow$  &  \cr
& {\it retarg }: float  &  \cr
}
  \halign{\textcolor{red}{\strut\vrule width 5pt#}&#\cr&\cr}
  }
    \vskip 2\baselineskip
    The first and the second interfaces show a ML-Function, and the third one is a 
    C-Function interface. This way to display ML-functions is different from the one 
    commonly used in ML interfaces, but more readable. There is also a generic ML-value 
    interface, shown in the fourth part of the example. In the second ML-function an 
    uncurried value tuple is used for the function argument. Either the curried or the 
    uncurried form must be used. The required programming code to get this beauty 
    ML-interfaces is easy to create: 
    \vskip 2\baselineskip
    \halign{
  \hskip3em#\hfil\cr
   \cr
  {\tt \hskip 1em.IN } \cr
  {\tt \hskip 1em \hskip 1em .NA Function interfaces .AN } \cr
  {\tt \hskip 1em \hskip 1em .IF } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .NA myfun1 .AN } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .RV ret1:int .($*$ The first return argument .$*$) .VR } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .RV ret2:bool .($*$ The second one .$*$) .VR } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .AR $^\sim$arg1:float .($*$ The first fun arg .$*$) .RA } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .AR $^\sim$arg2:string list .($*$ The second one .$*$) .RA } \cr
  {\tt \hskip 1em \hskip 1em .FI } \cr
  {\tt \hskip 1em \hskip 1em .IF } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .NA myfun2 .AN } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .RV ret1:bool .VR } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .AV arg1:float .VA } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .AV arg2:string list .VA } \cr
  {\tt \hskip 1em \hskip 1em .FI } \cr
  {\tt \hskip 1em \hskip 1em .CH } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em sys/io.h } \cr
  {\tt \hskip 1em \hskip 1em .HC } \cr
  {\tt \hskip 1em \hskip 1em .CF } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .NA cfun .AN } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .RV int .VR } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .AR float arg1 .RA } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .AR char arg2 .RA } \cr
  {\tt \hskip 1em \hskip 1em .FC } \cr
  {\tt \hskip 1em \hskip 1em .IV } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .($*$ The first value interface .$*$) } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .NA myval .AN } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .AR $^\sim$arg1:string .($*$ The arg string .$*$) .RA } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .AR $^\sim$arg2:int .RA } \cr
  {\tt \hskip 1em \hskip 1em \hskip 1em .AR retarg:float .RA } \cr
  {\tt \hskip 1em \hskip 1em .VI } \cr
  {\tt \hskip 1em .NI } \cr
  {\tt \hskip 1em \hfil} \cr 
  }
    
      \vskip 2\baselineskip
      Always, labels must be marked with a leading tilde character. All other names 
      appearing in value or function names are symbolic names and are displayed in a 
      slatented font. \\
      And an example for such an interface paragraph with ML-types and a ML-class: 
      \vskip 2\baselineskip
      \vbox{\hfil
    \vbox{\hrule
  \hbox{\vrule\qquad
\textcolor{red}{\rule[-.55em]{0pt}{1.7em}\sc Programming Interface}\quad\vrule}
  \hrule}
    }
      \nobreak\vskip \baselineskip\nobreak
      {
    \nobreak\vskip .5\baselineskip 
    \halign{
  
  \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil & #\hfill & \qquad # \hfill \cr
  &&&&\cr
  \textcolor{red}{type} & {\bf mytype } $=$  & 
  &Type$\_$1  & \cr
  &&  $|$ &Type$\_$2  & \cr
  &&  $|$ &Type$\_$3  & \cr
  }
    \halign{
  
  \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil & #\hfill & \qquad # \hfill \cr
  &&&&\cr
  \textcolor{red}{type} & {\bf mytype } $=$  $\{$  & 
  &\textcolor{red}{mutable }a:int $;$ & \cr
  && &b:float $;$ & \cr
  && &c:int list  $\}$  & \cr
  }
    \halign{
  
  \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil & #\hfill & \qquad # \hfill \cr
  &&&&\cr
  \textcolor{red}{exception} & {\bf Failure of string } & 
  \cr
  }
    \halign{
  
  \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil \cr
  &&\cr
  \textcolor{red}{class} & {\bf myclass }: & \cr
   & {\it a }: int $\rightarrow$ & \cr
   & {\it b }: int  & \cr
  & \textcolor{red}{object} & \cr
  &\vbox{
  \halign{
\hskip 20pt \hfill # & # \hfil  & \qquad # \cr
\textcolor{red}{val} \textcolor{red}{mutable }{\bf speed }: 
& {\it dir }: int list  $\rightarrow$  &  \cr
& {\it vl }:  int list  $\rightarrow$  &  \cr
&  ?really :  bool  &  \cr
}
  }&\cr
  &&\cr\noalign{\vglue -1pt}
  &\vbox{
  \halign{
\hskip 20pt \hfill # & # \hfil  & \qquad # \cr
\textcolor{red}{val} {\bf align }: 
& {\it up }: string list  $\rightarrow$  &  \cr
& {\it down }:  int list  $\rightarrow$  &  \cr
&  ?really :  bool  &  \cr
}
  }&\cr
  &&\cr\noalign{\vglue -1pt}
  &\vbox{
  \halign{
\hskip 20pt \hfill # & # \hfil & # & #\hfill \cr
\textcolor{red}{method} \textcolor{red}{private }{\bf up }: 
& & &{\it v }: int  $\rightarrow$ \cr
& & &{\it name }: string  $\rightarrow$ \cr
& & &arg3 : int int list list  $\rightarrow$ \cr
& & & () \cr
}
  }&\cr
  &&\cr\noalign{\vglue -1pt}
   & \textcolor{red}{end} & \cr
  }
  \halign{
\textcolor{red}{\strut\vrule width 5pt\qquad#}\tabskip=0pt plus 1fil& 
  #\hfil& #&\hfil#\hfil& 
  \tabskip=0pt#\cr &&&& \cr
 module & {\bf mymod } &&& \cr & sig &&& \cr
&\vbox{
  \vskip .1\baselineskip
  \halign{
    \hskip 20pt \hfill # & # \hfil & # & # \hfill & \qquad # \hfill \cr
    &&&&\cr
    \textcolor{red}{type} & {\bf mytype } $=$  & 
    &Type$\_$1  & \cr
    &&  $|$ &Type$\_$2  & \cr
    &&  $|$ &Type$\_$3  & \cr
    }
  \vskip .1\baselineskip} &&& \cr \noalign{\vglue -1pt}\noalign{\allowbreak}
& \vbox{
\vskip .1\baselineskip
\halign{
  \hskip 20pt \hfill # & # \hfil  & \qquad # \cr
  \textcolor{red}{val} {\bf align }: 
  & {\it up }: string list  $\rightarrow$  &  \cr
  & {\it down }:  int list  $\rightarrow$  &  \cr
  &  ?really :  bool  &  \cr
  }
\vskip .1\baselineskip} &&& \cr \noalign{\vglue -1pt}\noalign{\allowbreak}
  & \vbox{
  \vskip .1\baselineskip
  \halign{
\hskip 20pt \hfill # & # \hfil  & \qquad # \cr
\textcolor{red}{val} \textcolor{red}{mutable }{\bf speed }: 
& {\it dir }: int list  $\rightarrow$  &  \cr
& {\it vl }:  int list  $\rightarrow$  &  \cr
&  ?really :  bool  &  \cr
}
  \vskip .1\baselineskip} &&& \cr \noalign{\vglue -1pt}\noalign{\allowbreak}
     & end &&& \cr&&&& \cr
    }
      \halign{\textcolor{red}{\strut\vrule width 5pt#}&#\cr&\cr}
      }
        \vskip 2\baselineskip
        which was produced with this source code: 
        \vskip 2\baselineskip
        \halign{
      \hskip3em#\hfil\cr
       \cr
      {\tt \hskip 1em.IN } \cr
      {\tt \hskip 1em \hskip 1em .IT } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .NA mytype .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .AR Type$\_$1 .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .AR Type$\_$2 .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .AR Type$\_$3 .RA } \cr
      {\tt \hskip 1em \hskip 1em .TI } \cr
      {\tt \hskip 1em \hskip 1em .IS } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .NA mytype .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .AR .MU a:int .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .AR b:float .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .AR c:int list .RA } \cr
      {\tt \hskip 1em \hskip 1em .SI } \cr
      {\tt \hskip 1em \hskip 1em .CS } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .NA myclass .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .AR a:int .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .AR b:int .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .OB } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .IV } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .NA .MU speed .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR dir:int list .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR vl: int list .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR ?really: bool .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .VI } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .IV } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .NA align .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR up:string list .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR down: int list .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR ?really: bool .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .VI } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .MT } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .NA .PV up .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR v:int .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR name:string .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR $^\sim$arg3:int int list list .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR () .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .TM } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .BO } \cr
      {\tt \hskip 1em \hskip 1em .SC } \cr
      {\tt \hskip 1em \hskip 1em .IM } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .NA mymod .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .IT } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .NA mytype .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR Type$\_$1 .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR Type$\_$2 .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR Type$\_$3 .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .TI } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .IV } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .NA align .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR up:string list .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR down: int list .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR ?really: bool .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .VI } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .IV } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .NA .MU speed .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR dir:int list .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR vl: int list .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em \hskip 1em .AR ?really: bool .RA } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .VI } \cr
      {\tt \hskip 1em \hskip 1em .MI } \cr
      {\tt \hskip 1em .NI } \cr
      {\tt \hskip 1em \hfil} \cr 
      }
        
          \vskip 2\baselineskip
          The class interface needs the class name, optional arguments, and the object block with 
          values and methods. Of course, all possible special interfaces can be mixed, and the 
          interface subunit is not required, but strongly recommended. Currently, only simple 
          module signatures without functors are supported. 
          \vfill \eject
          \vbox{\hsize \textwidth
        \hrule
        \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
      \label{Paragraphelements}\textcolor{blue}{\sc {\sl Paragraph elements }} \hfill 
      \textcolor[rgb]{.0,.7,.0}{\sc  MlDoC dot commands}\quad \vrule}\hrule}
        
          \vskip \baselineskip
          In this section, all generic paragraph elements like lists are described. \\
          There are three different kinds of list you can use: 
          \vskip \baselineskip
          \begin{minipage}{.9\textwidth}\vbox{
        \begin{itemize}
      \item Numbered lists (aka ordered lists) 
      \item Unnumbered lists (aka unordered lists) 
      \item Option lists (aka definition lists) 
      \end{itemize}
        }\end{minipage}
          \vskip \baselineskip
          \vskip .5\baselineskip 
          {\parindent 0pt \vbox{\sc Lists }
          \leftskip 20pt \vskip .5\baselineskip
          \begin{list}{}{}\item{\parindent 0pt 
        Lists of different kind can be mixed and stacked to an arbitrary depth. 
        \vskip 2\baselineskip
        \begin{center}
      \begin{tabular}{|p{3.3cm}|p{1.8cm}|p{1.5cm}|p{3.3cm}|}\hline
    \multicolumn{4}{|c|}{\textcolor{red}{\sc Lists }}\\\hline\hline
    {\bf Name }&{\bf begin }&{\bf end }&{\bf Comment }\\\hline
    Ordered (numbered) List &{\tt .OL }&{\tt .LO }&\\\hline
    Unordered List &{\tt .UL }&{\tt .LU }&\\\hline
    Option List &{\tt .PL }&{\tt .LP }&First command in List item must be a Name. 
    \\\hline
    List item &{\tt .LI }&{\tt .IL }&Used inside lists only. \\\hline
    \end{tabular}
      \end{center}
        \vskip 2\baselineskip
        \vskip \baselineskip
        \begin{minipage}{.9\textwidth}\vbox{
      \begin{enumerate}
    \item 1 
    \item 2 
    \end{enumerate}
      }\end{minipage}
        \vskip \baselineskip
        Here is an example for an option list: 
        \vskip 2\baselineskip
        \vbox{\hfil
      \vbox{\hrule
    \hbox{\vrule\qquad
  {\rule[-.55em]{0pt}{1.7em}\sc Options }\qquad\vrule}
    \hrule}
      }
        \nobreak\vskip \baselineskip\nobreak
        \begin{list}{}{}\item{\parindent 0pt 
      \begin{description}
    \item[ -a]
  {\hfill\\}
  This program option is used to show all available options. It's not needed in the 
  server mode, but it's possible use this option in client mode. 
    \item[ -b]
  {\hfill\\}
  This program option is used to build all available options. 
    \item[ -c]
  {\hfill\\}
  This program option is used to convert all available options. 
    \end{description}
      }\end{list}
        \vskip .5\baselineskip
        \vskip \baselineskip
        The required source code for this option list is shown below: 
        \vskip 2\baselineskip
        \halign{
      \hskip3em#\hfil\cr
       \cr
      {\tt \hskip 1em.PL } \cr
      {\tt \hskip 1em \hskip 1em .LI } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .NA -a .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em This program option is used to show all available options. } \cr
      {\tt \hskip 1em \hskip 1em .IL } \cr
      {\tt \hskip 1em \hskip 1em .LI } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em .NA -b .AN } \cr
      {\tt \hskip 1em \hskip 1em \hskip 1em This program option is used to build all available options. } \cr
      {\tt \hskip 1em \hskip 1em .IL } \cr
      {\tt \hskip 1em .LP } \cr
      {\tt \hskip 1em \hfil} \cr 
      }
        
          \vskip 2\baselineskip
          The {\sl Option List }header can be changed with the {\sl Name }argument, too. 
          }\end{list}}
            \vskip .5\baselineskip
            \vskip .5\baselineskip 
            {\parindent 0pt \vbox{\sc Tables }
            \leftskip 20pt \vskip .5\baselineskip
            \begin{list}{}{}\item{\parindent 0pt 
          There is support for simple tables, too. A {\sl MlDoC }table is comparable with HTML 
          tables. You need to specifiy the table body, an optional table head, table rows and in 
          each table row the table column data. 
          \vskip 2\baselineskip
          \begin{center}
        \begin{tabular}{|p{3.3cm}|p{1.8cm}|p{1.5cm}|p{3.3cm}|}\hline
      \multicolumn{4}{|c|}{\textcolor{red}{\sc Tables }}\\\hline\hline
      {\bf Name }&{\bf begin }&{\bf end }&{\bf Comment }\\\hline
      Table body &{\tt .TB }&{\tt .BT }&\\\hline
      NoRulers &{\tt .NR }&&Don't put boxes around the table cells. \\\hline
      Table head &{\tt .TH }&{\tt .HT }&Optional table head row. \\\hline
      Table row &{\tt .TR }&{\tt .RT }&\\\hline
      Table columns &{\tt .TC }&{\tt .CT }&Must be included between the row command. 
      \\\hline
      \end{tabular}
        \end{center}
          \vskip 2\baselineskip
          Here is a small example for a generic table: 
          \vskip 2\baselineskip
          \begin{center}
        \begin{tabular}{|p{1.5cm}|p{1.5cm}|}\hline
      1 &2 \\\hline
      3 &4 \\\hline
      \end{tabular}
        \end{center}
          \vskip 2\baselineskip
          and the required source code: 
          \vskip 2\baselineskip
          \halign{
        \hskip3em#\hfil\cr
         \cr
        {\tt \hskip 1em.TB } \cr
        {\tt \hskip 1em \hskip 1em .TR } \cr
        {\tt \hskip 1em \hskip 1em \hskip 1em .TC 1 .CT } \cr
        {\tt \hskip 1em \hskip 1em \hskip 1em .TC 2 .CT } \cr
        {\tt \hskip 1em \hskip 1em .RT } \cr
        {\tt \hskip 1em \hskip 1em .TR } \cr
        {\tt \hskip 1em \hskip 1em \hskip 1em .TC 3 .CT } \cr
        {\tt \hskip 1em \hskip 1em \hskip 1em .TC 4 .CT } \cr
        {\tt \hskip 1em \hskip 1em .RT } \cr
        {\tt \hskip 1em .BT } \cr
        {\tt \hskip 1em \hfil} \cr 
        }
          
            \vskip 2\baselineskip
            The horizontal and vertical rulers are always present and can be removed with the {\sl 
            NoRulers }command. The {\tt .NR }command must follow the {\sl TableBody }command 
            immediately. The above table looks then like: 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}}
        1 &2 \\
        3 &4 \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              Misc. elements: 
              \vskip 2\baselineskip
              \begin{center}
            \begin{tabular}{|p{3.3cm}|p{1.8cm}|p{1.5cm}|p{3.3cm}|}\hline
          {\bf Name }&{\bf begin }&{\bf end }&{\bf Description }\\\hline
          Name &{\tt .NA }&{\tt .AN }&Outside from special interfaces, this command emphasize names 
          of functions, types or other important names. \\\hline
          Link &{\tt .LK }&{\tt .KL }&A link to another section or document \\\hline
          \end{tabular}
            \end{center}
              \vskip 2\baselineskip
              \vfill \eject
              \vbox{\hsize \textwidth
            \hrule
            \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
          \label{Textelements}\textcolor{blue}{\sc {\sl Text elements }} \hfill 
          \textcolor[rgb]{.0,.7,.0}{\sc  MlDoC dot commands}\quad \vrule}\hrule}
            
              \vskip \baselineskip
              \vskip 2\baselineskip
              \begin{center}
            \begin{tabular}{|p{3.3cm}|p{1.8cm}|p{1.5cm}|p{3.3cm}|}\hline
          {\bf Name }&{\bf begin }&{\bf end }&{\bf Description }\\\hline
          Newline &{\tt .NL }&&Flush the current text paragraph and force a newline. \\\hline
          Indentmark &{\tt .$\#$ }&&Increase the current text indention. Only used in preformatted 
          paragraphs like examples. \\\hline
          Preformatted text ('as is') &{\tt . [ }&{\tt . ] }&Print inlined raw text. Ignore all dot 
          commands. \\\hline
          Comments &{\tt .($*$ }&{\tt .$*$) }&Comments can be placed in {\sl Arguments }. \\\hline
          \end{tabular}
            \end{center}
              \vskip 2\baselineskip
              See \fbox{\small {\sc Special Interfaces} (p. \pageref{SpecialInterfaces})} for comment 
              examples and the place to use them. Use the {\sl Newline }command only to finish the current 
              text paragraph, and not to create space between paragraphs or other structure elements. \\
              There are several text attribute commands controlling the appearence of text. All font styles 
              must be switched off with the {\tt .R }regular style command. 
              \vskip 2\baselineskip
              \begin{center}
            \begin{tabular}{|p{6.6cm}|p{2.4cm}|}\hline
          \multicolumn{2}{|c|}{\textcolor{red}{\sc Text attributes }}\\\hline\hline
          {\bf Attribute }&{\bf command }\\\hline
          {\bf Boldface style }&{\tt .B }\\\hline
          {\it Italic style }&{\tt .I }\\\hline
          {\bf\sl Boldface and italic style }&{\tt .BI }\\\hline
          {\tt Typewriter style }&{\tt .T }\\\hline
          Romane style (default) &{\tt .R }\\\hline
          Superscript $^{\rm textmode\quad}$&{\tt .SP }{\tt .PS }\\\hline
          Subscript $_{\rm textmode\quad}$&{\tt .SB }{\tt .BS }\\\hline
          \end{tabular}
            \end{center}
              \vskip 2\baselineskip
              \vfill \eject
              \vbox{\hsize \textwidth
            \hrule
            \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
          \label{Summaryofdotcommands}\textcolor{blue}{\sc {\sl Summary of dot commands }} \hfill 
          \textcolor[rgb]{.0,.7,.0}{\sc  MlDoC dot commands}\quad \vrule}\hrule}
            
              \vskip \baselineskip
              \vskip .5\baselineskip 
              {\parindent 0pt \vbox{\sc \label{Textstylesandspecialtext}Text styles and special text }
              \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}p{4.4cm}}
        {\tt .B }&{\tt .R }&Bold text style \\
        {\tt .BI }&{\tt .R }&Bold-Italic text style \\
        {\tt .I }&{\tt .R }&Italic text style \\
        {\tt .T }&{\tt .R }&Typewriter text style \\
        {\tt .S }&{\tt .R }&Symbol text style [NA] \\
        {\tt .SB }&{\tt .BS }&Subscript text mode \\
        {\tt .SP }&{\tt .PS }&Superscript text mode \\
        {\tt . [ }&{\tt . ] }&'As-Is' text mode \\
        {\tt .NL }&&Newline: End of paragraph \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              \vskip .5\baselineskip 
              {\parindent 0pt \vbox{\sc \label{Specialdotcommands}Special dot commands }
              \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}p{4.4cm}}
        {\tt .MU }&&Special ML-attribute {\sl mutable }\\
        {\tt .PV }&&Special ML-attribute {\sl private }\\
        {\tt .VT }&&Special ML-attribute {\sl virtual }\\
        {\tt .NR }&&No rulers around tables and table cells \\
        {\tt .$\#$ }&&White Space in {\sl example }and {\sl As-Is }environments \\
        {\tt .<< }&{\tt .>> }&Include a {\sl MlDoc }file at the current position \\
        {\tt .LK }&{\tt .KL }&A document link \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              \vskip .5\baselineskip 
              {\parindent 0pt \vbox{\sc \label{Listcommands}List commands }
              \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}p{4.4cm}}
        {\tt .OL }&{\tt .LO }&Numbered (ordered) list body \\
        {\tt .UL }&{\tt .LU }&Unnumbered (unorderd) list body \\
        {\tt .PL }&{\tt .LP }&Option (definition) list \\
        {\tt .LI }&{\tt .IL }&A list item \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              \vskip .5\baselineskip 
              {\parindent 0pt \vbox{\sc \label{Tablecommands}Table commands }
              \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}p{4.4cm}}
        {\tt .TB }&{\tt .BT }&Table body \\
        {\tt .TR }&{\tt .RT }&Table row \\
        {\tt .TC }&{\tt .CT }&Table column \\
        {\tt .TH }&{\tt .HT }&Optional table head \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              \vskip .5\baselineskip 
              {\parindent 0pt \vbox{\sc \label{SpecialInterfacescommands}Special Interfaces commands }
              \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}p{4.4cm}}
        {\tt .IF }&{\tt .FI }&ML-Function Interface \\
        {\tt .IV }&{\tt .VI }&ML-Value Interface \\
        {\tt .IT }&{\tt .TI }&ML-Type Interface \\
        {\tt .IS }&{\tt .SI }&ML-Structure Interface \\
        {\tt .IX }&{\tt .XI }&ML-Exception Interface \\
        {\tt .IM }&{\tt .MI }&ML-Module Interface \\
        {\tt .CH }&{\tt .HC }&C-Header Interface \\
        {\tt .CF }&{\tt .FC }&C-Function Interface \\
        {\tt .CV }&{\tt .VC }&C-Variable Interface \\
        {\tt .CS }&{\tt .SC }&ML-Class Interface \\
        {\tt .OB }&{\tt .BO }&ML-Object (Class) Interface \\
        {\tt .MT }&{\tt .TM }&ML-Method (Class) Interface \\
        {\tt }&{\tt }&\\
        {\tt .NA }&{\tt .AN }&Name argument \\
        {\tt .AR }&{\tt .RA }&Curried value argument \\
        {\tt .AV }&{\tt .VA }&Uncurried (tuple) value argument \\
        {\tt .RV }&{\tt .VR }&Return argument of a function \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              \vskip .5\baselineskip 
              {\parindent 0pt \vbox{\sc \label{Sectioncommands}Section commands }
              \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}p{4.4cm}}
        {\tt .PR }&{\tt .RP }&Program Section \\
        {\tt .PK }&{\tt .KP }&Package Section \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              \vskip .5\baselineskip 
              {\parindent 0pt \vbox{\sc \label{Subsectioncommands}Subsection commands }
              \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}p{3cm}}
        {\tt .MD }&{\tt .DM }&ML-Module \\
        {\tt .CY }&{\tt .YC }&C-Library \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              \vskip .5\baselineskip 
              {\parindent 0pt \vbox{\sc \label{UnitsofaSubsectionManualPagecommands}Units of a Subsection 
              (Manual Page) commands }
              \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}p{4.4cm}}
        {\tt .FU }&{\tt .UF }&ML-Function \\
        {\tt .MV }&{\tt .VM }&ML-Value \\
        {\tt .TP }&{\tt .PT }&ML-Type (generic) \\
        {\tt .CL }&{\tt .LC }&ML-Class \\
        {\tt .CI }&{\tt .IC }&C \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              \vskip .5\baselineskip 
              {\parindent 0pt \vbox{\sc \label{Subunitcommands}Subunit commands }
              \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}p{4.4cm}}
        {\tt .IN }&{\tt .NI }&Generic Interface Paragraph \\
        {\tt .EX }&{\tt .XE }&Example Paragraph \\
        {\tt .\{ }&{\tt .\} }&Preformatted Paragraph \\
        {\tt .PA }&{\tt .AP }&A named Paragraph \\
        {\tt .IO }&{\tt .OI }&An Introduction Paragraph \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              \vskip .5\baselineskip 
              {\parindent 0pt \vbox{\sc \label{GenericSectionSubsectionUnitSubunitcommands}Generic Section, 
              Subsection, Unit, Subunit commands }
              \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
            \vskip 2\baselineskip
            \begin{center}
          \begin{tabular}{p{1.5cm}p{1.5cm}p{4.4cm}}
        {\tt .S1 }&{\tt .1S }&Generic Section \\
        {\tt .S2 }&{\tt .2S }&Generic Subsection \\
        {\tt .S3 }&{\tt .3S }&Generic Unit \\
        {\tt .S4 }&{\tt .4S }&Generic Subunit \\
        \end{tabular}
          \end{center}
            \vskip 2\baselineskip
            }\end{list}}
              \vskip .5\baselineskip
              \vfill \eject
              \vbox{\hsize \textwidth
            \hrule
            \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
          \label{CompileanduseoftheMlDoCpackage}\textcolor{blue}{\sc {\sl Compile and use of the 
          MlDoC package }} \hfill 
          \textcolor[rgb]{.0,.7,.0}{\sc  MlDoC dot commands}\quad \vrule}\hrule}
            
              \vskip \baselineskip
              First you must compile the package, consisting of the core module, the backend and the 
              frontend modules. Here the steps needed for the case you use the generic OCaML system, 
              version 3.XX: 
              \vskip 2\baselineskip
              \halign{
            \hskip3em#\hfil\cr
             \cr
            {\tt \hskip 1emocamlc -c doc$\_$core.ml } \cr
            {\tt \hskip 1em ocamlc -c doc$\_$html.mli } \cr
            {\tt \hskip 1em ocamlc -c doc$\_$html.ml } \cr
            {\tt \hskip 1em ocamlc -c doc$\_$latex.mli } \cr
            {\tt \hskip 1em ocamlc -c doc$\_$latex.ml } \cr
            {\tt \hskip 1em ocamlc -c doc$\_$text.mli } \cr
            {\tt \hskip 1em ocamlc -c doc$\_$text.ml } \cr
            {\tt \hskip 1em ocamlc -c doc$\_$help.ml } \cr
            {\tt \hskip 1em ocamlc -a doc$\_$core.cmo } \cr
            {\tt \hskip 1em \hskip 1em \hskip 1em doc$\_$html.cmo } \cr
            {\tt \hskip 1em \hskip 1em \hskip 1em doc$\_$latex.cmo } \cr
            {\tt \hskip 1em \hskip 1em \hskip 1em doc$\_$text.cmo } \cr
            {\tt \hskip 1em \hskip 1em \hskip 1em doc$\_$help.cmo -o mldoc.cma } \cr
            {\tt \hskip 1em \hfil} \cr 
            }
              
                \vskip 2\baselineskip
                You need the {\sl Terminfo }interface file {\tt terminfo.cmi }to be able to compile the {\sl 
                Doc$\_$text }module. \\
                For {\sl VamSyS }users: 
                \vskip 2\baselineskip
                \halign{
              \hskip3em#\hfil\cr
               \cr
              {\tt \hskip 1emvamcomp doc$\_$core.ml } \cr
              {\tt \hskip 1em vamcomp doc$\_$html.mli } \cr
              {\tt \hskip 1em vamcomp doc$\_$html.ml } \cr
              {\tt \hskip 1em vamcomp doc$\_$latex.mli } \cr
              {\tt \hskip 1em vamcomp doc$\_$latex.ml } \cr
              {\tt \hskip 1em vamcomp doc$\_$text.mli } \cr
              {\tt \hskip 1em vamcomp doc$\_$text.ml } \cr
              {\tt \hskip 1em vamcomp doc$\_$help.ml } \cr
              {\tt \hskip 1em vamar doc$\_$core.cmo } \cr
              {\tt \hskip 1em \hskip 1em \hskip 1em doc$\_$html.cmo } \cr
              {\tt \hskip 1em \hskip 1em \hskip 1em doc$\_$latex.cmo } \cr
              {\tt \hskip 1em \hskip 1em \hskip 1em doc$\_$text.cmo } \cr
              {\tt \hskip 1em \hskip 1em \hskip 1em doc$\_$help.cmo -o mldoc.cma } \cr
              {\tt \hskip 1em \hfil} \cr 
              }
                
                  \vskip 2\baselineskip
                  \vfill \eject
                  \vbox{\hsize \textwidth
                \hrule
                \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad \hfill
              \label{mldoc}\textcolor{blue}{\sc Package: {\sl mldoc }} \hfill
              \quad \vrule}\hrule}
                
                  \vskip \baselineskip
                  The {\sl mldoc }library is the heart of the {\sl MlDoC }system. It's divided in the core module 
                  and various backend modules and some frontend modules. 
                  \vfill \eject
                  \vbox{\hsize \textwidth
                \hrule
                \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
              \label{doc$_$core}\textcolor{blue}{\sc ML-Module: {\sl doc$\_$core }} \hfill 
              \textcolor[rgb]{.0,.7,.0}{\sc Package:  mldoc}\quad \vrule}\hrule}
                
                  \vskip \baselineskip
                  \vskip .5\baselineskip 
                  {\parindent 0pt \vbox{\sc \label{Description}Description }
                  \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
                The core module of {\sl MlDoC }. This module contains all basic functions and types used by all 
                other frontend and backend modules. }\end{list}}
                  \vskip .5\baselineskip
                  Flow of processing string text: 
                  \vskip \baselineskip
                  \begin{minipage}{.9\textwidth}\vbox{
                \begin{enumerate}
              \item Split the string text in atoms divided by blank spaces. 
              \item Translate these atoms in a structure tree. 
              \item Convert the structure tree into the desired output format. 
              \end{enumerate}
                }\end{minipage}
                  \vskip \baselineskip
                  First the interface of the main {\sl structure$\_$content }type and the the main {\sl 
                  structure$\_$block }: 
                  \vskip 2\baselineskip
                  \vbox{\hfil
                \vbox{\hrule
              \hbox{\vrule\qquad
            \textcolor{red}{\rule[-.55em]{0pt}{1.7em}\sc Programming Interface}\quad\vrule}
              \hrule}
                }
                  \nobreak\vskip \baselineskip\nobreak
                  {
                \nobreak\vskip .5\baselineskip 
                \halign{
              
              \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil & #\hfill & \qquad # \hfill \cr
              &&&&\cr
              \textcolor{red}{type} & {\bf structure$\_$content } $=$  & 
              &S$\_$Empty &{$\gg$\it Empty element $\ll$}\cr
              &&  $|$ &S$\_$Text of (string list) &{$\gg$\it Generic text: basic element $\ll$}\cr
              &&  $|$ &S$\_$Body &{$\gg$\it Document root $\ll$}\cr
              &&  $|$ &S$\_$Title &{$\gg$\it Document title $\ll$}\cr
              &&  $|$ &S$\_$TOC &{$\gg$\it Table of contents $\ll$}\cr
              &&  $|$ &S$\_$Intro &{$\gg$\it An intro paragraph $\ll$}\cr
              &&  $|$ &S$\_$Package &{$\gg$\it Package$=$Library $\ll$}\cr
              &&  $|$ &S$\_$Program &{$\gg$\it A program description $\ll$}\cr
              &&  $|$ &S$\_$S1 &{$\gg$\it Generic named section $\ll$}\cr
              &&  $|$ &S$\_$Module &{$\gg$\it A ML-module $\ll$}\cr
              &&  $|$ &S$\_$Clib &{$\gg$\it A C-Library $\ll$}\cr
              &&  $|$ &S$\_$S2 &{$\gg$\it Generic subsection $\ll$}\cr
              &&  $|$ &S$\_$Function &{$\gg$\it A function subsection $\ll$}\cr
              &&  $|$ &S$\_$Type &{$\gg$\it A type subsection $\ll$}\cr
              &&  $|$ &S$\_$Value &{$\gg$\it A value subsection $\ll$}\cr
              &&  $|$ &S$\_$Class &{$\gg$\it A class subsection $\ll$}\cr
              &&  $|$ &S$\_$C &{$\gg$\it C functions and variables $\ll$}\cr
              &&  $|$ &S$\_$S3 &{$\gg$\it Generic unit $\ll$}\cr
              &&  $|$ &S$\_$Paragraph &{$\gg$\it A named paragraph $\ll$}\cr
              &&  $|$ &S$\_$Interface &{$\gg$\it Generic Interface $\ll$}\cr
              &&  $|$ &S$\_$Example &{$\gg$\it Example preformatted paragraph $\ll$}\cr
              &&  $|$ &S$\_$Preform &{$\gg$\it Preformatted paragraph $\ll$}\cr
              &&  $|$ &S$\_$S4 &{$\gg$\it Generic subunit $\ll$}\cr
              &&  $|$ &S$\_$Fun$\_$Interface &{$\gg$\it ML-Function interface $\ll$}\cr
              &&  $|$ &S$\_$Val$\_$Interface &{$\gg$\it ML-Value interface $\ll$}\cr
              &&  $|$ &S$\_$Type$\_$Interface &{$\gg$\it A ML-type definition $\ll$}\cr
              &&  $|$ &S$\_$Exc$\_$Interface &{$\gg$\it Exception $\ll$}\cr
              &&  $|$ &S$\_$Struc$\_$Interface &{$\gg$\it A type structure $\ll$}\cr
              &&  $|$ &S$\_$C$\_$Hdr$\_$Interface &{$\gg$\it C header interface $\ll$}\cr
              &&  $|$ &S$\_$C$\_$Fun$\_$Interface &{$\gg$\it C function interface $\ll$}\cr
              &&  $|$ &S$\_$C$\_$Var$\_$Interface &{$\gg$\it C variable interface $\ll$}\cr
              &&  $|$ &S$\_$Class$\_$Interface &{$\gg$\it A ML-Class $\ll$}\cr
              &&  $|$ &S$\_$Method$\_$Interface &{$\gg$\it A ML method of a class $\ll$}\cr
              &&  $|$ &S$\_$Object$\_$Interface &{$\gg$\it A ML object of a class $\ll$}\cr
              &&  $|$ &S$\_$Module$\_$Interface &{$\gg$\it A ML module interface $\ll$}\cr
              &&  $|$ &S$\_$Attribute &{$\gg$\it Text or other attributes changes $\ll$}\cr
              &&  $|$ &S$\_$OList &{$\gg$\it Ordered List $\ll$}\cr
              &&  $|$ &S$\_$UList &{$\gg$\it Unordered List $\ll$}\cr
              &&  $|$ &S$\_$OpList &{$\gg$\it Definition List $\ll$}\cr
              &&  $|$ &S$\_$List$\_$Item &{$\gg$\it Unordered List item $\ll$}\cr
              &&  $|$ &S$\_$Table &{$\gg$\it Table body $\ll$}\cr
              &&  $|$ &S$\_$TableHead &{$\gg$\it Table header $\ll$}\cr
              &&  $|$ &S$\_$TableRow &{$\gg$\it A new table row $\ll$}\cr
              &&  $|$ &S$\_$TableCol &{$\gg$\it Table column data $\ll$}\cr
              &&  $|$ &S$\_$TableNoRulers &{$\gg$\it Don't put boxes around the table cells $\ll$}\cr
              &&  $|$ &S$\_$Name &{$\gg$\it Function, Type,... name $\ll$}\cr
              &&  $|$ &S$\_$Mutable &{$\gg$\it Mutable prefix $\ll$}\cr
              &&  $|$ &S$\_$Private &{$\gg$\it Provate prefix $\ll$}\cr
              &&  $|$ &S$\_$Virtual &{$\gg$\it Virtual prefix $\ll$}\cr
              &&  $|$ &S$\_$CurArg &{$\gg$\it Argument of a curried list $\ll$}\cr
              &&  $|$ &S$\_$UnCurArg &{$\gg$\it Argument of an uncurried list:tuple $\ll$}\cr
              &&  $|$ &S$\_$RetArg &{$\gg$\it Return argument of a function $\ll$}\cr
              &&  $|$ &S$\_$NL &{$\gg$\it Newline $\ll$}\cr
              &&  $|$ &S$\_$TAB &{$\gg$\it Text tabulation $\ll$}\cr
              &&  $|$ &S$\_$Link &{$\gg$\it Link $\ll$}\cr
              &&  $|$ &S$\_$Comment &{$\gg$\it A comment $\ll$}\cr
              }
                \halign{
              
              \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil & #\hfill & \qquad # \hfill \cr
              &&&&\cr
              \textcolor{red}{type} & {\bf structure$\_$block } $=$  $\{$  & 
              &\textcolor{red}{mutable }s$\_$parent: structure$\_$block option $;$ & \cr
              && &\textcolor{red}{mutable }s$\_$childs: structure$\_$block list $;$ & \cr
              && &\textcolor{red}{mutable }s$\_$content: structure$\_$content $;$ & \cr
              && &\textcolor{red}{mutable }s$\_$attr: structure$\_$attr list $;$ & \cr
              && &\textcolor{red}{mutable }s$\_$line: int $;$&{$\gg$\it For error tracking $\ll$}\cr
              && &\textcolor{red}{mutable }s$\_$name: string ref  $\}$ &{$\gg$\it For error tracking $\ll$}
              \cr
              }
                \halign{\textcolor{red}{\strut\vrule width 5pt#}&#\cr&\cr}
                }
                  \vskip 2\baselineskip
                  A string can be converted to an atom list with the {\sl atoms$\_$of$\_$text }function, and the 
                  {\sl atoms$\_$of$\_$file }functions reads text from a file and convert it to an atom list: 
                  \vskip 2\baselineskip
                  \vbox{\hfil
                \vbox{\hrule
              \hbox{\vrule\qquad
            \textcolor{red}{\rule[-.55em]{0pt}{1.7em}\sc Programming Interface}\quad\vrule}
              \hrule}
                }
                  \nobreak\vskip \baselineskip\nobreak
                  {
                \nobreak\vskip .5\baselineskip 
                \halign{
              
              \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
              &&&& \cr
              $[$ & {\it atom$\_$list }:  string list  & $]=$ & {\bf atoms$\_$of$\_$text } & \cr
              & & & \hskip 10pt  $^\sim$text :  string  & \cr
              }
                \halign{
              
              \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
              &&&& \cr
              $[$ & {\it atom$\_$list }:  string list  & $]=$ & {\bf atoms$\_$of$\_$file } & \cr
              & & & \hskip 10pt  $^\sim$fname :  string  & \cr
              }
                \halign{\textcolor{red}{\strut\vrule width 5pt#}&#\cr&\cr}
                }
                  \vskip 2\baselineskip
                  The atom list can now be converted to a {\sl struture$\_$block }tree with the {\sl 
                  tree$\_$of$\_$atoms }function. This function uses the {\sl parse }generic text parser function. 
                  Finally, a {\sl structure$\_$block }tree can be printed in symbolic form with the {\sl 
                  print$\_$tree }function. 
                  \vskip 2\baselineskip
                  \vbox{\hfil
                \vbox{\hrule
              \hbox{\vrule\qquad
            \textcolor{red}{\rule[-.55em]{0pt}{1.7em}\sc Programming Interface}\quad\vrule}
              \hrule}
                }
                  \nobreak\vskip \baselineskip\nobreak
                  {
                \nobreak\vskip .5\baselineskip 
                \halign{
              
              \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
              &&&& \cr
              $[$ &  unit  & $]=$ & {\bf parse } & \cr
              & & & \hskip 10pt {\it atom$\_$list }:  string list $\rightarrow$ & \cr
              & & & \hskip 10pt {\it cur$\_$block }:  structure$\_$block  & \cr
              }
                \halign{
              
              \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
              &&&& \cr
              $[$ & {\it struc$\_$tree }:  structure$\_$block  & $]=$ & {\bf tree$\_$of$\_$atoms } & \cr
              & & & \hskip 10pt  $^\sim$atoms :  string list  & \cr
              }
                \halign{
              
              \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
              &&&& \cr
              $[$ &  unit  & $]=$ & {\bf print$\_$tree } & \cr
              & & & \hskip 10pt  structure$\_$block  & \cr
              }
                \halign{\textcolor{red}{\strut\vrule width 5pt#}&#\cr&\cr}
                }
                  \vskip 2\baselineskip
                  Sometimes it's usefull to convert only a part of the full document. For this purpose, all back 
                  end functions have the {\sl section$\_$names }list argument to tell the backend the current 
                  section environment. The {\sl Doc$\_$core }module defines the {\sl section }structure and the 
                  {\sl section$\_$names }types. The structure is only for internal use in the backend. 
                  \vskip 2\baselineskip
                  \vbox{\hfil
                \vbox{\hrule
              \hbox{\vrule\qquad
            \textcolor{red}{\rule[-.55em]{0pt}{1.7em}\sc Programming Interface}\quad\vrule}
              \hrule}
                }
                  \nobreak\vskip \baselineskip\nobreak
                  {
                \nobreak\vskip .5\baselineskip 
                \halign{
              
              \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil & #\hfill & \qquad # \hfill \cr
              &&&&\cr
              \textcolor{red}{type} & {\bf section$\_$names } $=$  & 
              &Sec$\_$s1 of string  & \cr
              &&  $|$ &Sec$\_$s2 of string  & \cr
              &&  $|$ &Sec$\_$s3 of string  & \cr
              &&  $|$ &Sec$\_$s4 of string  & \cr
              &&  $|$ &Sec$\_$package of string  & \cr
              &&  $|$ &Sec$\_$program of string  & \cr
              &&  $|$ &Sec$\_$module of string  & \cr
              &&  $|$ &Sec$\_$function of string  & \cr
              &&  $|$ &Sec$\_$type of string  & \cr
              &&  $|$ &Sec$\_$val of string  & \cr
              &&  $|$ &Sec$\_$class of string  & \cr
              &&  $|$ &Sec$\_$cint of string  & \cr
              }
                \halign{
              
              \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil & #\hfill & \qquad # \hfill \cr
              &&&&\cr
              \textcolor{red}{type} & {\bf section } $=$  $\{$  & 
              &\textcolor{red}{mutable }sec$\_$parent: section $;$ & \cr
              && &\textcolor{red}{mutable }sec$\_$childs: section list $;$ & \cr
              && &\textcolor{red}{mutable }sec$\_$name: string $;$ & \cr
              && &\textcolor{red}{mutable }sec$\_$type: string  $\}$  & \cr
              }
                \halign{\textcolor{red}{\strut\vrule width 5pt#}&#\cr&\cr}
                }
                  \vskip 2\baselineskip
                  A short example follows to show the processing flow to translate a help text file to a {\sl 
                  structure$\_$block }tree. 
                  \vskip 2\baselineskip
                  \vbox{\hfil
                \vbox{\hrule
              \hbox{\vrule\qquad
            \textcolor{blue}{\rule[-.55em]{0pt}{1.7em}\sc Programming Example}\quad\vrule}
              \hrule}
                }
                  \nobreak\vskip \baselineskip\nobreak
                  \halign to \textwidth{
                \textcolor[rgb]{.58,.76,1.0}{\strut\vrule width 5pt#}\tabskip=0pt plus 1fil& 
                  #\hfil& #&\hfil#\hfil& 
                  \tabskip=0pt#\cr
                 &&&\cr 
                & {\tt \hskip 1emlet al $=$ atoms$\_$of$\_$file "mldoc.man" ;; } &&& \cr
                & {\tt \hskip 1em let st $=$ tree$\_$of$\_$atoms al ;; } &&& \cr
                & {\tt \hskip 1em html$\_$of$\_$tree ds [HTML$\_$single$\_$doc "mldoc$\_$man.html"] [];; } &&& \cr
                & {\tt \hskip 1em tex$\_$of$\_$tree ds [TEX$\_$doc$\_$name "mldoc.tex"; } &&& \cr
                & {\tt \hskip 1em \hskip 1em \hskip 1em TEX$\_$color; } &&& \cr
                & {\tt \hskip 1em \hskip 1em \hskip 1em TEX$\_$link$\_$ref; } &&& \cr
                & {\tt \hskip 1em \hskip 1em ] []; } &&& \cr
                & {\tt \hskip 1em text$\_$of$\_$tree ds [TEXT$\_$doc$\_$name "mldoc.txt"] []; } &&& \cr
                & {\tt \hskip 1em \hfil} &&& \cr 
                }
                  
                    \vskip 2\baselineskip
                    \vfill \eject
                    \vbox{\hsize \textwidth
                  \hrule
                  \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
                \label{doc$_$html}\textcolor{blue}{\sc ML-Module: {\sl doc$\_$html }} \hfill 
                \textcolor[rgb]{.0,.7,.0}{\sc Package:  mldoc}\quad \vrule}\hrule}
                  
                    \vskip \baselineskip
                    \vskip .5\baselineskip 
                    {\parindent 0pt \vbox{\sc \label{Description}Description }
                    \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
                  This is the HTML backend module used to convert {\sl MlDoC }documents in HTML-4 (transitional) 
                  format. This {\sl html$\_$of$\_$tree }function is used to convert the {\sl structure$\_$block }
                  graph to HTML output. }\end{list}}
                    \vskip .5\baselineskip
                    \vskip 2\baselineskip
                    \vbox{\hfil
                  \vbox{\hrule
                \hbox{\vrule\qquad
              \textcolor{red}{\rule[-.55em]{0pt}{1.7em}\sc Programming Interface}\quad\vrule}
                \hrule}
                  }
                    \nobreak\vskip \baselineskip\nobreak
                    {
                  \nobreak\vskip .5\baselineskip 
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
                &&&& \cr
                $[$ &  unit  & $]=$ & {\bf html$\_$of$\_$tree } & \cr
                & & & \hskip 10pt  $^\sim$ds :  structure$\_$block $\rightarrow$ & \cr
                & & & \hskip 10pt  $^\sim$options :  html$\_$options list $\rightarrow$ & \cr
                & & & \hskip 10pt  $^\sim$sections :  section$\_$names list  & \cr
                }
                  \halign{\textcolor{red}{\strut\vrule width 5pt#}&#\cr&\cr}
                  }
                    \vskip 2\baselineskip
                    The {\sl html$\_$of$\_$tree }function needs three arguments: 
                    \vskip 2\baselineskip
                    \vbox{\hfil
                  \vbox{\hrule
                \hbox{\vrule\qquad
              {\rule[-.55em]{0pt}{1.7em}\sc  Arguments }\qquad\vrule}
                \hrule}
                  }
                    \nobreak\vskip \baselineskip\nobreak
                    \begin{list}{}{}\item{\parindent 0pt 
                  \begin{description}
                \item[ ds]
              {\hfill\\}
              This is the structure block tree previously generated with the {\sl atoms$\_$of$\_$ }function 
              family. 
                \item[ options]
              {\hfill\\}
              Several options can control the converting behaviour and the output. Available options: 
              \vskip 2\baselineskip
              \begin{center}
            \begin{tabular}{|p{6.6cm}|p{6.6cm}|}\hline
          {\tt HTML$\_$single$\_$doc of string }&Only create a single HTML file instead of a 
          collection of files, each for one section. The string is the file name. \\\hline
          \end{tabular}
            \end{center}
              \vskip 2\baselineskip
              
                \item[ sections]
              {\hfill\\}
              To convert only a part of a manual, for example a module like this, some informations are 
              needed about sections above this section. 
                \end{description}
                  }\end{list}
                    \vskip .5\baselineskip
                    \vskip \baselineskip
                    \vskip .5\baselineskip 
                    {\parindent 0pt \vbox{\sc \label{Moduledependencies:}Module dependencies: }
                    \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
                  \vskip \baselineskip
                  \begin{minipage}{.9\textwidth}\vbox{
                \begin{itemize}
              \item {\sl Doc$\_$core }
              \end{itemize}
                }\end{minipage}
                  \vskip \baselineskip
                  }\end{list}}
                    \vskip .5\baselineskip
                    \vfill \eject
                    \vbox{\hsize \textwidth
                  \hrule
                  \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
                \label{doc$_$latex}\textcolor{blue}{\sc ML-Module: {\sl doc$\_$latex }} \hfill 
                \textcolor[rgb]{.0,.7,.0}{\sc Package:  mldoc}\quad \vrule}\hrule}
                  
                    \vskip \baselineskip
                    \vskip .5\baselineskip 
                    {\parindent 0pt \vbox{\sc \label{Description}Description }
                    \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
                  This is the Tex backend module used to convert {\sl MlDoC }documents in Plain-TeX/Latex format. 
                  This {\sl tex$\_$of$\_$tree }function is used to convert the {\sl structure$\_$block }graph to 
                  TeX output. }\end{list}}
                    \vskip .5\baselineskip
                    \vskip 2\baselineskip
                    \vbox{\hfil
                  \vbox{\hrule
                \hbox{\vrule\qquad
              \textcolor{red}{\rule[-.55em]{0pt}{1.7em}\sc Programming Interface}\quad\vrule}
                \hrule}
                  }
                    \nobreak\vskip \baselineskip\nobreak
                    {
                  \nobreak\vskip .5\baselineskip 
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
                &&&& \cr
                $[$ &  unit  & $]=$ & {\bf tex$\_$of$\_$tree } & \cr
                & & & \hskip 10pt  $^\sim$ds :  structure$\_$block $\rightarrow$ & \cr
                & & & \hskip 10pt  $^\sim$options :  tex$\_$options list $\rightarrow$ & \cr
                & & & \hskip 10pt  $^\sim$sections :  section$\_$names list  & \cr
                }
                  \halign{\textcolor{red}{\strut\vrule width 5pt#}&#\cr&\cr}
                  }
                    \vskip 2\baselineskip
                    The {\sl tex$\_$of$\_$tree }function needs three arguments: 
                    \vskip 2\baselineskip
                    \vbox{\hfil
                  \vbox{\hrule
                \hbox{\vrule\qquad
              {\rule[-.55em]{0pt}{1.7em}\sc  Arguments }\qquad\vrule}
                \hrule}
                  }
                    \nobreak\vskip \baselineskip\nobreak
                    \begin{list}{}{}\item{\parindent 0pt 
                  \begin{description}
                \item[ ds]
              {\hfill\\}
              This is the structure block tree previously generated with the {\sl atoms$\_$of$\_$ }function 
              family. 
                \item[ options]
              {\hfill\\}
              Several options can control the converting behaviour and the output. Available options: 
              \vskip 2\baselineskip
              \begin{center}
            \begin{tabular}{|p{6.6cm}|p{6.6cm}|}\hline
          {\tt TEX$\_$doc$\_$name of string }&The name of the output file. The default setting is 
          {\tt manual.tex }. \\\hline
          {\tt TEX$\_$head$\_$inline }&Don't perform a page break on section boundaries. \\\hline
          {\tt TEX$\_$color }&Ouput colored manual pages. Special color commands for {\sl dvips }
          are created. Default is color off. \\\hline
          {\tt TEX$\_$no$\_$toc }&Don't print a table of content. Default is print a TOC. \\\hline
          {\tt TEX$\_$link$\_$ref }&Generate links in the manual (page references). Default is no 
          links. \\\hline
          \end{tabular}
            \end{center}
              \vskip 2\baselineskip
              
                \item[ sections]
              {\hfill\\}
              To convert only a part of a manual, for example a module like this, some informations are 
              needed about sections above this section. 
                \end{description}
                  }\end{list}
                    \vskip .5\baselineskip
                    \vskip \baselineskip
                    \vskip .5\baselineskip 
                    {\parindent 0pt \vbox{\sc \label{LaTeXpackagedependencies}LaTeX package dependencies }
                    \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
                  The following packages are used by the {\sl Doc$\_$latex }module: 
                  \vskip \baselineskip
                  \begin{minipage}{.9\textwidth}\vbox{
                \begin{itemize}
              \item {\tt newcent }
              \item {\tt pifont }
              \item {\tt color[dvips] }
              \end{itemize}
                }\end{minipage}
                  \vskip \baselineskip
                  Most common LaTeX/TeX distributions are shipped with these packages. }\end{list}}
                    \vskip .5\baselineskip
                    \vskip .5\baselineskip 
                    {\parindent 0pt \vbox{\sc \label{Moduledependencies:}Module dependencies: }
                    \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
                  \vskip \baselineskip
                  \begin{minipage}{.9\textwidth}\vbox{
                \begin{itemize}
              \item {\sl Doc$\_$core }
              \end{itemize}
                }\end{minipage}
                  \vskip \baselineskip
                  }\end{list}}
                    \vskip .5\baselineskip
                    \vfill \eject
                    \vbox{\hsize \textwidth
                  \hrule
                  \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
                \label{doc$_$text}\textcolor{blue}{\sc ML-Module: {\sl doc$\_$text }} \hfill 
                \textcolor[rgb]{.0,.7,.0}{\sc Package:  mldoc}\quad \vrule}\hrule}
                  
                    \vskip \baselineskip
                    \vskip .5\baselineskip 
                    {\parindent 0pt \vbox{\sc \label{Description}Description }
                    \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
                  This is the ASCII-Text backend module used to convert {\sl MlDoC }documents in generic Text 
                  format. This {\sl text$\_$of$\_$tree }function is used to convert the {\sl structure$\_$block }
                  graph to text output. }\end{list}}
                    \vskip .5\baselineskip
                    \vskip 2\baselineskip
                    \vbox{\hfil
                  \vbox{\hrule
                \hbox{\vrule\qquad
              \textcolor{red}{\rule[-.55em]{0pt}{1.7em}\sc Programming Interface}\quad\vrule}
                \hrule}
                  }
                    \nobreak\vskip \baselineskip\nobreak
                    {
                  \nobreak\vskip .5\baselineskip 
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
                &&&& \cr
                $[$ &  unit  & $]=$ & {\bf text$\_$of$\_$tree } & \cr
                & & & \hskip 10pt  $^\sim$ds :  structure$\_$block $\rightarrow$ & \cr
                & & & \hskip 10pt  $^\sim$options :  text$\_$options list $\rightarrow$ & \cr
                & & & \hskip 10pt  $^\sim$sections :  section$\_$names list  & \cr
                }
                  \halign{\textcolor{red}{\strut\vrule width 5pt#}&#\cr&\cr}
                  }
                    \vskip 2\baselineskip
                    The {\sl text$\_$of$\_$tree }function needs three arguments: 
                    \vskip 2\baselineskip
                    \vbox{\hfil
                  \vbox{\hrule
                \hbox{\vrule\qquad
              {\rule[-.55em]{0pt}{1.7em}\sc  Arguments }\qquad\vrule}
                \hrule}
                  }
                    \nobreak\vskip \baselineskip\nobreak
                    \begin{list}{}{}\item{\parindent 0pt 
                  \begin{description}
                \item[ ds]
              {\hfill\\}
              This is the structure block tree previously generated with the {\sl atoms$\_$of$\_$ }function 
              family. 
                \item[ options]
              {\hfill\\}
              Several options can control the converting behaviour and the output. Available options: 
              \vskip 2\baselineskip
              \begin{center}
            \begin{tabular}{|p{6.6cm}|p{6.6cm}|}\hline
          {\tt TEXT$\_$doc$\_$name of string }&The output file name if any. Without this option, 
          the output is printied to the current standard out channel. \\\hline
          {\tt TEXT$\_$terminal }&Enhanced text ouput with special terminal control command 
          (underlined...). Default is no special commands. \\\hline
          {\tt TEXT$\_$notoc }&Don't print a table of content. \\\hline
          \end{tabular}
            \end{center}
              \vskip 2\baselineskip
              
                \item[ sections]
              {\hfill\\}
              To convert only a part of a manual, for example a module like this, some informations are 
              needed about sections above this section. 
                \end{description}
                  }\end{list}
                    \vskip .5\baselineskip
                    \vskip \baselineskip
                    \vskip .5\baselineskip 
                    {\parindent 0pt \vbox{\sc \label{Moduledependencies:}Module dependencies: }
                    \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
                  \vskip \baselineskip
                  \begin{minipage}{.9\textwidth}\vbox{
                \begin{itemize}
              \item {\tt Terminfo }(OCaML) 
              \item {\tt Doc$\_$core }
              \end{itemize}
                }\end{minipage}
                  \vskip \baselineskip
                  }\end{list}}
                    \vskip .5\baselineskip
                    \vfill \eject
                    \vbox{\hsize \textwidth
                  \hrule
                  \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad 
                \label{doc$_$help}\textcolor{blue}{\sc ML-Module: {\sl doc$\_$help }} \hfill 
                \textcolor[rgb]{.0,.7,.0}{\sc Package:  mldoc}\quad \vrule}\hrule}
                  
                    \vskip \baselineskip
                    \vskip .5\baselineskip 
                    {\parindent 0pt \vbox{\sc \label{Description}Description }
                    \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
                  This is the {\sl Help }frontend. It can be used to handle {\sl MlDoc }documents with various 
                  backend modules. First, a document must be loaded. Either, you use the {\sl atoms$\_$of$\_$file }
                  and the {\sl tree$\_$of$\_$atoms }functions from {\sl Doc$\_$core }module, finally loaded with 
                  {\sl help$\_$load }function, or you use the {\sl help$\_$file }function to load a document. 
                  }\end{list}}
                    \vskip .5\baselineskip
                    \vskip 2\baselineskip
                    \vbox{\hfil
                  \vbox{\hrule
                \hbox{\vrule\qquad
              \textcolor{red}{\rule[-.55em]{0pt}{1.7em}\sc Programming Interface}\quad\vrule}
                \hrule}
                  }
                    \nobreak\vskip \baselineskip\nobreak
                    {
                  \nobreak\vskip .5\baselineskip 
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil & #\hfill & \qquad # \hfill \cr
                &&&&\cr
                \textcolor{red}{type} & {\bf h$\_$sec } $=$  $\{$  & 
                &\textcolor{red}{mutable }h$\_$sec$\_$keywords: string list $;$ & \cr
                && &\textcolor{red}{mutable }h$\_$sec$\_$ds: structure$\_$block ref $;$ & \cr
                && &\textcolor{red}{mutable }h$\_$sec$\_$env: section$\_$names list $;$ & \cr
                && &\textcolor{red}{mutable }h$\_$type: string  $\}$  & \cr
                }
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil & #\hfill & \qquad # \hfill \cr
                &&&&\cr
                \textcolor{red}{type} & {\bf s$\_$help } $=$  $\{$  & 
                &\textcolor{red}{mutable }h$\_$sections: h$\_$sec list $;$ & \cr
                && &\textcolor{red}{mutable }h$\_$subsections: h$\_$sec list $;$ & \cr
                && &\textcolor{red}{mutable }h$\_$units: h$\_$sec list $;$ & \cr
                && &\textcolor{red}{mutable }h$\_$main: structure$\_$block  $\}$  & \cr
                }
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
                &&&& \cr
                $[$ & {\it help }:  s$\_$help  & $]=$ & {\bf help$\_$of$\_$doc } & \cr
                & & & \hskip 10pt  $^\sim$ds :  structure$\_$block  & \cr
                }
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
                &&&& \cr
                $[$ &  unit  & $]=$ & {\bf help$\_$load } & \cr
                & & & \hskip 10pt  $^\sim$ds :  structure$\_$block  & \cr
                }
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
                &&&& \cr
                $[$ &  unit  & $]=$ & {\bf help$\_$file } & \cr
                & & & \hskip 10pt  $^\sim$fname :  string  & \cr
                }
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # \hfil & #\hfill & \qquad # \hfill \cr
                &&&&\cr
                \textcolor{red}{type} & {\bf help$\_$Device } $=$  & 
                &Help$\_$TTY &{$\gg$\it Print to stdout $\ll$}\cr
                &&  $|$ &Help$\_$ASCII &{$\gg$\it Print to file: ASCII text $\ll$}\cr
                &&  $|$ &Help$\_$HTML &{$\gg$\it Print to file: HTML $\ll$}\cr
                &&  $|$ &Help$\_$LATEX &{$\gg$\it Print to file: Latex $\ll$}\cr
                }
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
                &&&& \cr
                $[$ &  unit  & $]=$ & {\bf help$\_$dev } & \cr
                & & & \hskip 10pt  $^\sim$dev :  help$\_$device  & \cr
                }
                  \halign{
                
                \textcolor{red}{\strut\vrule width 5pt\hskip 20pt \hfill #} & # \hfil & # & #\hfill & \qquad # \hfill \cr
                &&&& \cr
                $[$ &  unit  & $]=$ & {\bf help } & \cr
                & & & \hskip 10pt  $^\sim$name :  string  & \cr
                }
                  \halign{\textcolor{red}{\strut\vrule width 5pt#}&#\cr&\cr}
                  }
                    \vskip 2\baselineskip
                    The {\sl help$\_$dev }function can be used to change the output device. Default is the {\sl 
                    Help$\_$TTY }device. The {\sl help }function uses the keyword or name string to search the help 
                    database. The search results will be shown. 
                    \vskip 2\baselineskip
                    \vbox{\hfil
                  \vbox{\hrule
                \hbox{\vrule\qquad
              \textcolor{blue}{\rule[-.55em]{0pt}{1.7em}\sc Programming Example}\quad\vrule}
                \hrule}
                  }
                    \nobreak\vskip \baselineskip\nobreak
                    \halign to \textwidth{
                  \textcolor[rgb]{.58,.76,1.0}{\strut\vrule width 5pt#}\tabskip=0pt plus 1fil& 
                    #\hfil& #&\hfil#\hfil& 
                    \tabskip=0pt#\cr
                   &&&\cr 
                  & {\tt \hskip 1emlet at $=$ atoms$\_$of$\_$file "mldoc.man" in } &&& \cr
                  & {\tt \hskip 1em let ds $=$ tree$\_$of$\_$atoms at in } &&& \cr
                  & {\tt \hskip 1em help$\_$load ds; } &&& \cr
                  & {\tt \hskip 1em \hfil} &&& \cr 
                  }
                    
                      \vskip 2\baselineskip
                      \vskip .5\baselineskip 
                      {\parindent 0pt \vbox{\sc \label{Moduledependencies}Module dependencies }
                      \leftskip 20pt \rightskip 20pt \vskip .5\baselineskip\begin{list}{}{}\item{\parindent 0pt 
                    \vskip \baselineskip
                    \begin{minipage}{.9\textwidth}\vbox{
                  \begin{itemize}
                \item {\sl Doc$\_$core }
                \item {\sl Doc$\_$html }
                \item {\sl Doc$\_$latex }
                \item {\sl Doc$\_$text }
                \end{itemize}
                  }\end{minipage}
                    \vskip \baselineskip
                    }\end{list}}
                      \vskip .5\baselineskip
                      \vfill \eject
                      \vbox{\hsize \textwidth
                    \hrule
                    \vbox{\rule[-.55em]{0pt}{1.7em}\strut \vrule \quad \hfill
                  \textcolor{blue}{\sc Table of Content } \hfill
                  \quad \vrule}\hrule}
                    
                      \vskip \baselineskip
                      \vbox{\sc  MlDoC dot commands\quad\dotfill\quad\pageref{MlDoCdotcommands}}
                      \vskip .2\baselineskip
                      \vbox{\leftskip20pt \vbox{\sc  Section headers\quad\dotfill\quad\pageref{Sectionheaders}}
                      \vbox{\sc  Subsection headers\quad\dotfill\quad\pageref{Subsectionheaders}}
                      \vbox{\sc  Unit headers\quad\dotfill\quad\pageref{Unitheaders}}
                      \vbox{\sc  Subunits\quad\dotfill\quad\pageref{Subunits}}
                      \vbox{\sc  Special Interfaces\quad\dotfill\quad\pageref{SpecialInterfaces}}
                      \vbox{\sc  Paragraph elements\quad\dotfill\quad\pageref{Paragraphelements}}
                      \vbox{\sc  Text elements\quad\dotfill\quad\pageref{Textelements}}
                      \vbox{\sc  Summary of dot commands\quad\dotfill\quad\pageref{Summaryofdotcommands}}
                      \vskip .2\baselineskip
                      \vbox{\leftskip40pt 
                      \vbox{\sc  Text styles and special text\quad\dotfill\quad\pageref{Textstylesandspecialtext}}
                      \vbox{\sc  Special dot commands\quad\dotfill\quad\pageref{Specialdotcommands}}
                      \vbox{\sc  List commands\quad\dotfill\quad\pageref{Listcommands}}
                      \vbox{\sc  Table commands\quad\dotfill\quad\pageref{Tablecommands}}
                      \vbox{\sc  Special Interfaces commands\quad\dotfill\quad\pageref{SpecialInterfacescommands}}
                      \vbox{\sc  Section commands\quad\dotfill\quad\pageref{Sectioncommands}}
                      \vbox{\sc  Subsection commands\quad\dotfill\quad\pageref{Subsectioncommands}}
                      
                      \vbox{\sc  Units of a Subsection (Manual Page) commands\quad\dotfill\quad\pageref{UnitsofaSubsectionManualPagecommands}}
                      \vbox{\sc  Subunit commands\quad\dotfill\quad\pageref{Subunitcommands}}
                      
                      \vbox{\sc  Generic Section, Subsection, Unit, Subunit commands\quad\dotfill\quad\pageref{GenericSectionSubsectionUnitSubunitcommands}}
                      }
                      \vskip .2\baselineskip
                      
                      \vbox{\sc  Compile and use of the MlDoC package\quad\dotfill\quad\pageref{CompileanduseoftheMlDoCpackage}}
                      }
                      \vskip .2\baselineskip
                      \vbox{\sc Package:  mldoc\quad\dotfill\quad\pageref{mldoc}}
                      \vskip .2\baselineskip
                      \vbox{\leftskip20pt \vbox{\sc ML-Module:  doc$\_$core\quad\dotfill\quad\pageref{doc$_$core}}
                      \vskip .2\baselineskip
                      \vbox{\leftskip40pt \vbox{\sc  Description\quad\dotfill\quad\pageref{Description}}
                      }
                      \vskip .2\baselineskip
                      \vbox{\sc ML-Module:  doc$\_$html\quad\dotfill\quad\pageref{doc$_$html}}
                      \vskip .2\baselineskip
                      \vbox{\leftskip40pt \vbox{\sc  Description\quad\dotfill\quad\pageref{Description}}
                      \vbox{\sc  Module dependencies:\quad\dotfill\quad\pageref{Moduledependencies:}}
                      }
                      \vskip .2\baselineskip
                      \vbox{\sc ML-Module:  doc$\_$latex\quad\dotfill\quad\pageref{doc$_$latex}}
                      \vskip .2\baselineskip
                      \vbox{\leftskip40pt \vbox{\sc  Description\quad\dotfill\quad\pageref{Description}}
                      \vbox{\sc  LaTeX package dependencies\quad\dotfill\quad\pageref{LaTeXpackagedependencies}}
                      \vbox{\sc  Module dependencies:\quad\dotfill\quad\pageref{Moduledependencies:}}
                      }
                      \vskip .2\baselineskip
                      \vbox{\sc ML-Module:  doc$\_$text\quad\dotfill\quad\pageref{doc$_$text}}
                      \vskip .2\baselineskip
                      \vbox{\leftskip40pt \vbox{\sc  Description\quad\dotfill\quad\pageref{Description}}
                      \vbox{\sc  Module dependencies:\quad\dotfill\quad\pageref{Moduledependencies:}}
                      }
                      \vskip .2\baselineskip
                      \vbox{\sc ML-Module:  doc$\_$help\quad\dotfill\quad\pageref{doc$_$help}}
                      \vskip .2\baselineskip
                      \vbox{\leftskip40pt \vbox{\sc  Description\quad\dotfill\quad\pageref{Description}}
                      \vbox{\sc  Module dependencies\quad\dotfill\quad\pageref{Moduledependencies}}
                      }
                      \vskip .2\baselineskip
                      }
                      \vskip .2\baselineskip
                      
                        \end{document}
                        