<> <> DIRECTORY Atom, Basics, PrincOps, Rope; Collections: CEDAR DEFINITIONS IMPORTS Basics = { <> LNAT: TYPE ~ INT--[0 .. INT.LAST]--; ROPE: TYPE ~ Rope.ROPE; LOV: TYPE ~ LIST OF Value; Error: ERROR [msg: ROPE, args: LOV]; <> Complain: PROC [coll: Collection, msg: ROPE, args: LOV _ NIL] ~ INLINE {Error[msg, CONS[NEW [Collection _ coll], args]]}; <> <> <> Value: TYPE ~ REF ANY; noValue: READONLY NoValue; NoValue: TYPE ~ REF NoValuePrivate; NoValuePrivate: TYPE ~ RECORD []; MaybeValue: TYPE ~ RECORD [found: BOOL, val: Value]; noMaybe: READONLY MaybeValue -- = [FALSE, noValue]--; Val: PROC [mv: MaybeValue] RETURNS [Value] ~ INLINE {RETURN [IF mv.found THEN mv.val ELSE Error[notFound, NIL]]}; notFound: READONLY ROPE; DVal: PROC [mv: MaybeValue, ifNotFound: Value _ NIL] RETURNS [Value] ~ INLINE {RETURN [IF mv.found THEN mv.val ELSE ifNotFound]}; <> <> Space: TYPE ~ REF SpacePrivate; refs, refInts, refColls: READONLY Space; ropes: READONLY ARRAY --case matters--BOOL OF Space; SpaceEqual: PROC [space: Space, elt1, elt2: Value] RETURNS [BOOL] ~ INLINE {RETURN [elt1=elt2 OR space.Equal#NIL AND space.Equal[space.data, elt1, elt2]]}; SpaceHash: PROC [space: Space, elt: Value] RETURNS [CARDINAL] ~ INLINE {RETURN [IF space.Hash#NIL THEN space.Hash[space.data, elt] ELSE HashRefI[elt]]}; SpaceCompare: PROC [space: Space, elt1, elt2: Value] RETURNS [Basics.Comparison] ~ INLINE {RETURN [IF space.Compare#NIL THEN space.Compare[space.data, elt1, elt2] ELSE CompareRefI[elt1, elt2]]}; <> <> <> Collection: TYPE ~ RECORD [class: CollectionClass, data: REF ANY]; Cons: PROC [class: CollectionClass, data: REF ANY] RETURNS [Collection]; <> nilColl: Collection ~ [NIL, NIL]; --a Collection that is not a collection badColl: Collection; --another Collection that is not a collection; will not be returned by DeRef Refify: PROC [coll: Collection] RETURNS [ref: REF ANY] ~ INLINE {ref _ NEW [Collection _ coll]}; DeRef: PROC [ra: REF ANY] RETURNS [Collection] <> ~ INLINE {RETURN [IF ra#NIL THEN NARROW[ra, REF Collection]^ ELSE nilColl]}; <> Cant: ERROR [coll: Collection]; <> QualityOf: PROC [coll: Collection, op: ATOM, args: ArgList _ NIL] RETURNS [ImplQuality]; <> ArgList: TYPE ~ LIST OF REF ANY; ImplQuality: TYPE ~ {cant, poorDefault, goodDefault, primitive}; <> GetBool: PROC [args: ArgList, i: NAT, default: BOOL _ FALSE] RETURNS [BOOL]; <> GetDir: PROC [args: ArgList, i: NAT, default: Direction _ leftToRight] RETURNS [Direction]; FromBool: PROC [BOOL] RETURNS [ATOM]; FromDir: PROC [Direction] RETURNS [ATOM]; Can: PROC [coll: Collection, op: ATOM, args: ArgList _ NIL] RETURNS [BOOL] ~ INLINE {RETURN [QualityOf[coll, op, args]#cant]}; HasMember: PROC [coll: Collection, elt: Value] RETURNS [BOOL] ~ INLINE {RETURN [coll.class.HasMember[coll, elt]]}; OrderStyle: TYPE ~ {none, client, value}; <> OrderStyleOf: PROC [coll: Collection] RETURNS [OrderStyle] ~ INLINE {RETURN [coll.class.orderStyle]}; Ordering: TYPE ~ RECORD [Compare: CompareProc, data: REF ANY]; unordered: Ordering ~ [NIL, NIL]; <> ReverseOrdering: PROC [o: Ordering] RETURNS [ro: Ordering]; <> ComposeOrderings: PROC [mso, lso: Ordering] RETURNS [Ordering]; <> OrderingList: TYPE ~ LIST OF Ordering; LexOrdering: PROC [prefix, repeat: OrderingList] RETURNS [Ordering]; <> SpaceOrdering: PROC [space: Space] RETURNS [Ordering]; OrderingOf: PROC [coll: Collection] RETURNS [Ordering] <> ~ INLINE {RETURN coll.class.OrderingOf[coll]}; Enumerate: PROC [coll: Collection, Consumer: PROC [Value], bkwd: BOOL _ FALSE] <> <> ~ INLINE {coll.class.Enumerate[coll, Consumer, bkwd]}; PreserveValue: PROC [coll: Collection, val: Value] RETURNS [preserved: Value] <> ~ INLINE {RETURN [IF coll.class.PreserveValue=NIL THEN val ELSE coll.class.PreserveValue[coll, val]]}; Tester: TYPE ~ PROC [val: Value] RETURNS [pass: BOOL _ FALSE]; Scan: PROC [coll: Collection, Test: Tester, bkwd: BOOL _ FALSE] RETURNS [MaybeValue] <> ~ INLINE {RETURN coll.class.Scan[coll, Test, bkwd]}; ParallelTester: TYPE ~ PROC [a, b: MaybeValue] RETURNS [pass: BOOL _ FALSE]; ParallelScan: PROC [a, b: Collection, Test: ParallelTester, bkwd: BOOL _ FALSE] RETURNS [ParallelFind]; <> ParallelFind: TYPE ~ RECORD [found: BOOL, a, b: MaybeValue]; TheElt: PROC [coll: Collection] RETURNS [Value] <> ~ INLINE {RETURN coll.class.TheElt[coll]}; notASingleton: READONLY ROPE; First: PROC [coll: Collection] RETURNS [MaybeValue] <> ~ INLINE {RETURN coll.class.Extremum[coll, FALSE, FALSE]}; Last: PROC [coll: Collection] RETURNS [MaybeValue] ~ INLINE {RETURN coll.class.Extremum[coll, TRUE, FALSE]}; Pop: PROC [coll: Collection, bkwd: BOOL _ FALSE] RETURNS [MaybeValue] <> ~ INLINE {RETURN coll.class.Extremum[coll, bkwd, TRUE]}; Extremum: PROC [coll: Collection, bkwd, remove: BOOL] RETURNS [MaybeValue] ~ INLINE {RETURN coll.class.Extremum[coll, bkwd, remove]}; Next: PROC [coll: Collection, elt: Value] RETURNS [MaybeValue] <> ~ INLINE {RETURN [coll.class.Get3[coll, elt].next]}; Prev: PROC [coll: Collection, elt: Value] RETURNS [MaybeValue] ~ INLINE {RETURN [coll.class.Get3[coll, elt].prev]}; Get3: PROC [coll: Collection, elt: Value] RETURNS [prev, same, next: MaybeValue] <> ~ INLINE {RETURN coll.class.Get3[coll, elt]}; Size: PROC [coll: Collection, limit: LNAT _ LNAT.LAST] RETURNS [LNAT] <> ~ INLINE {RETURN [coll.class.Size[coll, limit]]}; Empty: PROC [coll: Collection] RETURNS [BOOL] ~ INLINE {RETURN [coll.class.Size[coll, 1]=0]}; Mutability: TYPE ~ {constant, readonly, variable}; <> ChangeableMutability: TYPE ~ Mutability[readonly..variable]; UnwriteableMutability: TYPE ~ Mutability[constant..readonly]; MutabilityOf: PROC [coll: Collection] RETURNS [Mutability] ~ INLINE {RETURN [coll.class.mutability]}; Copy: PROC [coll: Collection] RETURNS [VarColl] <> ~ INLINE {RETURN [coll.class.Copy[coll]]}; Insulate: PROC [coll: Collection] RETURNS [UWColl] <> ~ INLINE {RETURN [coll.class.Insulate[coll]]}; ValueOf: PROC [coll: Collection] RETURNS [ConstColl] <> ~ INLINE {RETURN [coll.class.ValueOf[coll]]}; Freeze: PROC [coll: Collection] RETURNS [const: ConstColl] <> ~ INLINE {RETURN coll.class.Freeze[coll]}; frozen, unfrozen: READONLY ROPE; Thaw: PROC [coll: Collection] ~ INLINE {coll.class.Thaw[coll]}; WhereKind: TYPE ~ {any, end, rel}; End: TYPE ~ {front, back}; WhereReln: TYPE ~ {before, after}; Where: TYPE ~ RECORD [SELECT kind: WhereKind FROM any => [], end => [end: End], rel => [elt: Value, reln: WhereReln], ENDCASE _ any[]]; AddElt: PROC [coll: Collection, elt: Value, where: Where _ []] RETURNS [new: BOOL] <> <> <> ~ INLINE {[new, new] _ coll.class.AddColl[coll, CreateSingleton[elt, coll.SpaceOf], where]}; NAddElt: PROC [coll: Collection, elt: Value, where: Where _ []] RETURNS [new: BOOL]; <> AddColl: PROC [coll, other: Collection, where: Where _ []] RETURNS [someNew, allNew: BOOL] <> ~ INLINE {RETURN coll.class.AddColl[coll, other, where]}; RemoveStyle: TYPE ~ {any--don't care--, one, first, last, all}; <> RemoveElt: PROC [coll: Collection, elt: Value, style: RemoveStyle _ any] RETURNS [had: BOOL] ~ INLINE {[had, had] _ coll.class.RemoveColl[coll, CreateSingleton[elt, coll.SpaceOf], style]}; RemoveColl: PROC [coll, other: Collection, style: RemoveStyle _ any] RETURNS [hadSome, hadAll: BOOL] <> ~ INLINE {RETURN coll.class.RemoveColl[coll, other, style]}; Erase: PROC [coll: Collection] ~ INLINE {[] _ coll.RemoveColl[coll]}; SpaceOf: PROC [coll: Collection] RETURNS [Space] <> ~ INLINE {RETURN coll.class.SpaceOf[coll]}; MayDuplicate: PROC [coll: Collection] RETURNS [BOOL] <> ~ INLINE {RETURN [coll.class.mayDuplicate]}; Equal: PROC [a, b: Collection] RETURNS [BOOL]; <> Hash: PROC [coll: Collection] RETURNS [CARDINAL]; Compare: PROC [a, b: Collection] RETURNS [Basics.Comparison]; <> <> Side: TYPE ~ {left, right}; Direction: TYPE ~ {leftToRight, rightToLeft}; OtherDirection: ARRAY Direction OF Direction ~ [rightToLeft, leftToRight]; OtherSide: ARRAY Side OF Side ~ [right, left]; Source: ARRAY Direction OF Side ~ [left, right]; Dest: ARRAY Direction OF Side ~ [right, left]; From: ARRAY Side OF Direction ~ [leftToRight, rightToLeft]; To: ARRAY Side OF Direction ~ [rightToLeft, leftToRight]; BoolPair: TYPE ~ PACKED ARRAY Direction OF BOOL; ReverseBoolPair: PROC [x: BoolPair] RETURNS [BoolPair] ~ INLINE {RETURN [[x[rightToLeft], x[leftToRight]]]}; <> <> <> <> <> < filter.HasMember#CantHasMember>> < filter.Enumerate#CantEnumerate>> < x.mayDuplicate=FALSE>> < setlike enumerator & filter>> < x.mutability#constant>> < x.mutability=variable>> < x.mutability#variable>> < x.mutability=readonly>> < x.mutability=constant>> < Ordered[x]>> < NOT Ordered[x]>> VarColl: TYPE ~ RECORD [Collection] --a variable collection--; nilVarColl: VarColl ~ [nilColl]; MaybeVarColl: TYPE ~ RECORD [found: BOOL, coll: VarColl]; IsVar: PROC [coll: Collection] RETURNS [BOOL] ~ INLINE {RETURN [coll.QuaVar.found]}; AsVar: PROC [coll: Collection] RETURNS [VarColl] ~ INLINE { mv: MaybeVarColl ~ coll.QuaVar; IF NOT mv.found THEN Complain[coll, notVariable]; RETURN [mv.coll]}; notVariable: READONLY ROPE; QuaVar: PROC [coll: Collection] RETURNS [MaybeVarColl] ~ INLINE { IF coll#nilColl AND coll.class.mutability#variable THEN RETURN [[FALSE, [badColl]]]; RETURN [[TRUE, [coll]]]}; UWColl: TYPE ~ RECORD [Collection] --a collection that cannot be changed through this reference, although it might be changeable through some other reference; the `UW' stands for `Unwritable'--; nilUWColl: UWColl ~ [nilColl]; MaybeUWColl: TYPE ~ RECORD [found: BOOL, coll: UWColl]; IsUW: PROC [coll: Collection] RETURNS [BOOL] ~ INLINE {RETURN [coll.QuaUW.found]}; AsUW: PROC [coll: Collection] RETURNS [UWColl] ~ INLINE { mv: MaybeUWColl ~ coll.QuaUW; IF NOT mv.found THEN Complain[coll, writeable]; RETURN [mv.coll]}; writeable: READONLY ROPE; QuaUW: PROC [coll: Collection] RETURNS [MaybeUWColl] ~ INLINE { IF coll#nilColl AND coll.class.mutability=variable THEN RETURN [[FALSE, [badColl]]]; RETURN [[TRUE, [coll]]]}; ConstColl: TYPE ~ RECORD [UWColl] --a constant collection  i.e., a collection value, rather than a collection variable--; nilConstColl: ConstColl ~ [nilUWColl]; MaybeConstColl: TYPE ~ RECORD [found: BOOL, coll: ConstColl]; IsConst: PROC [coll: Collection] RETURNS [BOOL] ~ INLINE {RETURN [coll.QuaConst.found]}; AsConst: PROC [coll: Collection] RETURNS [ConstColl] ~ INLINE { mv: MaybeConstColl ~ coll.QuaConst; IF NOT mv.found THEN Complain[coll, notConstant]; RETURN [mv.coll]}; notConstant: READONLY ROPE; QuaConst: PROC [coll: Collection] RETURNS [MaybeConstColl] ~ INLINE { IF coll#nilColl AND coll.class.mutability#constant THEN RETURN [[FALSE, [[badColl]]]]; RETURN [[TRUE, [[coll]]]]}; Setlike: TYPE ~ Collection; IsSetlike: PROC [coll: Collection] RETURNS [BOOL] ~ INLINE {RETURN [coll.class.mayDuplicate=FALSE]}; Filter: TYPE ~ Collection; UWFilter: TYPE ~ UWColl; ConstFilter: TYPE ~ ConstColl; IsFilter: PROC [coll: Collection] RETURNS [BOOL] ~ INLINE {RETURN [coll.Can[$HasMember]]}; Enumerator: TYPE ~ Collection; IsEnumerator: PROC [coll: Collection] RETURNS [BOOL] ~ INLINE {RETURN [coll.Can[$Enumerate]]}; Set: TYPE ~ Collection; VarSet: TYPE ~ VarColl; UWSet: TYPE ~ UWColl; ConstSet: TYPE ~ ConstColl; nilSet: Set ~ nilColl; nilVarSet: VarSet ~ nilVarColl; nilUWSet: UWSet ~ nilUWColl; nilConstSet: ConstSet ~ nilConstColl; MaybeSet: TYPE ~ RECORD [found: BOOL, coll: Set]; IsSet: PROC [coll: Collection] RETURNS [BOOL] ~ INLINE {RETURN [coll.QuaSet.found]}; AsSet: PROC [coll: Collection] RETURNS [Set] ~ INLINE {RETURN [coll.QuaSet.coll]}; QuaSet: PROC [coll: Collection] RETURNS [MaybeSet] ~ INLINE { IF coll.class.mayDuplicate OR NOT coll.Can[$HasMember] OR NOT coll.Can[$Enumerate] THEN RETURN [[FALSE, badColl]]; RETURN [[TRUE, coll]]}; IsPairColl: PROC [coll: Collection] RETURNS [BOOL] ~ INLINE {RETURN [QuaPairColl[coll].found]}; AsPairColl: PROC [coll: Collection] RETURNS [REF ANY] ~ INLINE {RETURN [QuaPairColl[coll].val]}; QuaPairColl: PROC [coll: Collection] RETURNS [MaybeValue] <> ~ INLINE {RETURN coll.class.QuaPairColl[coll]}; IsIntFn: PROC [coll: Collection, dir: Direction _ leftToRight] RETURNS [BOOL] ~ INLINE {RETURN [QuaIntFn[coll].found]}; AsIntFn: PROC [coll: Collection, dir: Direction _ leftToRight] RETURNS [REF ANY] ~ INLINE {RETURN [QuaIntFn[coll].val]}; QuaIntFn: PROC [coll: Collection, dir: Direction _ leftToRight] RETURNS [MaybeValue] ~ INLINE {RETURN coll.class.QuaIntFn[coll, dir]}; <> emptySet: READONLY ConstSet; passAll: READONLY ConstFilter; CreateSingleton: PROC [elt: Value, space: Space] RETURNS [ConstSet] ~ INLINE {RETURN [[[[GetSingletonClass[space], elt]]]]}; GetSingletonClass: PROC [space: Space] RETURNS [CollectionClass]; NCreateSingleton: PROC [elt: Value, space: Space] RETURNS [ConstSet]; CreateEnumerator: PROC [e: EnumerateClosure, mayDuplicate: BOOL _ TRUE, orderStyle: OrderStyle _ none, mutability: UnwriteableMutability _ readonly] RETURNS [Enumerator]; EnumerateClosure: TYPE ~ RECORD [ Enumerate: PROC [Consume: PROC [val: Value], data: REF ANY], space: Space, Preserve: PROC [val: Value, data: REF ANY] RETURNS [Value] _ NIL, data: REF ANY _ NIL]; CreateFilter: PROC [f: FilterClosure, mutability: UnwriteableMutability _ readonly] RETURNS [Filter] ~ INLINE {RETURN [[filterClasses[mutability], NEW [FilterClosure _ f]]]}; filterClasses: READONLY ARRAY UnwriteableMutability OF CollectionClass; FilterClosure: TYPE ~ RECORD [ Test: PROC [val: Value, data: REF ANY _ NIL] RETURNS [BOOL], space: Space, data: REF ANY _ NIL]; CreateConditional: PROC [cond: Condition, coll: Collection] RETURNS [UWColl]; Condition: TYPE ~ REF ConditionPrivate; ConditionPrivate: TYPE ~ RECORD [ EvalMe: PROC [data: REF ANY] RETURNS [BOOL], data: REF ANY _ NIL ]; Eval: PROC [cond: Condition] RETURNS [BOOL] ~ INLINE {RETURN cond.EvalMe[cond.data]}; CreateList: PROC [vals: LOV, space: Space _ refs, mayDuplicate: BOOL _ TRUE, mutability: Mutability _ variable, orderStyle: OrderStyle _ client, ordering: Ordering _ unordered] RETURNS [Collection]; <> HashSet: TYPE ~ VarSet; IsHash: PROC [Collection] RETURNS [BOOL]; CreateHashSet: PROC [space: Space _ refs] RETURNS [HashSet]; CreateHashRopeSet: PROC [case: BOOL] RETURNS [HashSet] ~ INLINE {RETURN CreateHashSet[ropes[case]]}; CreateHashCopy: PROC [coll: Collection, space: Space _ NIL--NIL means to use the same space as the given collection--] RETURNS [HashSet]; CreateHashSetFromProc: PROC [Produce: PROC [Consume: PROC [Value]], space: Space _ refs] RETURNS [HashSet]; RedBlackSet: TYPE ~ VarSet; CreateRedBlackSet: PROC [space: Space _ refs] RETURNS [RedBlackSet]; CreateRedBlackCopy: PROC [coll: Collection, space: Space _ NIL--NIL means to use the same space as the given collection--] RETURNS [RedBlackSet]; <> Union: PROC [a, b: Collection] RETURNS [Collection]; DisjointUnion: PROC [a, b: Collection] RETURNS [Set]; <> Intersection: PROC [Collection, Collection] RETURNS [Collection]; Difference: PROC [Collection, Collection] RETURNS [Collection]; SymmetricDifference: PROC [a, b: Collection] RETURNS [c: Collection] ~ INLINE {RETURN [Union[a.Difference[b], b.Difference[a]]]}; Negate: PROC [Collection] RETURNS [Collection]; <> PrimitiveAnswer: TYPE ~ {yes, no, pass}; CollectionClass: TYPE ~ REF CollectionClassPrivate; CollectionClassPrivate: TYPE ~ MONITORED RECORD [ Primitive: PROC [coll: Collection, op: ATOM, args: ArgList] RETURNS [PrimitiveAnswer] _ NIL, <> HasMember: PROC [coll: Collection, elt: Value] RETURNS [BOOL] _ NIL, Enumerate: PROC [coll: Collection, Consumer: PROC [elt: Value], bkwd: BOOL] _ NIL, Scan: PROC [coll: Collection, Test: Tester, bkwd: BOOL] RETURNS [MaybeValue] _ NIL, TheElt: PROC [coll: Collection] RETURNS [Value] _ NIL, Extremum: PROC [coll: Collection, bkwd, remove: BOOL] RETURNS [MaybeValue] _ NIL, Get3: PROC [coll: Collection, elt: Value] RETURNS [prev, same, next: MaybeValue] _ NIL, Size: PROC [coll: Collection, limit: LNAT _ LNAT.LAST] RETURNS [LNAT] _ NIL, Copy: PROC [coll: Collection] RETURNS [VarColl] _ NIL, Insulate: PROC [coll: Collection] RETURNS [UWColl] _ NIL, ValueOf: PROC [coll: Collection] RETURNS [ConstColl] _ NIL, Freeze: PROC [coll: Collection] RETURNS [const: ConstColl] _ NIL, Thaw: PROC [coll: Collection] _ NIL, AddColl: PROC [coll, other: Collection, where: Where] RETURNS [someNew, allNew: BOOL] _ NIL, RemoveColl: PROC [coll, other: Collection, style: RemoveStyle] RETURNS [hadSome, hadAll: BOOL] _ NIL, QuaPairColl: PROC [coll: Collection] RETURNS [MaybeValue] _ NIL, QuaIntFn: PROC [coll: Collection, dir: Direction] RETURNS [MaybeValue] _ NIL, SpaceOf: PROC [coll: Collection] RETURNS [Space] _ NIL, OrderingOf: PROC [coll: Collection] RETURNS [Ordering] _ NIL, PreserveValue: PROC [coll: Collection, val: Value] RETURNS [Value] _ NIL, mayDuplicate: BOOL _ TRUE, orderStyle: OrderStyle _ none, mutability: Mutability _ variable, other: Atom.PropList _ NIL, --the canonical expansion slot data: REF ANY _ NIL ]; <> CreateClass: PROC [cp: CollectionClassPrivate, bkwdable: BB _ [TRUE, FALSE], dirable: BoolPair _ [TRUE, TRUE]] RETURNS [CollectionClass]; <> BB: TYPE ~ ARRAY --bkwd--BOOL OF BOOL; DefaultEnumerate: PROC [coll: Collection, Consumer: PROC [elt: Value], bkwd: BOOL]; DefaultScan: PROC [coll: Collection, Test: Tester, bkwd: BOOL] RETURNS [mv: MaybeValue _ noMaybe]; DefaultExtremum: PROC [coll: Collection, bkwd, remove: BOOL] RETURNS [mv: MaybeValue]; DefaultQuaPairColl: PROC [coll: Collection] RETURNS [MaybeValue]; DefaultQuaIntFn: PROC [coll: Collection, dir: Direction] RETURNS [MaybeValue]; SpaceBeRefs, DontKnowSpace: PROC [coll: Collection] RETURNS [Space]; SpaceBeRopes: READONLY ARRAY --case matters--BOOL OF PROC [coll: Collection] RETURNS [Space]; BeOrderedBySpace: PROC [coll: Collection] RETURNS [Ordering]; QMin: PROC [q1, q2: ImplQuality] RETURNS [ImplQuality] ~ INLINE {RETURN[IF q1q2 THEN q1 ELSE q2]}; UpdateCollectionClassOther: PROC [class: CollectionClass, Update: PROC [Atom.PropList] RETURNS [Atom.PropList]]; <> SpacePrivate: TYPE ~ MONITORED RECORD [ Equal: EqualProc _ NIL, Hash: HashProc _ NIL, Compare: CompareProc _ NIL, other: Atom.PropList _ NIL, --the canonical expansion slot data: REF ANY ]; <> <> CantHash: HashProc; CantCompare: CompareProc; EqualProc: TYPE ~ PROC [data: REF ANY, elt1, elt2: Value] RETURNS [BOOL]; HashProc: TYPE ~ PROC [data: REF ANY, elt: Value] RETURNS [CARDINAL]; CompareProc: TYPE ~ PROC [data: REF ANY, elt1, elt2: Value] RETURNS [Basics.Comparison]; EqualAddresses: EqualProc; HashAddress: HashProc; CompareAddresses: CompareProc; HashIntI: PROC [INT] RETURNS [CARDINAL] ~ TRUSTED MACHINE CODE { PrincOps.zXOR }; HashRefI: PROC [REF ANY] RETURNS [CARDINAL] ~ TRUSTED MACHINE CODE { PrincOps.zXOR }; CompareIntI: PROC [a, b: INT] RETURNS [Basics.Comparison] ~ Basics.CompareInt; CompareRefI: PROC [a, b: REF ANY] RETURNS [Basics.Comparison] ~ TRUSTED INLINE {RETURN [Basics.CompareInt[LOOPHOLE[a], LOOPHOLE[b]]]}; UpdateSpaceOther: PROC [s: Space, Update: PROC [Atom.PropList] RETURNS [Atom.PropList]]; }.