DIRECTORY
Rope,
IO,
MathExpr,
MathConstructors,
AlgebraClasses,
Structures,
Ints,
Sequences;

SequencesImpl: CEDAR PROGRAM
IMPORTS Rope, IO, MathConstructors, Structures, AlgebraClasses, Ints 
EXPORTS Sequences =

BEGIN OPEN AC: AlgebraClasses, Sequences;
SyntaxError: PUBLIC ERROR [reason: ATOM] = CODE;
BadElementStructure: PUBLIC ERROR [elementStructure: AC.Object] = CODE;
TypeError: PUBLIC ERROR [message: ATOM _ $Unspecified] = CODE;
Method: TYPE = AC.Method;
Object: TYPE = AC.Object;
MakeSequenceStructure: PUBLIC AC.SequenceStructureConstructor ~ {
sequenceStructureData: SequenceStructureData _ NEW[SequenceStructureDataRec _ [
row: row,
elementStructure: elementStructure
] ];
sequenceStructure _ AC.MakeStructure[
name: NIL,
class: sequencesClass,
instanceData: sequenceStructureData
];
sequenceStructure.name _ ShortPrintName[sequenceStructure];
IF AC.LookupStructure[sequenceStructure.name] = NIL THEN AC.InstallStructure[sequenceStructure];
RETURN[sequenceStructure];
};
PrintName: PUBLIC AC.ToRopeOp = {
data: SequenceStructureData _ NARROW[in.data];
shortPrintNameMethod: Method _ AC.LookupMethodInStructure[$shortPrintName, data.elementStructure];
RETURN[Rope.Concat[
"Sequences over ",
NARROW[AC.ApplyNoLkpNoRecastRef[shortPrintNameMethod,LIST[data.elementStructure] ] ]
] ];
};

ShortPrintName: PUBLIC AC.ToRopeOp = {
data: SequenceStructureData _ NARROW[in.data];
shortPrintNameMethod: Method _ AC.LookupMethodInStructure[$shortPrintName, data.elementStructure];
RETURN[Rope.Cat[
"Seq(",
NARROW[AC.ApplyNoLkpNoRecastRef[shortPrintNameMethod,LIST[data.elementStructure] ] ],
")"
] ];
};

Recast: PUBLIC AC.BinaryOp = {
thisSequenceStructure: Object _ secondArg;
thisSequenceStructureData: SequenceStructureData _ NARROW[thisSequenceStructure.data];
thisStructureElementStructure: Object _ thisSequenceStructureData.elementStructure;
canRecastMethod: Method _ AC.LookupMethodInStructure[$canRecast, thisStructureElementStructure];
recastMethod: Method _ AC.LookupMethodInStructure[$recast, thisStructureElementStructure];
flag: BOOL;

IF AC.StructureEqual[firstArg.class, secondArg] THEN RETURN[firstArg]; -- nothing to do

flag _ AC.ApplyPredNoLkpNoRecast[canRecastMethod,LIST[firstArg.class, thisStructureElementStructure] ];
IF flag THEN  {
recastElement: Object _ AC.ApplyNoLkpNoRecastObject[recastMethod, LIST[firstArg, thisStructureElementStructure] ];
RETURN[ MakeSequence[LIST[recastElement], thisSequenceStructure] ];
};

IF AC.LookupMethodInStructure[$sequenceStructure, firstArg.class]#NIL THEN {
inputSequenceStructure: Object _ firstArg.class;
inputSequenceStructureData: SequenceStructureData _ NARROW[inputSequenceStructure.data];
inputStructureElementStructure: Object _ inputSequenceStructureData.elementStructure;
argData: SequenceData _ NARROW[firstArg.data];
resultData: SequenceData;
flag _ AC.ApplyPredNoLkpNoRecast[canRecastMethod,LIST[inputStructureElementStructure, thisStructureElementStructure] ];
IF NOT flag THEN RETURN[NIL]; -- give up
resultData _ NEW[SequenceDataRec[argData.lengthPlus1 - 1] ];
FOR i:NAT IN [1..argData.lengthPlus1) DO
resultData[i] _ AC.ApplyNoLkpNoRecastObject[recastMethod, LIST[argData[i], thisStructureElementStructure] ];
ENDLOOP;
RETURN[ NEW[AC.ObjectRec _ [
flavor: StructureElement,
class: thisSequenceStructure,
data: resultData
] ] ];
};

RETURN[NIL];
};

CanRecast: PUBLIC AC.BinaryPredicate = {
thisSequenceStructure: Object _ secondArg;
thisSequenceStructureData: SequenceStructureData _ NARROW[thisSequenceStructure.data];
thisStructureElementStructure: Object _ thisSequenceStructureData.elementStructure;
canRecastMethod: Method _ AC.LookupMethodInStructure[$canRecast, thisStructureElementStructure];
flag: BOOL;
firstArgStructure: Object _ IF firstArg.flavor = StructureElement THEN firstArg.class ELSE IF firstArg.flavor = Structure THEN firstArg ELSE ERROR;
IF AC.StructureEqual[firstArgStructure, thisSequenceStructure] THEN RETURN[TRUE];

flag _ AC.ApplyPredNoLkpNoRecast[canRecastMethod,LIST[firstArgStructure, thisStructureElementStructure] ];
IF flag THEN RETURN[TRUE];

IF AC.LookupMethodInStructure[$sequenceStructure, firstArgStructure]#NIL THEN {
inputSequenceStructure: Object _ firstArgStructure;
inputSequenceStructureData: SequenceStructureData _ NARROW[inputSequenceStructure.data];
inputStructureElementStructure: Object _ inputSequenceStructureData.elementStructure;
flag _ AC.ApplyPredNoLkpNoRecast[canRecastMethod,LIST[inputStructureElementStructure, thisStructureElementStructure] ];
RETURN[flag];
};
RETURN[FALSE];
};

ToExpr: PUBLIC AC.ToExprOp = {
sequenceData: SequenceData _ NARROW[in.data];
sequenceStructureData: SequenceStructureData _ NARROW[in.class.data];
size: CARDINAL _ sequenceData.lengthPlus1 - 1;
outColumn: LIST OF MathExpr.EXPR _ NIL;
method: Method _ AC.LookupMethodInStructure[$toExpr, sequenceStructureData.elementStructure];
FOR j:NAT DECREASING IN [1..size] DO
outColumn _ CONS[NARROW[AC.ApplyNoLkpNoRecastRef[method, LIST[sequenceData[j]] ]] , outColumn];
ENDLOOP;
out _  MathConstructors.MakeSequence[size, outColumn, sequenceStructureData.row]; -- row (not column) sequence
}; 
LegalFirstChar: PUBLIC AC.LegalFirstCharOp = {
SELECT char FROM
'< => RETURN[TRUE];
ENDCASE;
RETURN[FALSE];
};

Read: PUBLIC AC.ReadOp ~ {
structureData: SequenceStructureData _ NARROW[structure.data];
elementStructure: AC.Object _ structureData.elementStructure;
readMethod: AC.Method _ AC.LookupMethodInStructure[$read, elementStructure];
puncChar: CHAR;
nextElement: AC.Object;
length: NAT _ 0;
ReadFail: PUBLIC ERROR [subclass: ATOM _ $Unspecified] = CODE;
list, listTail: LIST OF AC.Object _ NIL;
outData: SequenceData;
[]_ in.SkipWhitespace[];
puncChar _ in.GetChar[];
[]_ in.SkipWhitespace[];
IF puncChar # '< THEN ReadFail[$LeftParenExpected];
[]_ in.SkipWhitespace[];
puncChar _ in.PeekChar[];
IF puncChar = '> THEN puncChar _ in.GetChar[];
WHILE puncChar # '> DO
nextElement _ AC.ApplyReadMethod[readMethod, in, elementStructure];
length _ length + 1;
[]_ in.SkipWhitespace[];
IF list=NIL THEN list _ listTail _LIST[nextElement] ELSE
{ listTail.rest _ LIST[nextElement];  listTail _ listTail.rest };
puncChar _ in.GetChar[];
[]_ in.SkipWhitespace[];
IF puncChar # '> THEN
IF puncChar # ', THEN ReadFail[$CommaExpected];
ENDLOOP;
outData _ NEW[SequenceDataRec[length] ];
FOR i:NAT IN [1..length] DO
outData[i] _ list.first;
list _ list.rest;
ENDLOOP;
out _ NEW[AC.ObjectRec _ [flavor: StructureElement, class: structure, data: outData] ];
};

FromRope: PUBLIC AC.FromRopeOp ~ {
out _ Read[IO.RIS[in], structure];
};

ToRope: PUBLIC AC.ToRopeOp ~ { 
sequenceStructureData: SequenceStructureData _ NARROW[in.class.data];
elementStructure: AC.Object _ sequenceStructureData.elementStructure;
toRopeMethod: AC.Method _ AC.LookupMethodInStructure[$toRope, elementStructure];
inData: SequenceData _ NARROW[in.data];
out _ "( "; -- temp change 5/21/87 for SAC-2
FOR i:NAT IN [1..inData.lengthPlus1) DO
out _ Rope.Concat[ out, NARROW[AC.ApplyNoLkpNoRecastRef[toRopeMethod, LIST[inData[i] ] ] ] ];
IF i < inData.lengthPlus1-1 THEN out _ Rope.Concat[out,", "];
ENDLOOP;
out _ Rope.Concat[ out, " )" ]; -- temp change 5/21/87 for SAC-2
};

Write: PUBLIC AC.WriteOp ~ {
stream.PutRope[ ToRope[in] ]
};  
MakeSequence: PUBLIC AC.ListImbedOp ~ {
structureData: SequenceStructureData _ NARROW[structure.data];
elementStructure: AC.Object _ structureData.elementStructure;
recastMethod: Method _ AC.LookupMethodInStructure[$recast, elementStructure];
length: NAT _ 0;
ptr: LIST OF AC.Object _ data;
outData: SequenceData;
WHILE ptr#NIL DO length _ length + 1; ptr _ ptr.rest ENDLOOP;
outData _ NEW[SequenceDataRec[length] ];
FOR i:NAT IN [1..length] DO
outData[i] _ AC.ApplyNoLkpNoRecastObject[recastMethod, LIST[data.first, elementStructure] ];
IF outData[i] = NIL THEN TypeError[];
data _ data.rest;
ENDLOOP;
out _ NEW[AC.ObjectRec _ [flavor: StructureElement, class: structure, data: outData] ];
};
Select: PUBLIC AC.BinaryOp ~ {
firstData: SequenceData _ NARROW[firstArg.data];
index: INT _ Ints.ToINT[secondArg];
IF index<1 OR firstData.lengthPlus1-1<index THEN RETURN[NIL];
RETURN[firstData[index] ];
};

First: PUBLIC AC.UnaryOp ~ {
RETURN[ Select[arg, Ints.FromINT[1] ] ];
}; 

Last: PUBLIC AC.UnaryOp ~ {
firstData: SequenceData _ NARROW[arg.data];
IF firstData.lengthPlus1-1=0 THEN RETURN[NIL];
RETURN[firstData[firstData.lengthPlus1-1] ];
};

Length: PUBLIC AC.ElementRankOp ~ {
data: SequenceData _ NARROW[arg.data];
RETURN[data.lengthPlus1-1];
};
IsSubset: PUBLIC AC.BinaryPredicate ~ {
firstSeqData: SequenceData _ NARROW[firstArg.data];
secondSeqData: SequenceData _ NARROW[secondArg.data];
firstStructureData: SequenceStructureData _ NARROW[firstArg.class.data];
secondStructureData: SequenceStructureData _ NARROW[firstArg.class.data];
firstElementStructure: Object _ firstStructureData.elementStructure;
secondElementStructure: Object _ firstStructureData.elementStructure;
intIndex: Ints.Int;
IF NOT AC.StructureEqual[firstElementStructure, secondElementStructure] THEN RETURN[FALSE];
FOR i:INT IN [1..firstSeqData.lengthPlus1) DO
intIndex _ Find[secondArg, firstSeqData[i] ];
IF intIndex=NIL THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};
ObjectAndIntDesired: PUBLIC AC.UnaryToListOp ~ {
RETURN[ LIST[arg, Ints.Ints] ]; -- arg assumed to be a Sequence Structure
};

SequenceAndElementDesired: PUBLIC AC.UnaryToListOp ~ {
thisSequenceStructureData: SequenceStructureData _ NARROW[arg.data];
elementStructure: Object _ thisSequenceStructureData.elementStructure;
RETURN[ LIST[arg, elementStructure] ]; -- arg assumed to be a Sequence Structure
};
SequenceIntAndElementDesired: PUBLIC AC.UnaryToListOp ~ {
thisSequenceStructureData: SequenceStructureData _ NARROW[arg.data];
elementStructure: Object _ thisSequenceStructureData.elementStructure;
RETURN[ LIST[arg, Ints.Ints, elementStructure] ]; -- arg assumed to be a Sequence Structure
};
Paren: PUBLIC AC.UnaryOp ~ {
RETURN[NEW[AC.ObjectRec _ [
flavor: arg.flavor,
class: arg.class,
data: arg.data
] ] ];
};

Equal: PUBLIC AC.BinaryPredicate ~ {
firstArgData: SequenceData _ NARROW[firstArg.data];
secondArgData: SequenceData _ NARROW[secondArg.data];
sequenceStructureData: SequenceStructureData _ NARROW[firstArg.class.data];
elementEqualsMethod: Method _ AC.LookupMethodInStructure[$eqFormula, sequenceStructureData.elementStructure];
IF firstArgData.lengthPlus1 # secondArgData.lengthPlus1 THEN RETURN[FALSE];
FOR j: NAT IN [1..firstArgData.lengthPlus1) DO
IF NOT AC.ApplyPredNoLkpNoRecast[elementEqualsMethod, LIST[firstArgData[j], secondArgData[j] ] ] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};

Prepend: PUBLIC AC.BinaryOp ~ {
RETURN[ Insert[firstArg, Ints.FromINT[0], secondArg] ];
};

Append: PUBLIC AC.BinaryOp ~ {
firstData: SequenceData _ NARROW[firstArg.data];
RETURN[ Insert[firstArg, Ints.FromINT[firstData.lengthPlus1 - 1], secondArg] ];
};

Insert: PUBLIC AC.TernaryOp ~ {
sequenceStructureData: SequenceStructureData _ NARROW[firstArg.class.data];
elementStructure: Object _ sequenceStructureData.elementStructure;
recastMethod: Method _ AC.LookupMethodInStructure[$recast, elementStructure];
newElement: Object _ AC.ApplyNoLkpNoRecastObject[recastMethod, LIST[thirdArg, elementStructure] ];
firstData: SequenceData _ NARROW[firstArg.data];
length: INT _ firstData.lengthPlus1 -1;
insertAfter: INT _ Ints.ToINT[secondArg];
newData: SequenceData;
IF insertAfter>length THEN ERROR; 
IF newElement = NIL THEN TypeError[]; -- recast failed
newData _ NEW[SequenceDataRec[length+1] ];
FOR i:INT IN [1..insertAfter] DO newData[i] _ firstData[i] ENDLOOP;
newData[insertAfter+1] _ thirdArg;
FOR j:INT IN [insertAfter+1..length] DO newData[j+1] _ firstData[j] ENDLOOP;
RETURN[ NEW[AC.ObjectRec _ [
flavor: StructureElement,
class: firstArg.class,
data: newData
] ] ];
};

Delete: PUBLIC AC.BinaryOp ~ {
firstData: SequenceData _ NARROW[firstArg.data];
delete: INT _ Ints.ToINT[secondArg];
length: INT _ firstData.lengthPlus1-1;
newData: SequenceData;
IF delete<1 OR delete>length THEN ERROR; 
newData _ NEW[SequenceDataRec[length-1] ];
FOR i:INT IN [1..delete-1] DO newData[i] _ firstData[i] ENDLOOP;
FOR j:INT IN [delete+1..length] DO newData[j-1] _ firstData[j] ENDLOOP;
RETURN[ NEW[AC.ObjectRec _ [
flavor: StructureElement,
class: firstArg.class,
data: newData
] ] ];
};
DeleteLast: PUBLIC AC.UnaryOp ~ {
data: SequenceData _ NARROW[arg.data];
IF data.lengthPlus1-1 = 0 THEN RETURN[arg];
RETURN[Delete[arg, Ints.FromINT[data.lengthPlus1-1] ] ];
};

Find: PUBLIC AC.BinaryOp ~ {
seqData: SequenceData _ NARROW[firstArg.data];
sequenceStructureData: SequenceStructureData _ NARROW[firstArg.class.data];
elementStructure: Object _ sequenceStructureData.elementStructure;
equalMethod: Method _ AC.LookupMethodInStructure[$eqFormula, elementStructure]; 
test: BOOL;
FOR i:INT IN [1..seqData.lengthPlus1) DO
test _ AC.ApplyPredNoLkpRecast[equalMethod, elementStructure, LIST[seqData[i], secondArg] ];
IF test THEN RETURN[Ints.FromINT[i] ];
ENDLOOP;
RETURN[NIL];
};

Concatenate: PUBLIC AC.BinaryOp ~ {
firstData: SequenceData _ NARROW[firstArg.data];
firstLengthPlus1: INT _ firstData.lengthPlus1;
secondData: SequenceData _ NARROW[secondArg.data];
newData: SequenceData _ NEW[SequenceDataRec[firstLengthPlus1+secondData.lengthPlus1-2] ];
IF NOT AC.StructureEqual[firstArg.class, secondArg.class] THEN ERROR;
FOR i:INT IN [1..firstLengthPlus1) DO newData[i] _ firstData[i] ENDLOOP;
FOR j:INT IN [firstLengthPlus1..firstLengthPlus1+secondData.lengthPlus1-1) DO newData[j] _ secondData[j - firstLengthPlus1 + 1] ENDLOOP;
RETURN[ NEW[AC.ObjectRec _ [
flavor: StructureElement,
class: firstArg.class,
data: newData
] ] ];
};

MapUnaryElementOp: PUBLIC AC.BinaryMixedOp ~ {
seqData: SequenceData _ NARROW[firstArg.data];
method: Method _ NARROW[secondArg];
newElementStructure, newSeqStructure: AC.Object _ NIL;
newData: SequenceData _ NEW[SequenceDataRec[seqData.lengthPlus1-1] ];
FOR i:INT IN [1..seqData.lengthPlus1) DO
newData[i] _ AC.ApplyNoLkpNoRecastObject[method, LIST[seqData[i] ] ];
IF newData[i]# NIL THEN newElementStructure _ newData[i].class;
ENDLOOP;
IF newElementStructure = NIL THEN RETURN[firstArg]; -- map has trivial result
newSeqStructure _ MakeSequenceStructure[newElementStructure];
RETURN[ NEW[AC.ObjectRec _ [
flavor: StructureElement,
class: newSeqStructure,
data: newData
] ] ];
};
sequencesClass: AC.Object _ AC.MakeClass["SequenceClass", NIL, NIL];

setCategoryMethod: Method _ AC.MakeMethod[Value, FALSE, NEW[AC.Category _ set], NIL, NIL];
sequenceStructureMethod: Method _ AC.MakeMethod[Value, FALSE, NIL, NIL, "sequenceStructure"];
shortPrintNameMethod: Method _ AC.MakeMethod[ToRopeOp, FALSE, NEW[AC.ToRopeOp _ ShortPrintName], NIL, "shortPrintName"];
recastMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Recast], NIL, "recast"];
canRecastMethod: Method _ AC.MakeMethod[BinaryPredicate, TRUE, NEW[AC.BinaryPredicate _ CanRecast], NIL, "canRecast"];
toExprMethod: Method _ AC.MakeMethod[ToExprOp, FALSE, NEW[AC.ToExprOp _ ToExpr], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "toExpr"];
legalFirstCharMethod: Method _ AC.MakeMethod[LegalFirstCharOp, FALSE, NEW[AC.LegalFirstCharOp _ LegalFirstChar], NIL, "legalFirstChar"];
readMethod: Method _ AC.MakeMethod[ReadOp, FALSE, NEW[AC.ReadOp _ Read], NIL, "read"];
fromRopeMethod: Method _ AC.MakeMethod[FromRopeOp, TRUE, NEW[AC.FromRopeOp _ FromRope], NIL, "fromRope"];
toRopeMethod: Method _ AC.MakeMethod[ToRopeOp, FALSE, NEW[AC.ToRopeOp _ ToRope], NIL, "toRope"];
parenMethod: Method _ AC.MakeMethod[UnaryOp, FALSE, NEW[AC.UnaryOp _ Paren], NIL, "paren"];
sequenceMethod: Method _ AC.MakeMethod[ListImbedOp, FALSE, NEW[AC.ListImbedOp _ MakeSequence], NIL, "sequence"];
selectMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Select], NEW[AC.UnaryToListOp _ ObjectAndIntDesired], "select"];
firstMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ First], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "first"];
lastMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Last], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "last"];
lengthMethod: Method _ AC.MakeMethod[ElementRankOp, TRUE, NEW[AC.ElementRankOp _ Length], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "length"];
subsetMethod: Method _ AC.MakeMethod[BinaryPredicate, TRUE, NEW[AC.BinaryPredicate _ IsSubset], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "subset"];
equalMethod: Method _ AC.MakeMethod[BinaryPredicate, TRUE, NEW[AC.BinaryPredicate _ Equal], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "equals"];
prependMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Prepend], NEW[AC.UnaryToListOp _ SequenceAndElementDesired], "prepend"];
appendMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Append], NEW[AC.UnaryToListOp _ SequenceAndElementDesired], "append"];
insertMethod: Method _ AC.MakeMethod[TernaryOp, FALSE, NEW[AC.TernaryOp _ Insert], NEW[AC.UnaryToListOp _ SequenceIntAndElementDesired], "insert"];  -- not an operator currently since takes three args
deleteMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Delete], NEW[AC.UnaryToListOp _ ObjectAndIntDesired], "delete"];
deleteLastMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ DeleteLast], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "deleteLast"];
findMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Find], NEW[AC.UnaryToListOp _ SequenceAndElementDesired], "find"];
concatenateMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Concatenate], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "concatenate"];
mapUnaryElementOpMethod: Method _ AC.MakeMethod[BinaryMixedOp, TRUE, NEW[AC.BinaryMixedOp _ MapUnaryElementOp], NIL, "mapUnary"]; -- have to have DesiredArgStructures _ NIL since BinaryMixedOp

makeSequenceStructureMethod: Method _ AC.MakeMethod[SequenceStructureConstructor, FALSE, NEW[AC.SequenceStructureConstructor _ MakeSequenceStructure], NIL, "makeSequenceStructure"];


AC.AddMethodToClass[$category, setCategoryMethod, sequencesClass];
AC.AddMethodToClass[$sequenceStructure, sequenceStructureMethod, sequencesClass];
AC.AddMethodToClass[$shortPrintName, shortPrintNameMethod, sequencesClass];
AC.AddMethodToClass[$recast, recastMethod, sequencesClass];
AC.AddMethodToClass[$canRecast, canRecastMethod, sequencesClass];
AC.AddMethodToClass[$toExpr, toExprMethod, sequencesClass];
AC.AddMethodToClass[$legalFirstChar, legalFirstCharMethod, sequencesClass];
AC.AddMethodToClass[$read, readMethod, sequencesClass];
AC.AddMethodToClass[$fromRope, fromRopeMethod, sequencesClass];
AC.AddMethodToClass[$toRope, toRopeMethod, sequencesClass];
AC.AddMethodToClass[$paren, parenMethod, sequencesClass];
AC.AddMethodToClass[$sequence, sequenceMethod, sequencesClass];
AC.AddMethodToClass[$select, selectMethod, sequencesClass];
AC.AddMethodToClass[$first, firstMethod, sequencesClass];
AC.AddMethodToClass[$last, lastMethod, sequencesClass];
AC.AddMethodToClass[$length, lengthMethod, sequencesClass];
AC.AddMethodToClass[$subset, subsetMethod, sequencesClass];
AC.AddMethodToClass[$eqFormula, equalMethod, sequencesClass];
AC.AddMethodToClass[$prepend, prependMethod, sequencesClass];
AC.AddMethodToClass[$append, appendMethod, sequencesClass];
AC.AddMethodToClass[$insert, insertMethod, sequencesClass];
AC.AddMethodToClass[$delete, deleteMethod, sequencesClass];
AC.AddMethodToClass[$deleteLast, deleteLastMethod, sequencesClass];
AC.AddMethodToClass[$find, findMethod, sequencesClass];
AC.AddMethodToClass[$concatenate, concatenateMethod, sequencesClass];
AC.AddMethodToClass[$mapUnary, mapUnaryElementOpMethod, sequencesClass];

AC.AddMethodToClass[$makeSequenceStructure, makeSequenceStructureMethod, Structures.StructuresClass];



END.

ΎSequencesImpl.mesa
Last Edited by: Arnon, July 19, 1985 2:54:46 pm PDT

Errors and Types
Sequence Structure Ops
Conversion and IO
Args are a StructureElement and a Structure
See if can recast firstArg into thisStructureElementStructure
If firstArg is a Sequence, see if can recast its elementStructure into thisStructureElementStructure; if so, recast all its elements.
Can't do it
Args are either [Structure, Structure] or [StructureElement, Structure]
out _ "< ";
out _ Rope.Concat[ out, " >" ];
Constructor
Attempts to recast supplied elements into elementStructure.
If data = NIL then returns a Sequence whose SequenceDataRec is of length 0.
Selection
firstArg = Sequence, return first element.  Return NIL if empty.
firstArg = Sequence, return last element.  Return NIL if empty.
Predicates
firstArg and secondArg are Sequences.  Returns TRUE if firstArg is a subset of secondArg.  Returns FALSE if args have different elementStructures.
Standard Desired Arg Structures
Operations
firstArg is a Sequence, secondArg is an Ints.Int specifying position after which to insert new item, thirdArg is new item. secondArg = 0 means insert at beginning, secondArg = i means insert after ith element of sequence. thirdArg must belong to firstArg's elementStructure.
Error if secondArg > Length[firstArg].
firstArg is a Sequence, secondArg is a positive Ints.Int specifying position to delete.
Error if secondArg<1 OR secondArg > Length[firstArg].
Concatenate two Sequences.  Must have same elementStructure.
firstArg is a Sequence, secondArg is a unary Method (e.g. UnaryOp, UnaryPredicate) on its elementStructure, result is Sequence of results of applications of the unary operation to the elements of firstArg.
Start Code
Κ˜Jš
œ™J™3J™š
Οk	˜	Jš
œ˜Icode˜K˜	K˜Kš
œ˜Kš
œ˜K˜Jš
œ
˜
—J˜
head2šœœ
˜Jšœœ5˜EJšœ˜J˜—Jšœ
œ
œ˜)
head™Jš	œ
œ
œ
œœ
˜0Jš	œœ
œœœ
˜GJš	œœ
œœœ
˜>Jšœœœ˜Jšœœœ˜—š
œ™šΟnœœ
œ!˜Ašœ/œ˜OK˜	Kš
œ"˜"Kš
œ˜—šœœ˜%Kšœœ
˜
Kš
œ˜Kš
œ#˜#Kš
œ˜—Kš
œ;˜;Kš
œ
œ+œ
œ
œ%˜`Jšœ˜K˜—šž	œ	œ
˜!Jšœœ
˜.KšœœA˜bšœ
˜Jš
œ˜Jšœ
œ,œ˜TJš
œ˜—J˜J˜—šžœ	œ
˜&Jšœœ
˜.KšœœA˜bšœ
˜J˜Jšœ
œ,œ˜UJš
œ˜Jš
œ˜—J˜J˜——š
œ™šžœ	œ
˜Jš
œ+™+J˜*Jšœ3œ˜VJš
œS˜SKšœœD˜`KšœœA˜ZJšœœ
˜J˜Jš	œ
œ+œ
œΟc˜WJ˜Jš
œ=™=Jšœœ(œ2˜gšœœ˜Jšœœ(œ,˜rJšœœ*˜CJš
œ˜J˜—Jš
œ…
™…
šœ
œ=œ
œ˜LJš
œ0˜0Jšœ4œ˜XJš
œU˜UJšœœ˜.Jš
œ˜Jšœœ(œB˜wJšœ
œœ
œ
œŸ
˜(Jšœ
œ,˜<šœœ
œ˜(Jšœœ(œ.˜lJšœ
˜—šœœ
œ˜K˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜—K˜K™Kšœ
œ˜K˜J˜—šž	œ	œ˜(Jš
œG™GJ˜*Jšœ3œ˜VJš
œS˜SKšœœD˜`Jšœœ
˜Jšœœ$œœ
œœ
œ
œ
˜“
Jš
œ
œ:œ
œ
œ˜QJ˜Jšœœ(œ5˜jJšœœ
œ
œ˜J˜šœ
œ@œ
œ˜OJš
œ3˜3Jšœ4œ˜XJš
œU˜UJšœœ(œB˜wJšœ˜
K˜—Kšœ
œ˜K˜J˜—šžœ	œ
˜Jšœœ
˜-Jšœ/œ˜EJšœœ ˜.Jš	œœ
œ
œœ
˜'KšœœJ˜]š	œœ

œ
œ˜$Jš	œœ
œ
œœ"˜_Kšœ
˜—JšœRŸ˜nJš
œ˜—šžœ	œ˜.šœ˜Kšœœ
œ˜Kšœ
˜—Kšœ
œ˜J˜J˜—šžœœ
œ˜Jšœ'œ˜>Jšœœ)˜=Jšœœ
œ2˜LJšœ
œ
˜Kšœ
œ˜Kšœœ˜Jš
žœœ
œœœ
˜>Jš	œœ
œ
œ
œ
˜(Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœœ˜3Jš
œ˜Jš
œ˜Jšœœ˜.šœ˜Jšœœ3˜CKš
œ˜Jš
œ˜š	œœ
œœ˜8Jšœœ+˜A—Jš
œ˜Jš
œ˜šœ˜Jšœœ˜/—Kšœ
˜—Jšœ
œ˜(šœœ
œ
˜Jš
œ˜Jš
œ˜Jšœ
˜—Jšœœ
œK˜WJ˜J˜—šžœœ
œ˜"Jšœœ
œ˜"J˜J˜—šžœœ
œ˜Jšœ/œ˜EJšœœ1˜EJšœœ
œ4˜PJšœœ
˜'Jš
œ™JšœŸ ˜,šœœ
œ˜'Jšœ	œ%œ˜]Kšœœ˜=Jšœ
˜—Jš
œ™Jšœ Ÿ ˜@K˜J˜—šžœœ˜Jš
œ˜Jš
œ˜——™šžœœ
œ˜'Jš
œ;™;Jš
œK™KJšœ'œ˜>Jšœœ)˜=Kšœœ4˜MKšœœ˜Kšœœ
œ
œ˜Jš
œ˜Jšœœ
œ%œ
˜=Jšœ
œ˜(šœœ
œ
˜Jšœ
œ(œ!˜\Jšœœ
œ
˜%Jš
œ˜Jšœ
˜—Jšœœ
œK˜WJ˜——š
ž	™	šžœœ
œ
˜Jšœœ˜0Jšœœ˜#Jš
œ	œœ
œ
œ˜=Jšœ˜K˜K˜—šžœœ
œ˜Kšœ3œ
™@Kšœ"˜(Kš
œ˜K˜—šžœ	œ˜Kš
œ?™?Jšœœ˜+Jšœœ
œ
œ˜.Jšœ&˜,K˜K˜—šžœœ
œ˜#Jšœœ˜&Jšœ˜K˜——š
ž
™
šžœ	œ˜'Kš
œ’
™’
Jšœœ˜3Jšœœ˜5Jšœ,œ˜HJšœ-œ˜IJš
œD˜DJš
œE˜EJš
œ˜Jšœ
œ
œ?œ
œ
œ˜[šœœ
œ˜-Jš
œ-˜-Jš
œ
œ
œ
œ
œ˜#Jšœ
˜—Jšœ
œ˜
K˜——™šžœœ
œ˜0JšœœŸ)˜IJ˜J˜—šžœœ
œ˜6Jšœ3œ˜DJš
œF˜FJšœœŸ)˜PJ˜—šžœœ
œ˜9Jšœ3œ˜DJš
œF˜FJšœœ&Ÿ)˜[J˜——š
ž
™
šžœœ
œ˜šœ
œ
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜K˜—šžœœ
œ˜$Jšœœ˜3Jšœœ˜5Jšœ/œ˜KKšœœM˜mJšœ6œ
œ
œ˜Kšœœ
œ˜.Jšœ
œ
œ-œ'œ
œ
œ˜tJšœ
˜—Jšœ
œ˜
J˜J˜—šžœœ
œ
˜Jšœ1˜7K˜K˜—šžœœ
œ
˜Jšœœ˜0JšœI˜OK˜K˜—šžœœ
œ˜Kš
œ’™’Kš
œ&™&Jšœ/œ˜KJš
œB˜BKšœœ4˜MKšœœ(œ˜bJšœœ˜0Jšœœ˜'Jšœ
œ˜)Jš
œ˜Kšœœ
œ˜"Jšœœ
œŸ˜6Jšœ
œ˜*Jš
œœ
œœœ
˜CJš
œ"˜"Jš
œœ
œœœ
˜Lšœœ
œ˜K˜Kš
œ˜Kš
œ
˜
Kš
œ˜—K˜K˜—šžœœ
œ
˜Kš
œW™WKš
œ5™5Jšœœ˜0Jšœœ˜$Jšœœ˜&Jš
œ˜Kšœ
œœ
œ˜)Jšœ
œ˜*Jš
œœ
œœœ
˜@Jš
œœ
œœœ
˜Gšœœ
œ˜K˜Kš
œ˜Kš
œ
˜
Kš
œ˜—K˜—šž
œœ
œ˜!Jšœœ˜&Jšœœ
œ˜+Jšœ2˜8J˜K˜—šžœœ
œ
˜Jšœœ˜.Jšœ/œ˜KJš
œB˜BJšœœ8˜PJšœœ
˜šœœ
œ˜(Jšœœ5œ˜\Jšœœ
œ˜&Jšœ
˜—Jšœ
œ˜K˜K˜—šžœœ
œ
˜#Kš
œ<™<Jšœœ˜0Jšœœ˜.Jšœœ˜2Jšœœ>˜YJš
œ
œ
œ1œ
œ
˜EJš
œœ
œœœ
˜HJš
œœ
œ?œ3œ
˜ˆ
šœœ
œ˜K˜Kš
œ˜Kš
œ
˜
Kš
œ˜—K˜K˜—šžœœ
œ˜.Kšœ:žœžœ|™Ν
Jšœœ˜.Kšœœ˜#Jšœ&œ
œ
˜6Jšœœ*˜Ešœœ
œ˜(Jšœ
œ"œ˜EJšœ
œ
œ(˜?Jšœ
˜—Jš	œœ
œ
œŸ˜MJš
œ=˜=šœœ
œ˜K˜Kš
œ˜Kš
œ
˜
Kš
œ˜—K˜——™
Kš	œœ
œœœ˜DJ˜Jš
œœœœ
œœœ˜ZJš	œ"œœœœ˜]Jšœœœœ
œœ˜xJšœœœœ
œœ˜_Jšœœœœ
œœ˜vJšœœœœ
œœ
œœ
žœ
˜“
Jšœœœœ
œ%œ˜ˆ
Jšœœœœ
œœ
˜VJšœœœœ
œœ˜iJšœœœœ
œœ˜`Jšœœœœ
œœ˜[Jšœœœœ
œœ˜pJšœœœœ
œœ
œžœ
˜‡
Jšœœœœ
œœ
œœ(˜
Jšœœœœ
œœ
œœ'˜Š
Jšœœœœ
œœ
œœ)˜œ
Jšœœœœ
œœ
œœ)˜’
Jšœœœœ
œœ
œœ)˜ž
Jšœœœœ
œœ
œžœ˜
Jšœœœœ
œœ
œžœ
˜
Jšœœœœ
œœ
œžœŸ3˜Θ
Jšœœœœ
œœ
œžœ
˜‡
Jšœœœœ
œœ
œœ-˜œ
Jšœœœœ
œœ
œžœ˜‡
Jšœœœœ
œœ
œœ.˜‘
Jšœ"œœœ
œ%œŸ>˜ΐ
J˜Jšœ&œ*œœ
œ8œ˜΅
J˜J˜Jšœ@˜BJšœO˜QJšœI˜KJšœ9˜;Jšœ?˜AJšœ9˜;JšœI˜KJšœ5˜7Jšœ=˜?Jšœ9˜;Jšœ7˜9Jšœ=˜?Jšœ9˜;Jšœ7˜9Jšœ5˜7Jšœ9˜;Jšœ9˜;Jšœ;˜=Jšœ;˜=Jšœ9˜;Jšœ9˜;Jšœ9˜;JšœA˜CJšœ5˜7JšœC˜EJšœF˜HJ˜Jšœc˜eJ˜—˜J˜—Jšœ
˜J˜—…—MDi‘