
    <<SetsTest.cm>>
        <<Last tweaked by Mike Spreitzer on March 8, 1988 9:08:58 am PST>>

    Install SetsAndStuff
    state
    { OPEN IntStuff, SetBasics, Sets:AbSets, Sets, BiRelBasics, BiRels; NULL}
    { alwaysAdd: IfHadPair ~ ALL[ALL[TRUE]]; NULL}
    _ &r1 _ CreateHashReln[ALL[refs], ALL[TRUE], ALL[TRUE]]
    _ &r1.class.AddPair[&r1, [[ra:$foo], [ra:$bar]], alwaysAdd]
    _ &s1 _ Sets.NCreateSingleton[[ra:$foo], refs]
    _ &i1 _ &r1.class.Image[&r1, &s1, leftToRight]
    _ &r1.class.AddPair[&r1, [[ra:$bar], [ra:$gronk]], alwaysAdd]
    _ &r1.class.AddPair[&r1, [[ra:$gronk], [ra:$foo]], alwaysAdd]
    _ &r1.class.AddPair[&r1, [[ra:$zot], [ra:NIL]], alwaysAdd]
    _ &r1
    _ &c1 _ Compose[&r1, &r1, ALL[FALSE]]

    _ &r2 _ CreateList[NIL, [TRUE, FALSE], ALL[refs], variable, [ALL[fwd]], FALSE]
    _ &r2.class.AddPair[&r2, [[ra:$foo], [ra:$zoo]], alwaysAdd]
    _ &r2.class.AddPair[&r2, [[ra:$bar], [ra:$baz]], alwaysAdd]
    _ &r2.class.AddPair[&r2, [[ra:$baz], [ra:$foo]], alwaysAdd]
    _ &r2.class.AddPair[&r2, [[ra:$zoo], [ra:$bar]], alwaysAdd]
    _ &r2
    _ &r2.class.AddPair[&r2, [[ra:$bar], [ra:$oof]], alwaysAdd]
    _ &r2

    _ &l1 _ Sets.CreateList[LIST[[i:10], [i:30], [i:20]], ints, variable, fwd]
    _ &l1.class.AddSet[&l1, Sets.NCreateSingleton[[i:15], ints]]
    _ &l1
    _ &l1.class.AddSet[&l1, Sets.NCreateSingleton[[i:20], ints]]
    _ &l1

    _ &v1 _ CreateVector[bounds: [0, 9], val: [ra:$foo], rightSpace: refs]
    _ &v1.class.AddPair[&v1, [[i:3], [ra:$bar]], alwaysAdd]
    _ &v1.class.AddPair[&v1, [[i:13], [ra:$bar]], alwaysAdd]
    _ &v1.class.RemPair[&v1, [[i:5], [ra:$foo]]]
    _ &v1.class.RemPair[&v1, [[i:4], [ra:$zork]]]
    _ &v1.class.RemPair[&v1, [[i:40], [ra:$zork]]]
    _ &v1
    _ &v1.class.Image[&v1, IIAsSet[[0, 20]], leftToRight]
    _ &sr _ &v1.class.SetOn[&v1, right]
    _ &sr.class.Get3[&sr, [$foo], [TRUE, TRUE, TRUE]]
    _ &sr.class.HasMember[&sr, [$foo]]
    _ &sr.class.HasMember[&sr, [$baz]]
    _ &v1.class.AddPair[&v1, [[i:11], [ra:NIL]], alwaysAdd]
    _ &allints _ IntervalAsSet[ints, ALL[noValue]]
    _ &nil _ Sets.NCreateSingleton[[NIL], refs]
    _ &v1.class.ScanRestriction[&v1, [&allints, &nil], AcceptAny, [ALL[no]]]

    _ &l2 _ Sets.CreateList[LIST[[ra:"y"], [ra:"x"], [ra:"z"]], ropes[TRUE], variable, no]
    _ EnumSeqOfSet[&l2, fwd]
    _ EnumSeqOfSet[&l2, bwd]
    _ &s2 _ EnumSeqOfSet[&l2, no]
    _ &s2.class.GetBounds[&s2, ALL[TRUE], [ALL[fwd]]]!!!
    _ &l2.class.AddSet[&l2, Sets.NCreateSingleton[[ra:"xyz"], ropes[TRUE]]]
    _ &l2
    _ &s2
    _ &p1 _ GradeUp[&s2, [ropes[TRUE].Compare, ropes[TRUE].data]]
    _ &s3 _ CreateVector[val: noValue, rightSpace: ropes[TRUE]]
    _ TransPermute[&s2, &s3, &p1]
    _ &s3
    _ &s2b _ CreateVectorCopy[of: &s2, rightSpace: ropes[TRUE]]
    _ PermuteInPlace[&s2b, &p1]
    _ &s2b

    _ &rb1 _ CreateRedBlackTable[[ropes[TRUE], refs]]
    _ &rb1.class.AddPair[&rb1, [[ra:"bar"], [ra:$bar]], alwaysAdd]
    _ &rb1
    _ &rb1.class.AddPair[&rb1, [[ra:"bar"], [ra:$Bar]], alwaysAdd]
    _ &rb1.class.AddPair[&rb1, [[ra:"Bar"], [ra:$Bar]], alwaysAdd]
    _ &rb1.class.Apply[&rb1, [ra:"bar"], leftToRight]
    _ &rb1.class.Apply[&rb1, [ra:"zork"], leftToRight]
    _ &rb1.class.Delete[&rb1, [ra:"bar"], left]
    _ &rb1.class.Delete[&rb1, [ra:"bork"], left]
    _ &rb1.class.RemPair[&rb1, [[ra:"bar"], [ra:$Boff]]]

    _ &ht1 _ CreateHashTable[ALL[refs]]
    _ &ht1.class.AddPair[&ht1, [[ra:$bar], [ra:$rab]], alwaysAdd]
    _ &ht1.class.AddPair[&ht1, [[ra:$foo], [ra:$oof]], alwaysAdd]
    _ &ht1
    _ BiRels.Primitive[&ht1, $ScanRestriction, NIL, BiRels.FromRO[[[fwd, no], left]]]
    _ &ht1.class.GetOne[&ht1, FALSE, [[fwd, no], left]]

    _ &s4 _ CreateHashSet[refs]
    _ NAddElt[&s4, [ra:$foo]]
    _ NAddElt[&s4, [ra:NIL]]
    _ NAddElt[&s4, [ra:$zork]]
    _ &s4
    _ NAddElt[&s4, [ra: $foo]]
    _ &s4
    _ &s4.class.RemSet[&s4, Sets.NCreateSingleton[[ra:$foo], refs]]
    _ &s4.class.RemSet[&s4, Sets.NCreateSingleton[[ra:$foo], refs]]
    _ &s4

    _ &ps1 _ WidenPairSpace[[[ints, refs], [ALL[fwd], left]]]
    _ &hps1 _ CreateHashSet[&ps1]!
    _ NAddElt[&hps1, [ra: NEW [Pair _ [[i:3], [ra:$foo]]]]]
    _ NAddElt[&hps1, [ra: NEW [Pair _ [[i:5], [ra:"5"]]]]]
    _ &hps1
    _ FormatSet[&hps1]

    _ &v2 _ CreateBitVector[bounds: [0, 32], expandable: FALSE]!
    _ NAddElt[&v2, [i: 5]]
    _ NAddElt[&v2, [i: 10]]
    _ NAddElt[&v2, [i: 16]]
    _ &v2
    _ &v2.class.Size[&v2, lastEINT]
    _ &v2.class.RemSet[&v2, IIAsSet[[10, 20]]]
    _ &v2

    _ &v2 _ CreateBitVector[bounds: [0, 32], expandable: TRUE]!
    _ NAddElt[&v2, [i: 5]]
    _ NAddElt[&v2, [i: 16]]
    _ &v2
    _ NAddElt[&v2, [i: -5]]
    _ NAddElt[&v2, [i: 35]]
    _ &v2

    _ &g1 _ GenCreate[spaces: [refs, ints], functional: ALL[FALSE], mappable: ALL[TRUE], hints: [[set: [class: $Vector, details: 
    LIST[[$Bounds, NEW [IntInterval _ [0, 16]] ]] ]], [fn: [class: $Vector, details: LIST[[$Bounds, NEW [IntInterval _ [0, 16]] ]] 
    ]] ]]
    _ &g1.class.AddPair[&g1, [[ra:$bar], [i:6]], alwaysAdd]
    _ &g1.class.AddPair[&g1, [[ra:$bar], [i:7]], alwaysAdd]
    _ &g1.class.AddPair[&g1, [[ra:$rab], [i:6]], alwaysAdd]
    _ &g1.class.AddPair[&g1, [[ra:$zit], [i:-6]], alwaysAdd]
    _ &g1
    _ &g1.class.Apply[&g1, [i:-6], rightToLeft]
    _ &g1.class.Apply[&g1, [i:7], rightToLeft]
    _ &g1.class.Apply[&g1, [i:8], rightToLeft]

    _ &base _ CreateVector[bounds: [0, 10], val: noValue, rightSpace: ints]
    _ &tfc _ &base.TransitiveFnClosure[TRUE]!
    _ &img _ &tfc.class.Image[&tfc, &v2, leftToRight]
    _ &base.AddNewII[1, 0]
    _ &base.AddNewII[2, 1]
    _ &base.AddNewII[3, 1]
    _ &base.AddNewII[4, 2]
    _ &base.AddNewII[5, 2]
    _ &base
    _ &tfc
    _ &img
    _ &tfc.class.HasPair[&tfc, [[i:1], [i:0]]]
    _ &tfc.class.HasPair[&tfc, [[i:0], [i:1]]]
    _ &base.AddNewII[0, 0]
    _ &tfc _ &base.TransitiveFnClosure[FALSE]
    _ &tfc.class.HasPair[&tfc, [[i:1], [i:0]]]
    _ &tfc.class.HasPair[&tfc, [[i:0], [i:1]]]
    _ &base.Substitute[[i:1], [i:7], right]
    _ &base