@Section
   @Title { Definitions }
   @Tag { definitions }
@Begin
@PP
The features of Lout are very general.  They do not assume that documents
are composed of pages, nor that there are such things as margins and
footnotes, for example.  @I Definitions
definitions. @Index { Definitions }
bridge the gap between Lout's general features and the
special features -- footnotes, equations, pages -- that particular
documents require.  They hold the instr&-uct&-ions for producing these
special features, conveniently packaged ready for use.
@PP
For example, consider the challenge posed by `@TeX', which is the name of
one of Lout's most illustrious rivals @Cite { $knuth1984tex }.  Lout solves it
easily enough, like this:
@ID @Code {
"T{ /0.2fo E }X"
}
but to type this every time @TeX is mentioned would be tedious and
error-prone.  So we place a definition at the beginning of the document:
@ID @Code {
"def  @TeX  {  T{ /0.2fo E }X  }"
}
Now @Code "@TeX" stands for the object following it between
braces, and we may write
@ID @Code {
consider the challenge posed by "`@TeX'", ...
}
as the author did earlier in this paragraph.
@PP
A @I symbol
symbol. @Index Symbol
is a name, like {@Code "@TeX"}, which stands for
something other than itself.  The initial @Code "@" is not compulsory,
but it does make the name stand out clearly.  A @I definition of a symbol
declares a name to be a symbol, and says what the symbol stands for.  The
@I body of a definition
body.of @Index { Body of a definition }
is the part following the name, between the braces.  To @I invoke
invocation @Index { Invocation of a symbol }
a symbol is to make use of it.
@PP
Another expression ripe for packaging in a definition is
@ID @Code {
"@OneRow {  |  -2p @Font n  ^/0.5fk  2  }"
}
which produces @OneRow { | -2p @Font n ^/0.5sk 2 } (see
Chapter {@NumberOf details}).  But this time we would like to be able to write
@ID {
@I object  @Code "@Super"  @I object
}
so that @Code { a "@Super" 2 } would come out as {a @Super 2}, and so
on, for in this way the usefulness of the definition is greatly
increased.  Here is how it is done:
@ID @OneRow @Code {
"def @Super"
"   left x"
"   right y"
"{ @OneRow {  |  -2p @Font y  ^/0.5fk  x  }"
"}"
}
This definition says that @Code "@Super" has two {@I parameters},
parameter @Index Parameter
@Code x and {@Code y}.  When @Code "@Super" is invoked, all occurrences
of @Code x in the body will be replaced by the object just to the left
of {@Code "@Super"}, and all occurrences of @Code y will be replaced by
the object just to the right.  So, for example, the expression
@ID @Code {
"2  @Super  { Slope @Font n }"
}
is equal to
@ID @Code {
"@OneRow {  |  -2p @Font { Slope @Font n }  ^/0.5fk  2  }"
}
and so comes out as {2 @Super {Slope @Font n}}.
@PP
Lout permits definitions to invoke themselves, a peculiarly circular
thing to do which goes by the name of
recursion @Index Recursion
@I recursion.  Here is an example
of a recursive definition:
@ID @Code {
"def  @Leaders  {  ..   @Leaders  }"
}
The usual rule is that the value of an invocation of a symbol is a copy of
the body of the symbol's definition, so the value of @Code "@Leaders" must be
@ID @Code {
"..   @Leaders"
}
But now this rule applies to this new invocation of {@Code "@Leaders"};
substituting its body gives
@ID @Code {
"..   ..   @Leaders"
}
and so on forever.  In order to make this useful,
an invocation of a recursive symbol is replaced by its body only if
sufficient space is available.  So, for example,
@ID @Code {
"4i @Wide { Chapter 7  @Leaders   62 }"
}
has for its result the object
@ID {
4i @Wide { Chapter 7  @Leaders   62 }
}
with Lout checking before each replacement of @Code "@Leaders" by
@OneCol @Code { ".."   "@Leaders" } that the total length afterwards,
including the other words, would not exceed four inches.
@PP
The remaining issue is what happens when Lout decides that it is time to
stop.  The obvious thing to do is to replace the last invocation by an
empty object:
@ID @Code {
"..    ..    ..    ..    ..    ..    ..    ..    {}"
}
As the example shows, this would leave a small trailing space, which
is a major headache.  Lout fixes this
by replacing the last invocation with a different kind of empty object,
called @@Null, whose effect is to make an adjacent concatenation symbol
disappear, preferably one preceding the @@Null.  Thus, when Lout
replaces @Code "@Leaders" by @@Null in the expression
@ID @Code {
"..    ..    ..    ..    ..    ..    ..    ..    @Leaders"
}
the trailing space, which is really a horizontal concatenation symbol,
disappears as well.  This is taken into account when deciding
whether there is room to replace @Code "@Leaders" by its body.
@PP
The remainder of this section is devoted to showing how definitions may
be used to specify the @I {page layout}
page.layout @RawIndex { Page layout }
page.layout.basic @SubIndex { principles of }
of a document.  To begin with,
we can define a page like this:
@ID @OneRow @Code {
"def @Page"
"{"
"    //1i  ||1i"
"    6i @Wide 9.5i @High"
"    { @TextPlace  //1rt  @FootSect }"
"    ||1i  //1i"
"}"
}
Now @Code "@Page" is an eight by
eleven and a half inch object, with one inch margins, a place at the top for
text, and a section at the bottom for footnotes (since @Code "//1rt"
bottom-justifies the following object).  It will be
convenient for us to show the effect of invoking @Code "@Page" like this:
@ID @Code
{ { //0.5ix 8p @Font "@Page" &2m => } &2m
@LittlePage { "@TextPlace" //1rt "@FootSect" }
}
with the invoked symbol appearing to the left of the arrow, and its body to
the right.
@PP
The definition of a vertical list of pages should come as no surprise:
@ID @OneRow @Code {
"def @PageList"
"{"
"    @Page  //  @PageList"
"}"
}
This allows invocations like the following:
@ID @Code @HExpand @HScale {
{ //0.5ix 8p @Font "@PageList" }
||1m { //0.5ix => } ||1m
{        @LittlePage { "@TextPlace" //1rt "@FootSect" }
  //0.2c 8p @Font "@PageList"
}
||1m { //0.5ix => } ||1m
{        @LittlePage { "@TextPlace" //1rt "@FootSect" }
  //     @LittlePage { "@TextPlace" //1rt "@FootSect" }
  //0.2c 8p @Font "@PageList"
}
||1m { //0.5ix => } ||1m
{        @LittlePage { "@TextPlace" //1rt "@FootSect" }
  //     @LittlePage { "@TextPlace" //1rt "@FootSect" }
}
}
setting  @Code "@PageList" to @Code @@Null on the last step.  Any
number of pages can be generated.
@PP
A definition for @Code "@TextPlace" is beyond us at present, since
@Code "@TextPlace" must be replaced by different parts of the text
of the document on different pages.  But we can
define @Code "@FootSect" to be a small space followed by a
horizontal line followed by a list of places where footnotes go:
@ID @OneRow @Code {
"def @FootList         "
"{                     "
"   @FootPlace  //0.3v  @FootList"
"}                     "
"                      "
"def @FootSect"
"{                        "
"   //0.3v 1i @Wide @HLine"
"   //0.3v @FootList      "
"}                        "
}
assuming that @Code "@HLine" will produce a horizontal line of the
indicated width.  With this definition we can generate pages like this:
@ID @Code {
@LittlePage { "@TextPlace"
               //1rt
               "@FootSect"
             }
||2m { //0.5ix => } ||2m
@LittlePage { "@TextPlace"
               //1rt
               @OneRow { 1c @Wide @HLine
                         //0.1c
                         "@FootList"
                       }
             }
||2m { //0.5ix => } ||2m
@LittlePage { "@TextPlace"
               //1rt
               @OneRow { 1c @Wide @HLine
                         //0.1c
                         "@FootPlace"
                         //0.1c
                         "@FootList"
                       }
             }
}
and so on for arbitrarily many footnotes.
@PP
We will see in the next section how invocations of @Code "@PageList",
@Code "@FootSect" and @Code "@FootList" are replaced by their bodies only
when the need to insert text and footnotes obliges Lout to do so;
otherwise the invocations are replaced by @@Null.  In this way, the
right number of pages is made, the small line appears only on pages that
have at least one footnote, and unnecessary concatenation symbols
disappear.
@PP
This approach to page layout is the most original contribution Lout has
made to document formatting.  It is extraordinarily flexible.  Two-column
pages?  Use
@ID @Code {
"{2.8i @Wide @TextPlace}  ||0.4i  {2.8i @Wide @TextPlace}"
}
instead of {@Code "@TextPlace"}.  Footnotes in smaller type?  Use
@Code { -2p "@Font" "@FootPlace" } instead of {@Code "@FootPlace"}.  And
on and on.
@End @Section