AssociationListAggregate(Key, Entry)

aggcat.spad line 2502 [edit on github]

• Key : SetCategory
• Entry : Type

An association list is a list of key entry pairs which may be viewed as a table. It is a poor mans version of a table: searching for a key is a linear operation.

# : % -> NonNegativeInteger

from Aggregate

< : (%, %) -> Boolean if Record(key : Key, entry : Entry) has OrderedSet

from PartialOrder

<= : (%, %) -> Boolean if Record(key : Key, entry : Entry) has OrderedSet

from PartialOrder

= : (%, %) -> Boolean if Entry has BasicType or Record(key : Key, entry : Entry) has BasicType

from BasicType

> : (%, %) -> Boolean if Record(key : Key, entry : Entry) has OrderedSet

from PartialOrder

>= : (%, %) -> Boolean if Record(key : Key, entry : Entry) has OrderedSet

from PartialOrder

any? : (Mapping(Boolean, Entry), %) -> Boolean

from HomogeneousAggregate(Entry)

any? : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> Boolean

from HomogeneousAggregate(Record(key : Key, entry : Entry))

assoc : (Key, %) -> Union(Record(key : Key, entry : Entry), "failed")

assoc(k, u) returns the element x in association list u stored with key k, or "failed" if u has no key k.

child? : (%, %) -> Boolean if Record(key : Key, entry : Entry) has BasicType

from RecursiveAggregate(Record(key : Key, entry : Entry))

children : % -> List(%)

from RecursiveAggregate(Record(key : Key, entry : Entry))

coerce : % -> OutputForm if Entry has CoercibleTo(OutputForm) or Record(key : Key, entry : Entry) has CoercibleTo(OutputForm)

from CoercibleTo(OutputForm)

concat : (%, %) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

concat : (%, Record(key : Key, entry : Entry)) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

concat : List(%) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

concat : (Record(key : Key, entry : Entry), %) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

concat! : (%, %) -> %

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

concat! : (%, Record(key : Key, entry : Entry)) -> %

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

concat! : List(%) -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

construct : List(Record(key : Key, entry : Entry)) -> %

from Collection(Record(key : Key, entry : Entry))

convert : % -> InputForm if Record(key : Key, entry : Entry) has ConvertibleTo(InputForm)

from ConvertibleTo(InputForm)

copy : % -> %

from Aggregate

copyInto! : (%, %, Integer) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

count : (Entry, %) -> NonNegativeInteger if Entry has BasicType

from HomogeneousAggregate(Entry)

count : (Mapping(Boolean, Entry), %) -> NonNegativeInteger

from HomogeneousAggregate(Entry)

count : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> NonNegativeInteger

from HomogeneousAggregate(Record(key : Key, entry : Entry))

count : (Record(key : Key, entry : Entry), %) -> NonNegativeInteger if Record(key : Key, entry : Entry) has BasicType

from HomogeneousAggregate(Record(key : Key, entry : Entry))

cycleEntry : % -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

cycleLength : % -> NonNegativeInteger

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

cycleSplit! : % -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

cycleTail : % -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

cyclic? : % -> Boolean

from RecursiveAggregate(Record(key : Key, entry : Entry))

delete : (%, Integer) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

delete : (%, UniversalSegment(Integer)) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

delete! : (%, Integer) -> %

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

delete! : (%, UniversalSegment(Integer)) -> %

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

dictionary : () -> %

from DictionaryOperations(Record(key : Key, entry : Entry))

dictionary : List(Record(key : Key, entry : Entry)) -> %

from DictionaryOperations(Record(key : Key, entry : Entry))

distance : (%, %) -> Integer

from RecursiveAggregate(Record(key : Key, entry : Entry))

elt : (%, "rest") -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

elt : (%, UniversalSegment(Integer)) -> %

from Eltable(UniversalSegment(Integer), %)

elt : (%, Key) -> Entry

from Eltable(Key, Entry)

elt : (%, Key, Entry) -> Entry

from EltableAggregate(Key, Entry)

elt : (%, "first") -> Record(key : Key, entry : Entry)

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

elt : (%, "last") -> Record(key : Key, entry : Entry)

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

elt : (%, "value") -> Record(key : Key, entry : Entry)

from RecursiveAggregate(Record(key : Key, entry : Entry))

elt : (%, Integer) -> Record(key : Key, entry : Entry)

from Eltable(Integer, Record(key : Key, entry : Entry))

elt : (%, Integer, Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from EltableAggregate(Integer, Record(key : Key, entry : Entry))

empty : () -> %

from Aggregate

empty? : % -> Boolean

from Aggregate

entries : % -> List(Entry)

from IndexedAggregate(Key, Entry)

entries : % -> List(Record(key : Key, entry : Entry))

from IndexedAggregate(Integer, Record(key : Key, entry : Entry))

entry? : (Entry, %) -> Boolean if Entry has BasicType

from IndexedAggregate(Key, Entry)

entry? : (Record(key : Key, entry : Entry), %) -> Boolean if Record(key : Key, entry : Entry) has BasicType

from IndexedAggregate(Integer, Record(key : Key, entry : Entry))

eq? : (%, %) -> Boolean

from Aggregate

eval : (%, Entry, Entry) -> % if Entry has SetCategory and Entry has Evalable(Entry)

from InnerEvalable(Entry, Entry)

eval : (%, Equation(Entry)) -> % if Entry has SetCategory and Entry has Evalable(Entry)

from Evalable(Entry)

eval : (%, Equation(Record(key : Key, entry : Entry))) -> % if Record(key : Key, entry : Entry) has Evalable(Record(key : Key, entry : Entry)) and Record(key : Key, entry : Entry) has SetCategory

from Evalable(Record(key : Key, entry : Entry))

eval : (%, List(Entry), List(Entry)) -> % if Entry has SetCategory and Entry has Evalable(Entry)

from InnerEvalable(Entry, Entry)

eval : (%, List(Equation(Entry))) -> % if Entry has SetCategory and Entry has Evalable(Entry)

from Evalable(Entry)

eval : (%, List(Equation(Record(key : Key, entry : Entry)))) -> % if Record(key : Key, entry : Entry) has Evalable(Record(key : Key, entry : Entry)) and Record(key : Key, entry : Entry) has SetCategory

from Evalable(Record(key : Key, entry : Entry))

eval : (%, List(Record(key : Key, entry : Entry)), List(Record(key : Key, entry : Entry))) -> % if Record(key : Key, entry : Entry) has Evalable(Record(key : Key, entry : Entry)) and Record(key : Key, entry : Entry) has SetCategory

from InnerEvalable(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry))

eval : (%, Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)) -> % if Record(key : Key, entry : Entry) has Evalable(Record(key : Key, entry : Entry)) and Record(key : Key, entry : Entry) has SetCategory

from InnerEvalable(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry))

every? : (Mapping(Boolean, Entry), %) -> Boolean

from HomogeneousAggregate(Entry)

every? : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> Boolean

from HomogeneousAggregate(Record(key : Key, entry : Entry))

explicitlyFinite? : % -> Boolean

from StreamAggregate(Record(key : Key, entry : Entry))

extract! : % -> Record(key : Key, entry : Entry)

from BagAggregate(Record(key : Key, entry : Entry))

fill! : (%, Entry) -> %

from IndexedAggregate(Key, Entry)

fill! : (%, Record(key : Key, entry : Entry)) -> %

from IndexedAggregate(Integer, Record(key : Key, entry : Entry))

find : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> Union(Record(key : Key, entry : Entry), "failed")

from Collection(Record(key : Key, entry : Entry))

first : (%, NonNegativeInteger) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

first : % -> Entry if Key has OrderedSet

from IndexedAggregate(Key, Entry)

first : % -> Record(key : Key, entry : Entry)

from IndexedAggregate(Integer, Record(key : Key, entry : Entry))

hash : % -> SingleInteger if Record(key : Key, entry : Entry) has Hashable

from Hashable

hashUpdate! : (HashState, %) -> HashState if Record(key : Key, entry : Entry) has Hashable

from Hashable

index? : (Key, %) -> Boolean

from IndexedAggregate(Key, Entry)

index? : (Integer, %) -> Boolean

from IndexedAggregate(Integer, Record(key : Key, entry : Entry))

indices : % -> List(Key)

from IndexedAggregate(Key, Entry)

indices : % -> List(Integer)

from IndexedAggregate(Integer, Record(key : Key, entry : Entry))

insert : (%, %, Integer) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

insert : (Record(key : Key, entry : Entry), %, Integer) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

insert! : (%, %, Integer) -> %

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

insert! : (Record(key : Key, entry : Entry), %) -> %

from BagAggregate(Record(key : Key, entry : Entry))

insert! : (Record(key : Key, entry : Entry), %, Integer) -> %

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

inspect : % -> Record(key : Key, entry : Entry)

from BagAggregate(Record(key : Key, entry : Entry))

key? : (Key, %) -> Boolean

from KeyedDictionary(Key, Entry)

keys : % -> List(Key)

from KeyedDictionary(Key, Entry)

last : (%, NonNegativeInteger) -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

last : % -> Record(key : Key, entry : Entry)

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

latex : % -> String if Entry has SetCategory or Record(key : Key, entry : Entry) has SetCategory

from SetCategory

leaf? : % -> Boolean

from RecursiveAggregate(Record(key : Key, entry : Entry))

leaves : % -> List(Record(key : Key, entry : Entry))

from RecursiveAggregate(Record(key : Key, entry : Entry))

leftTrim : (%, Record(key : Key, entry : Entry)) -> % if Record(key : Key, entry : Entry) has BasicType

from LinearAggregate(Record(key : Key, entry : Entry))

less? : (%, NonNegativeInteger) -> Boolean

from Aggregate

list : Record(key : Key, entry : Entry) -> %

from ListAggregate(Record(key : Key, entry : Entry))

map : (Mapping(Entry, Entry), %) -> %

from HomogeneousAggregate(Entry)

map : (Mapping(Entry, Entry, Entry), %, %) -> %

from TableAggregate(Key, Entry)

map : (Mapping(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %) -> %

from HomogeneousAggregate(Record(key : Key, entry : Entry))

map : (Mapping(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %, %) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

map! : (Mapping(Entry, Entry), %) -> %

from HomogeneousAggregate(Entry)

map! : (Mapping(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %) -> %

from HomogeneousAggregate(Record(key : Key, entry : Entry))

max : (%, %) -> % if Record(key : Key, entry : Entry) has OrderedSet

from OrderedSet

max : % -> Entry if Entry has OrderedSet

from HomogeneousAggregate(Entry)

max : (Mapping(Boolean, Entry, Entry), %) -> Entry

from HomogeneousAggregate(Entry)

max : % -> Record(key : Key, entry : Entry) if Record(key : Key, entry : Entry) has OrderedSet

from HomogeneousAggregate(Record(key : Key, entry : Entry))

max : (Mapping(Boolean, Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %) -> Record(key : Key, entry : Entry)

from HomogeneousAggregate(Record(key : Key, entry : Entry))

maxIndex : % -> Key if Key has OrderedSet

from IndexedAggregate(Key, Entry)

maxIndex : % -> Integer

from IndexedAggregate(Integer, Record(key : Key, entry : Entry))

member? : (Entry, %) -> Boolean if Entry has BasicType

from HomogeneousAggregate(Entry)

member? : (Record(key : Key, entry : Entry), %) -> Boolean if Record(key : Key, entry : Entry) has BasicType

from HomogeneousAggregate(Record(key : Key, entry : Entry))

members : % -> List(Entry)

from HomogeneousAggregate(Entry)

members : % -> List(Record(key : Key, entry : Entry))

from HomogeneousAggregate(Record(key : Key, entry : Entry))

merge : (%, %) -> % if Record(key : Key, entry : Entry) has OrderedSet

from LinearAggregate(Record(key : Key, entry : Entry))

merge : (Mapping(Boolean, Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %, %) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

merge! : (%, %) -> % if Record(key : Key, entry : Entry) has OrderedSet

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

merge! : (Mapping(Boolean, Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %, %) -> %

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

min : (%, %) -> % if Record(key : Key, entry : Entry) has OrderedSet

from OrderedSet

min : % -> Entry if Entry has OrderedSet

from HomogeneousAggregate(Entry)

min : % -> Record(key : Key, entry : Entry) if Record(key : Key, entry : Entry) has OrderedSet

from HomogeneousAggregate(Record(key : Key, entry : Entry))

minIndex : % -> Key if Key has OrderedSet

from IndexedAggregate(Key, Entry)

minIndex : % -> Integer

from IndexedAggregate(Integer, Record(key : Key, entry : Entry))

more? : (%, NonNegativeInteger) -> Boolean

from Aggregate

new : (NonNegativeInteger, Record(key : Key, entry : Entry)) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

node? : (%, %) -> Boolean if Record(key : Key, entry : Entry) has BasicType

from RecursiveAggregate(Record(key : Key, entry : Entry))

nodes : % -> List(%)

from RecursiveAggregate(Record(key : Key, entry : Entry))

parts : % -> List(Entry)

from HomogeneousAggregate(Entry)

parts : % -> List(Record(key : Key, entry : Entry))

from HomogeneousAggregate(Record(key : Key, entry : Entry))

position : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> Integer

from LinearAggregate(Record(key : Key, entry : Entry))

position : (Record(key : Key, entry : Entry), %) -> Integer if Record(key : Key, entry : Entry) has BasicType

from LinearAggregate(Record(key : Key, entry : Entry))

position : (Record(key : Key, entry : Entry), %, Integer) -> Integer if Record(key : Key, entry : Entry) has BasicType

from LinearAggregate(Record(key : Key, entry : Entry))

possiblyInfinite? : % -> Boolean

from StreamAggregate(Record(key : Key, entry : Entry))

qelt : (%, Key) -> Entry

from EltableAggregate(Key, Entry)

qelt : (%, Integer) -> Record(key : Key, entry : Entry)

from EltableAggregate(Integer, Record(key : Key, entry : Entry))

qsetelt! : (%, Key, Entry) -> Entry

from EltableAggregate(Key, Entry)

qsetelt! : (%, Integer, Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from EltableAggregate(Integer, Record(key : Key, entry : Entry))

qsetfirst! : (%, Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

qsetrest! : (%, %) -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

reduce : (Mapping(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %) -> Record(key : Key, entry : Entry)

from Collection(Record(key : Key, entry : Entry))

reduce : (Mapping(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %, Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from Collection(Record(key : Key, entry : Entry))

reduce : (Mapping(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %, Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry) if Record(key : Key, entry : Entry) has BasicType

from Collection(Record(key : Key, entry : Entry))

remove : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> %

from Collection(Record(key : Key, entry : Entry))

remove : (Record(key : Key, entry : Entry), %) -> % if Record(key : Key, entry : Entry) has BasicType

from Collection(Record(key : Key, entry : Entry))

remove! : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> %

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

remove! : (Record(key : Key, entry : Entry), %) -> % if Record(key : Key, entry : Entry) has BasicType

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

remove! : (Key, %) -> Union(Entry, "failed")

from KeyedDictionary(Key, Entry)

removeDuplicates : % -> % if Record(key : Key, entry : Entry) has BasicType

from Collection(Record(key : Key, entry : Entry))

removeDuplicates! : % -> % if Record(key : Key, entry : Entry) has BasicType

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

rest : % -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

rest : (%, NonNegativeInteger) -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

reverse : % -> %

from LinearAggregate(Record(key : Key, entry : Entry))

reverse! : % -> %

from LinearAggregate(Record(key : Key, entry : Entry))

rightTrim : (%, Record(key : Key, entry : Entry)) -> % if Record(key : Key, entry : Entry) has BasicType

from LinearAggregate(Record(key : Key, entry : Entry))

sample : () -> %

from Aggregate

search : (Key, %) -> Union(Entry, "failed")

from KeyedDictionary(Key, Entry)

second : % -> Record(key : Key, entry : Entry)

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

select : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> %

from Collection(Record(key : Key, entry : Entry))

select! : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> %

from ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

setchildren! : (%, List(%)) -> %

from RecursiveAggregate(Record(key : Key, entry : Entry))

setelt! : (%, "rest", %) -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

setelt! : (%, Key, Entry) -> Entry

from TableAggregate(Key, Entry)

setelt! : (%, "first", Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

setelt! : (%, "last", Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

setelt! : (%, "value", Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from RecursiveAggregate(Record(key : Key, entry : Entry))

setelt! : (%, Integer, Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from EltableAggregate(Integer, Record(key : Key, entry : Entry))

setelt! : (%, UniversalSegment(Integer), Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from LinearAggregate(Record(key : Key, entry : Entry))

setfirst! : (%, Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

setlast! : (%, Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

setrest! : (%, %) -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

setvalue! : (%, Record(key : Key, entry : Entry)) -> Record(key : Key, entry : Entry)

from RecursiveAggregate(Record(key : Key, entry : Entry))

size? : (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller? : (%, %) -> Boolean if Record(key : Key, entry : Entry) has Comparable

from Comparable

sort : % -> % if Record(key : Key, entry : Entry) has OrderedSet

from LinearAggregate(Record(key : Key, entry : Entry))

sort : (Mapping(Boolean, Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

sort! : % -> % if Record(key : Key, entry : Entry) has OrderedSet

from LinearAggregate(Record(key : Key, entry : Entry))

sort! : (Mapping(Boolean, Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %) -> %

from LinearAggregate(Record(key : Key, entry : Entry))

sorted? : % -> Boolean if Record(key : Key, entry : Entry) has OrderedSet

from LinearAggregate(Record(key : Key, entry : Entry))

sorted? : (Mapping(Boolean, Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %) -> Boolean

from LinearAggregate(Record(key : Key, entry : Entry))

split! : (%, NonNegativeInteger) -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

swap! : (%, Key, Key) -> Void

from IndexedAggregate(Key, Entry)

swap! : (%, Integer, Integer) -> Void

from IndexedAggregate(Integer, Record(key : Key, entry : Entry))

table : () -> %

from TableAggregate(Key, Entry)

table : List(Record(key : Key, entry : Entry)) -> %

from TableAggregate(Key, Entry)

tail : % -> %

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

third : % -> Record(key : Key, entry : Entry)

from UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

trim : (%, Record(key : Key, entry : Entry)) -> % if Record(key : Key, entry : Entry) has BasicType

from LinearAggregate(Record(key : Key, entry : Entry))

value : % -> Record(key : Key, entry : Entry)

from RecursiveAggregate(Record(key : Key, entry : Entry))

~= : (%, %) -> Boolean if Entry has BasicType or Record(key : Key, entry : Entry) has BasicType

from BasicType

TableAggregate(Key, Entry)

DictionaryOperations(Record(key : Key, entry : Entry))

ConvertibleTo(InputForm)

shallowlyMutable

IndexedAggregate(Integer, Record(key : Key, entry : Entry))

IndexedAggregate(Key, Entry)

Evalable(Record(key : Key, entry : Entry))

FiniteLinearAggregate(Record(key : Key, entry : Entry))

ExtensibleLinearAggregate(Record(key : Key, entry : Entry))

UnaryRecursiveAggregate(Record(key : Key, entry : Entry))

OrderedSet

Dictionary(Record(key : Key, entry : Entry))

RecursiveAggregate(Record(key : Key, entry : Entry))

StreamAggregate(Record(key : Key, entry : Entry))

finiteAggregate

InnerEvalable(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry))

Evalable(Entry)

LinearAggregate(Record(key : Key, entry : Entry))

PartialOrder

Aggregate

Eltable(UniversalSegment(Integer), %)

EltableAggregate(Integer, Record(key : Key, entry : Entry))

BagAggregate(Record(key : Key, entry : Entry))

Comparable

Hashable

Eltable(Integer, Record(key : Key, entry : Entry))

Collection(Record(key : Key, entry : Entry))

CoercibleTo(OutputForm)

HomogeneousAggregate(Record(key : Key, entry : Entry))

EltableAggregate(Key, Entry)

KeyedDictionary(Key, Entry)

BasicType

InnerEvalable(Entry, Entry)

SetCategory

Eltable(Key, Entry)

ListAggregate(Record(key : Key, entry : Entry))

HomogeneousAggregate(Entry)