
<<SequencesImpl.mesa>>
<<Last Edited by: Arnon, July 19, 1985 2:54:46 pm PDT>>
<<>>
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;
<<Errors and Types>>
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;
<<Sequence Structure Ops>>
    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] ] ],
")"
] ];
};

<<Conversion and IO>>
Recast: PUBLIC AC.BinaryOp = {
<<Args are a StructureElement and a Structure>>
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

<<See if can recast firstArg into thisStructureElementStructure>>
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 firstArg is a Sequence, see if can recast its elementStructure into thisStructureElementStructure; if so, recast all its 
elements.>>
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
        ] ] ];
    };

    <<Can't do it>>
    RETURN[NIL];
    };

CanRecast: PUBLIC AC.BinaryPredicate = {
<<Args are either [Structure, Structure] or [StructureElement, Structure]>>
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 _ "< ";>>
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, " >" ];>>
out _ Rope.Concat[ out, " )" ]; -- temp change 5/21/87 for SAC-2
    };

Write: PUBLIC AC.WriteOp ~ {
stream.PutRope[ ToRope[in] ]
};  
<<Constructor>>
MakeSequence: PUBLIC AC.ListImbedOp ~ {
<<Attempts to recast supplied elements into elementStructure.>>
<<If data = NIL then returns a Sequence whose SequenceDataRec is of length 0.>>
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] ];
};
<<Selection>>
    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 ~ {
        <<firstArg = Sequence, return first element.  Return NIL if empty.>>
        RETURN[ Select[arg, Ints.FromINT[1] ] ];
        }; 

    Last: PUBLIC AC.UnaryOp ~ {
        <<firstArg = Sequence, return last element.  Return NIL if empty.>>
    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];
        };
<<Predicates>>
    IsSubset: PUBLIC AC.BinaryPredicate ~ {
        <<firstArg and secondArg are Sequences.  Returns TRUE if firstArg is a subset of secondArg.  Returns FALSE if args have different 
        elementStructures.>>
    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];
        };
<<Standard Desired Arg Structures>>
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
};
<<Operations>>
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 ~ {
        <<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].>>
    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 ~ {
        <<firstArg is a Sequence, secondArg is a positive Ints.Int specifying position to delete.>>
        <<Error if secondArg<1 OR secondArg > Length[firstArg].>>
    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 ~ {
        <<Concatenate two Sequences.  Must have same elementStructure.>>
    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 ~ {
        <<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.>>
    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
            ] ] ];
        };
<<Start Code>>
    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.