effects: Returns unaltered boxes (i.e. no resizing takes place)

RETURN[boxes];

};

effects: Sizes boxes for expr of form ($paren $a)

leftParenBox: BOX ← MathBox.GetBox[$leftParen, boxes];

rightParenBox: BOX ← MathBox.GetBox[$rightParen, boxes];

aBox: BOX ← MathBox.GetBox[$a, boxes];

right and left parentheses must be as tall as expression "a"

scaleFactor: REAL ← MAX[0.25, 1.1 * aBox.Height[] / leftParenBox.Height[]];

leftParenBox ← MathBox.Scale[leftParenBox, [scaleFactor, scaleFactor]];

rightParenBox ← MathBox.Scale[rightParenBox, [scaleFactor, scaleFactor]];

RETURN[LIST[aBox, leftParenBox, rightParenBox]];

};

effects: Sizes boxes for expr of form ($curly $a)

leftCurlyBox: BOX ← MathBox.GetBox[$leftCurly, boxes];

rightCurlyBox: BOX ← MathBox.GetBox[$rightCurly, boxes];

aBox: BOX ← MathBox.GetBox[$a, boxes];

right and left curly brackets must be as tall as expression "a"

scaleFactor: REAL ← MAX[0.25, 1.1 * aBox.Height[] / leftCurlyBox.Height[]];

leftCurlyBox ← MathBox.Scale[leftCurlyBox, [scaleFactor, scaleFactor]];

rightCurlyBox ← MathBox.Scale[rightCurlyBox, [scaleFactor, scaleFactor]];

RETURN[LIST[aBox, leftCurlyBox, rightCurlyBox]];

};

effects: Sizes boxes for expr of form ($square $a)

leftSquareBox: BOX ← MathBox.GetBox[$leftSquare, boxes];

rightSquareBox: BOX ← MathBox.GetBox[$rightSquare, boxes];

aBox: BOX ← MathBox.GetBox[$a, boxes];

right and left square brackets must be as tall as expression "a"

scaleFactor: REAL ← MAX[0.25, 1.1 * aBox.Height[] / leftSquareBox.Height[]];

leftSquareBox ← MathBox.Scale[leftSquareBox, [scaleFactor, scaleFactor]];

rightSquareBox ← MathBox.Scale[rightSquareBox, [scaleFactor, scaleFactor]];

RETURN[LIST[aBox, leftSquareBox, rightSquareBox]];

};

effects: Sizes boxes for expr of form ($quote $a)

leftSquareBox: BOX ← MathBox.GetBox[$leftQuote, boxes];

rightSquareBox: BOX ← MathBox.GetBox[$rightQuote, boxes];

aBox: BOX ← MathBox.GetBox[$a, boxes];

right and left square brackets must be as tall as expression "a"

scaleFactor: REAL ← MAX[0.25, 1.1 * aBox.Height[] / leftSquareBox.Height[]];

leftSquareBox ← MathBox.Scale[leftSquareBox, [scaleFactor, scaleFactor]];

rightSquareBox ← MathBox.Scale[rightSquareBox, [scaleFactor, scaleFactor]];

RETURN[LIST[aBox, leftSquareBox, rightSquareBox]];

};

effects: Sizes boxes for expr of form ($f $funSpace $leftParen $arg1 $rightParen)

should ENABLE noSuchBox

fBox: BOX ← MathBox.GetBox[$f, boxes];

funSpaceBox: BOX ← MathBox.GetBox[$funSpace, boxes];

lParenBox: BOX ← MathBox.GetBox[$leftParen, boxes];

arg1Box: BOX ← MathBox.GetBox[$arg1, boxes];

rParenBox: BOX ← MathBox.GetBox[$rightParen, boxes];

parens must be as tall as arg

scaleFactor: REAL ← MAX[minParenSize, parensToArgs * arg1Box.Height[] / lParenBox.Height[]];

lParenBox ← MathBox.Scale[lParenBox, [scaleFactor, scaleFactor]];

rParenBox ← MathBox.Scale[rParenBox, [scaleFactor, scaleFactor]];

RETURN[LIST[fBox, funSpaceBox, lParenBox, arg1Box, rParenBox] ];

};

effects: Sizes boxes for expr of form ($f $funSpace $leftParen $arg1 $comma12 $arg12Space $arg2 $rightParen)

should ENABLE noSuchBox

fBox: BOX ← MathBox.GetBox[$f, boxes];

funSpaceBox: BOX ← MathBox.GetBox[$funSpace, boxes];

lParenBox: BOX ← MathBox.GetBox[$leftParen, boxes];

arg1Box: BOX ← MathBox.GetBox[$arg1, boxes];

comma12Box: BOX ← MathBox.GetBox[$comma12, boxes];

arg12SpaceBox: BOX ← MathBox.GetBox[$arg12Space, boxes];

arg2Box: BOX ← MathBox.GetBox[$arg2, boxes];

rParenBox: BOX ← MathBox.GetBox[$rightParen, boxes];

right and left parentheses must be as tall as max of arg heights; comma should also scale

scaleFactor: REAL ← MAX[

lParenBox ← MathBox.Scale[lParenBox, [scaleFactor, scaleFactor]];

comma12Box ← MathBox.Scale[comma12Box, [scaleFactor, scaleFactor]];

rParenBox ← MathBox.Scale[rParenBox, [scaleFactor, scaleFactor]];

RETURN[LIST[fBox, funSpaceBox, lParenBox, arg1Box, comma12Box, arg12SpaceBox, arg2Box, rParenBox] ];

};

effects: Sizes boxes for expr of form ($f $funSpace $leftParen $arg1 $arg2 $arg3 $rightParen)

should ENABLE noSuchBox

fBox: BOX ← MathBox.GetBox[$f, boxes];

funSpaceBox: BOX ← MathBox.GetBox[$funSpace, boxes];

lParenBox: BOX ← MathBox.GetBox[$leftParen, boxes];

arg1Box: BOX ← MathBox.GetBox[$arg1, boxes];

comma12Box: BOX ← MathBox.GetBox[$comma12, boxes];

arg12SpaceBox: BOX ← MathBox.GetBox[$arg12Space, boxes];

arg2Box: BOX ← MathBox.GetBox[$arg2, boxes];

comma23Box: BOX ← MathBox.GetBox[$comma23, boxes];

arg23SpaceBox: BOX ← MathBox.GetBox[$arg23Space, boxes];

arg3Box: BOX ← MathBox.GetBox[$arg3, boxes];

rParenBox: BOX ← MathBox.GetBox[$rightParen, boxes];

right and left parentheses must be as tall as max of arg expressions

scaleFactor: REAL ← MAX[

lParenBox ← MathBox.Scale[lParenBox, [scaleFactor, scaleFactor]];

comma12Box ← MathBox.Scale[comma12Box, [scaleFactor, scaleFactor]];

comma23Box ← MathBox.Scale[comma23Box, [scaleFactor, scaleFactor]];

rParenBox ← MathBox.Scale[rParenBox, [scaleFactor, scaleFactor]];

RETURN[LIST[fBox, funSpaceBox, lParenBox, arg1Box, comma12Box, arg12SpaceBox, arg2Box, comma23Box, arg23SpaceBox, arg3Box, rParenBox] ];

};

effects: Sizes boxes for expr of form ($f $funSpace $leftParen $arg1 $arg2 $arg3 $$arg4 rightParen)

should ENABLE noSuchBox

fBox: BOX ← MathBox.GetBox[$f, boxes];

funSpaceBox: BOX ← MathBox.GetBox[$funSpace, boxes];

lParenBox: BOX ← MathBox.GetBox[$leftParen, boxes];

arg1Box: BOX ← MathBox.GetBox[$arg1, boxes];

comma12Box: BOX ← MathBox.GetBox[$comma12, boxes];

arg12SpaceBox: BOX ← MathBox.GetBox[$arg12Space, boxes];

arg2Box: BOX ← MathBox.GetBox[$arg2, boxes];

comma23Box: BOX ← MathBox.GetBox[$comma23, boxes];

arg23SpaceBox: BOX ← MathBox.GetBox[$arg23Space, boxes];

arg3Box: BOX ← MathBox.GetBox[$arg3, boxes];

comma34Box: BOX ← MathBox.GetBox[$comma34, boxes];

arg34SpaceBox: BOX ← MathBox.GetBox[$arg34Space, boxes];

arg4Box: BOX ← MathBox.GetBox[$arg4, boxes];

rParenBox: BOX ← MathBox.GetBox[$rightParen, boxes];

right and left parentheses must be as tall as max of arg expressions

scaleFactor: REAL ← MAX[

lParenBox ← MathBox.Scale[lParenBox, [scaleFactor, scaleFactor]];

comma12Box ← MathBox.Scale[comma12Box, [scaleFactor, scaleFactor]];

comma23Box ← MathBox.Scale[comma23Box, [scaleFactor, scaleFactor]];

comma34Box ← MathBox.Scale[comma34Box, [scaleFactor, scaleFactor]];

rParenBox ← MathBox.Scale[rParenBox, [scaleFactor, scaleFactor]];

RETURN[LIST[fBox, funSpaceBox, lParenBox, arg1Box, comma12Box, arg12SpaceBox, arg2Box, comma23Box, arg23SpaceBox, arg3Box, comma34Box, arg34SpaceBox, arg4Box, rParenBox] ];

};

effects: Composes layout for expr of form ($comma $car $cdr) with symbol $space.

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$car, [origin]], [$comma, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($f $funSpace $leftParen $rightParen)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$f, [origin]], [$f, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($f $funSpace $arg1 $leftParen $rightParen)

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$f, [origin]], [$f, [origin]]];

RETURN[tempBox, tempBoxes];

};

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$f, [origin]], [$f, [origin]]];

RETURN[tempBox, tempBoxes];

};

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$f, [origin]], [$f, [origin]]];

RETURN[tempBox, tempBoxes];

};

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$f, [origin]], [$f, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($aliasUnaryOp $aliasA).

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$aliasUnaryOp, [origin]],
[$aliasUnaryOp, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($aliasBinOp $aliasA $aliasB) with

symbols $aliasLeftSpace & $aliasRightSpace.

tempBox: BOX;

tempBoxes: LIST OF BOX;

leftVertOffsetA, leftVertOffsetOp, rightVertOffsetB, rightVertOffsetOp: Offset;

alignments: LIST OF Alignment2D;

set vertical offset depending on format classes of A & B arguments

SELECT MathBox.GetBox[$aliasA, boxes].FormatClass[] FROM

SELECT MathBox.GetBox[$aliasB, boxes].FormatClass[] FROM

alignments ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$aliasA, [origin]], [$aliasBinOp, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($aliasRelation $aliasLHS $aliasRHS) with

symbols $aliasLeftSpace & $aliasRightSpace.

tempBox: BOX;

tempBoxes: LIST OF BOX;

leftVertOffsetLHS, leftVertOffsetRel, rightVertOffsetRHS, rightVertOffsetRel: Offset;

alignments: LIST OF Alignment2D;

set vertical offset depending on format classes of lhs & rhs arguments

SELECT MathBox.GetBox[$aliasLHS, boxes].FormatClass[] FROM

SELECT MathBox.GetBox[$aliasRHS, boxes].FormatClass[] FROM

alignments ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$aliasLHS, [origin]],
[$aliasRelation, [origin]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($paren $a) with symbols

$leftParen and $rightParen

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$leftParen, [origin]],
[$self, [center, -0.25]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($curly $a) with symbols

$leftCurly and $rightCurly

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$leftCurly, [origin]],
[$self, [center, -0.25]]];

RETURN[tempBox, tempBoxes];

};

effects: Composes layout for expr of form ($square $a) with symbols

$leftSquare and $rightSquare

tempBox: BOX;

tempBoxes: LIST OF BOX;

alignments: LIST OF Alignment2D ← LIST[

[tempBox, tempBoxes] ←
MathRules.Compose[boxes, alignments, [$leftSquare, [origin]],
[$self, [center, -0.25]]];

RETURN[tempBox, tempBoxes];

};

effects: Creates and returns standard unary operation compound class named "class".

The alignment is "operation arg"; alignment is thru baselines.

Both op, arg are of fixed size "normal".

argArg: Argument ← MakeArgument[arg, LIST[$aliasA, $aliasHot], normal];

spaceSym: Symbol ← MakeSymbol[$Space, LIST[$aliasSpace], normal, MathConstructors.MakeSpace[$medium]];

unaryOpSym: Symbol ← MakeSymbol[op, LIST[$aliasUnaryOp], normal, operation];

RETURN[MakeCompoundClass[class, unaryOp, description, LIST[argArg], LIST[unaryOpSym, spaceSym], FixedSizeBoxRule, UnaryOpCompRule, cvtAS]];

};

effects: Creates and returns standard relation compound class named "class".

The alignment is "lhs relation rhs"; alignment is thru baselines.

All of lhs, rhs, rel are of fixed size "normal".

lhsArg: Argument ← MakeArgument[lhs, LIST[$aliasLHS, $aliasHot], normal];

rhsArg: Argument ← MakeArgument[rhs, LIST[$aliasRHS], normal];

relSym: Symbol ← MakeSymbol[rel, LIST[$aliasRelation], normal, relation];

leftSpace: Symbol ← MakeSymbol[$leftSpace, LIST[$aliasLeftSpace], normal, MathConstructors.MakeSpace[$thick]];

rightSpace: Symbol ← MakeSymbol[$rightSpace, LIST[$aliasRightSpace], normal, MathConstructors.MakeSpace[$thick]];

RETURN[MakeCompoundClass[class, relation, description, LIST[lhsArg, rhsArg], LIST[relSym, leftSpace, rightSpace], FixedSizeBoxRule, RelationCompRule, cvtAS]];

};

local declarations

parenClass, curlyClass, squareClass, listClass, unaryFunctionClass, binaryFunctionClass, ternaryFunctionClass, quaternaryFunctionClass, altFunctionClass, nullaryFunctionClass, quoteClass: CompoundClass;

aParenArg, aCurlyArg, aSquareArg, carArg, cdrArg, fArg, arg1, arg2, arg3, arg4: Argument;

leftParenSym, rightParenSym, leftCurlySym, rightCurlySym, leftSquareSym, rightSquareSym, commaSym, listSpSym, funSpaceSym, funLParenSym, funRParenSym, altFunLP, altFunRP, arg12SpaceSym, arg23SpaceSym, arg34SpaceSym, comma12Sym, comma23Sym, comma34Sym, leftQuoteSym, rightQuoteSym: Symbol;

define info for "( a )"

aParenArg ← MakeArgument[$a, LIST[$aliasA, $aliasHot], normal];

leftParenSym ← MakeSymbol[$leftParen, NIL, normal, MathConstructors.MakePlainSym['(]];

rightParenSym ← MakeSymbol[$rightParen, NIL, normal, MathConstructors.MakePlainSym[')]];

define info for "{ a }"

aCurlyArg ← MakeArgument[$a, LIST[$aliasA, $aliasHot], normal];

leftCurlySym ← MakeSymbol[$leftCurly, NIL, normal, MathConstructors.MakePlainSym['{]];

rightCurlySym ← MakeSymbol[$rightCurly, NIL, normal, MathConstructors.MakePlainSym['}]];

define info for "[ a ]"

aSquareArg ← MakeArgument[$a, LIST[$aliasA, $aliasHot], normal];

leftSquareSym ← MakeSymbol[$leftSquare, NIL, normal, MathConstructors.MakePlainSym['[]];

rightSquareSym ← MakeSymbol[$rightSquare, NIL, normal, MathConstructors.MakePlainSym[']]];

define info for quote(a)

leftQuoteSym ← MakeSymbol[$leftSquare, NIL, normal, MathConstructors.MakePlainSym['']];

rightQuoteSym ← MakeSymbol[$rightSquare, NIL, normal, MathConstructors.MakePlainSym['']];

define info for "$list $car $cdr"

carArg ← MakeArgument[$car, LIST[$aliasA, $aliasHot], normal];

cdrArg ← MakeArgument[$cdr, LIST[$aliasB], normal];

commaSym ← MakeSymbol[$comma, NIL, normal, MathConstructors.MakeItalSym[',]];

listSpSym ← MakeSymbol[$space, LIST[$aliasSpace], normal, MathConstructors.MakeSpace[$thick]];

define info for functions (parens also used by complex)

fArg ← MakeArgument[$f, LIST[$aliasA], normal];

arg1 ← MakeArgument[$arg1, LIST[$aliasB, $aliasHot], normal];

arg2 ← MakeArgument[$arg2, NIL, normal];

arg3 ← MakeArgument[$arg3, NIL, normal];

arg4 ← MakeArgument[$arg4, NIL, normal];

funLParenSym ← MakeSymbol[$leftParen, NIL, normal, MathConstructors.MakePlainSym['\050]];

funRParenSym ← MakeSymbol[$rightParen, NIL, normal, MathConstructors.MakePlainSym['\051]];

funLParenSym ← MakeSymbol[$leftParen, NIL, normal, MathConstructors.MakePlainSym['[]];

funRParenSym ← MakeSymbol[$rightParen, NIL, normal, MathConstructors.MakePlainSym[']]];

altFunLP ← MakeSymbol[$leftParen, NIL, normal, MathConstructors.MakeSpace[$null]];

altFunRP ← MakeSymbol[$rightParen, NIL, normal, MathConstructors.MakeSpace[$null]];

funSpaceSym ← MakeSymbol[$funSpace, LIST[$aliasSpace], normal, MathConstructors.MakeSpace[$medium]];

arg12SpaceSym ← MakeSymbol[$arg12Space, NIL, normal, MathConstructors.MakeSpace[$medium]];

arg23SpaceSym ← MakeSymbol[$arg23Space, NIL, normal, MathConstructors.MakeSpace[$medium]];

arg34SpaceSym ← MakeSymbol[$arg34Space, NIL, normal, MathConstructors.MakeSpace[$medium]];

comma12Sym ← MakeSymbol[$comma12, NIL, normal, MathConstructors.MakeItalSym[',]];

comma23Sym ← MakeSymbol[$comma23, NIL, normal, MathConstructors.MakeItalSym[',]];

comma34Sym ← MakeSymbol[$comma34, NIL, normal, MathConstructors.MakeItalSym[',]];

define compound classes

others

listClass ← MakeCompoundClass[$list, other, "a, b", LIST[carArg, cdrArg], LIST[commaSym, listSpSym], FixedSizeBoxRule, ListCompRule, "($car, $cdr)", "{$car, $cdr}"]; -- these are binary, not n-ary, lists

nullaryFunctionClass ← MakeCompoundClass[$nullaryFunction, other, "function()", LIST[fArg], LIST[funLParenSym, funRParenSym, funSpaceSym], FixedSizeBoxRule, NullaryFunctionCompRule, "$f []", "$f ()", "$f []"];

unaryFunctionClass ← MakeCompoundClass[$unaryFunction, other, "function(arg)", LIST[fArg, arg1], LIST[funSpaceSym, funLParenSym, funRParenSym], UnaryFunctionBoxRule, UnaryFunctionCompRule, "$f [$arg1]", "$f ($arg1)", "$f [$arg1]"];

binaryFunctionClass ← MakeCompoundClass[$binaryFunction, other, "function(arg1, arg2)", LIST[fArg, arg1, arg2], LIST[funSpaceSym, funLParenSym, comma12Sym, arg12SpaceSym, funRParenSym], BinaryFunctionBoxRule, BinaryFunctionCompRule, "$f [$arg1, $arg2]", "$f ($arg1, $arg2)", "$f [$arg1, $arg2]"];

ternaryFunctionClass ← MakeCompoundClass[$ternaryFunction, other, "function(arg1, arg2, arg3)", LIST[fArg, arg1, arg2, arg3], LIST[funSpaceSym, funLParenSym, comma12Sym, arg12SpaceSym, comma23Sym, arg23SpaceSym, funRParenSym], TernaryFunctionBoxRule, TernaryFunctionCompRule, "$f [$arg1, $arg2, $arg3]", "$f ($arg1, $arg2, $arg3)", "$f [$arg1, $arg2, $arg3]"];

quaternaryFunctionClass ← MakeCompoundClass[$quaternaryFunction, other, "function(arg1, arg2, arg3, arg4)", LIST[fArg, arg1, arg2, arg3, arg4], LIST[funSpaceSym, funLParenSym, comma12Sym, arg12SpaceSym, comma23Sym, arg23SpaceSym, comma34Sym, arg34SpaceSym, funRParenSym], QuaternaryFunctionBoxRule, QuaternaryFunctionCompRule, "$f [$arg1, $arg2, $arg3, $arg4]", "$f ($arg1, $arg2, $arg3, $arg4)", "$f [$arg1, $arg2, $arg3, $arg4]"];

altFunctionClass ← MakeCompoundClass[$altFunction, other, "function arg", LIST[fArg, arg1], LIST[altFunLP, altFunRP, funSpaceSym], FixedSizeBoxRule, UnaryFunctionCompRule, "(function $f $arg1)"];

parenClass ← MakeCompoundClass[$paren, paren, "( a )", LIST[aParenArg], LIST[leftParenSym, rightParenSym], ParenBoxRule, ParenCompRule, "( $a )", "( $a )", "( $a )"];

curlyClass ← MakeCompoundClass[$curly, paren, "{ a }", LIST[aCurlyArg], LIST[leftCurlySym, rightCurlySym], CurlyBoxRule, CurlyCompRule, "{ $a }"];

squareClass ← MakeCompoundClass[$square, paren, "[ a ]", LIST[aSquareArg], LIST[leftSquareSym, rightSquareSym], SquareBoxRule, SquareCompRule, "[ $a ]"];

quoteClass ← MakeCompoundClass[$quote, paren, "' a", LIST[aSquareArg], LIST[leftQuoteSym, rightQuoteSym], SquareBoxRule, SquareCompRule, "quote($a)"];

Register compound classes in user-friendly order

MathDB.InstallCompoundClass[parenClass];

MathDB.AddOperator[parenClass, $List];

MathDB.InstallCompoundClass[curlyClass];

MathDB.AddOperator[curlyClass, $List];

MathDB.InstallCompoundClass[squareClass];

MathDB.AddOperator[squareClass, $List];

*** 7/16/87 disable lists so Reduce list function treated as unknown func

MathDB.InstallCompoundClass[listClass];

MathDB.AddOperator[listClass, $List];

***

MathDB.InstallCompoundClass[quoteClass];

MathDB.AddOperator[quoteClass, $List];

MathDB.InstallCompoundClass[altFunctionClass];

MathDB.AddOperator[altFunctionClass, $List];

MathDB.InstallCompoundClass[nullaryFunctionClass];

MathDB.AddOperator[nullaryFunctionClass, $List];

MathDB.InstallCompoundClass[unaryFunctionClass];

MathDB.AddOperator[unaryFunctionClass, $List];

MathDB.InstallCompoundClass[binaryFunctionClass];

MathDB.AddOperator[binaryFunctionClass, $List];

MathDB.InstallCompoundClass[ternaryFunctionClass];

MathDB.AddOperator[ternaryFunctionClass, $List];

MathDB.InstallCompoundClass[quaternaryFunctionClass];

MathDB.AddOperator[quaternaryFunctionClass, $List];

};

local declarations

assignmentClass: CompoundClass;

assignmentClass, quoteClass: CompoundClass;

relations

quoteClass ← MakeUnaryOpClass[$quote, $quote, $a, MathConstructors.MakePlainSym[''], "quote a", "quote($a)"];

assignmentClass ← MakeRelationClass[$assign, $assign, $lhs, $rhs, MathConstructors.MakePlainSym['\254], "a ← b", "$lhs ← $rhs", "$lhs := $rhs", "$lhs : $rhs"];

MathDB.InstallCompoundClass[assignmentClass];

MathDB.AddOperator[assignmentClass, $List];

MathDB.InstallCompoundClass[quoteClass];

MathDB.AddOperator[quoteClass, $List];

};