
The macro package supports four document types: article, report, book and the 
manual page. Note that document types have nothing in common with output 
formats; a book can be converted to each of the output formats, and a manual 
page can be converted to a tt(.dvi) file. Nevertheless, some formats are more 
useful for some document types. A book that is converted to the tt(man) output 
format to be later processed with tt(groff) won't look too good; a better
conversion to ASCII would be via the tt(ms) output format.

Each document must be started by specifying the document type. 
The  relevant macros are:

itemize(

    it() tt(article(title)(author)(date)): The tt(article) document type is
    meant for short documents. The macro arguments specify the title of the
    document, the author and the date. 
    
    In articles, the title page is numbered and the table of contents is on
    the title page. The sectioning commands tt(sect), tt(subsect) etc.
    are available.
    
    it() tt(report(title)(author)(date)): The tt(report) document type differs
    from an tt(article) in that it has a separate unnumbered title page, a
    table of contents on its own page, and the sectioning command
    tt(chapter). A tt(report) is meant for larger documents.
    
    it() tt(book(title)(author)(date)): The tt(book) type is for still larger
    documents. It supports the sectioning command tt(part).
    
    it() tt(manpage(title)(section)(date)(source)(manual)): The tt(manpage) 
    document type is specifically meant to write manual pages, as found on 
    Unix systems. It uses its own sectioning commands to reflect the necessary 
    sections in a manual page. This document format is described separately 
    in ref(manpage).
    
    it() tt(plainhtml(title)): This document type is typically used in HTML 
    output. It's implemented for situations where you only need to create a 
    HTML file, but want to use the Yodl package to help you with handy macros.
    Except for the fact that no tt(author) and tt(date) arguments are
    necessary, this document type is similar to tt(article). (In fact, you can 
    emulate tt(plainhtml) by using an tt(article), but without author and date 
    information for the title.)
    
    tt(plainhtml) bf(is) available for other output formats, though it doesn't 
    really make sense to use it. If you want the most `portable' document 
    type, use one of tt(article), tt(report) or tt(book).
    
)

The function of these macros is, globally, threefold. First, the macros must 
send any commands that need to appear before `real' text to the output file. 
E.g., the LaTeX output needs the right tt(\documentstyle) preamble, HTML 
output needs tt(<html>) and tt(<body>) tags. 

Second, the macros define appropriate document-dependent settings. E.g., this 
means that the LaTeX converter defines the title, author and date using 
tt(\title) etc..

Third, the actual document is started. In LaTeX this means a
tt(\begin{)em(type)tt(}), followed by the appropriate commands to generate
a the document title and the table of contents.  The tt(title) setting in the
above macros defines the document title which always appears on the front page
of the document. For HTML output, this is also the title of the HTML file (or
files), as appearing in the HTML tt(<title>) tag. 

The fact that the macros which define the document type perform many
functions, means that once the macro is started, nothing `extra' can be put
say between the generated title and the table of contents. Sometimes however
this is what you'd like; as is the case with an abstract. The Yodl package
therefore implements em(modifiers), that appear bf(before) the document type
macros.
