AssociationListAggregate(Key, Entry)ΒΆ

aggcat.spad line 2383

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
~=: (%, %) -> Boolean if Entry has BasicType or Record(key: Key, entry: Entry) has BasicType
from BasicType
any?: (Entry -> Boolean, %) -> Boolean
from HomogeneousAggregate Entry
any?: (Record(key: Key, entry: Entry) -> Boolean, %) -> 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 ExtensibleLinearAggregate Record(key: Key, entry: Entry)
concat!: (%, Record(key: Key, entry: Entry)) -> %
from ExtensibleLinearAggregate Record(key: Key, entry: Entry)
concat: (%, %) -> %
from LinearAggregate Record(key: Key, entry: Entry)
concat: (%, Record(key: Key, entry: Entry)) -> %
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)
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 -> Boolean, %) -> NonNegativeInteger
from HomogeneousAggregate Entry
count: (Entry, %) -> NonNegativeInteger if Entry has BasicType
from HomogeneousAggregate Entry
count: (Record(key: Key, entry: Entry) -> Boolean, %) -> 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 ExtensibleLinearAggregate Record(key: Key, entry: Entry)
delete!: (%, UniversalSegment Integer) -> %
from ExtensibleLinearAggregate Record(key: Key, entry: Entry)
delete: (%, Integer) -> %
from LinearAggregate Record(key: Key, entry: Entry)
delete: (%, UniversalSegment Integer) -> %
from LinearAggregate 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: (%, first) -> Record(key: Key, entry: Entry)
from UnaryRecursiveAggregate 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))
elt: (%, Key) -> Entry
from Eltable(Key, Entry)
elt: (%, Key, Entry) -> Entry
from EltableAggregate(Key, Entry)
elt: (%, last) -> Record(key: Key, entry: Entry)
from UnaryRecursiveAggregate Record(key: Key, entry: Entry)
elt: (%, rest) -> %
from UnaryRecursiveAggregate Record(key: Key, entry: Entry)
elt: (%, UniversalSegment Integer) -> %
from Eltable(UniversalSegment Integer, %)
elt: (%, value) -> Record(key: Key, entry: Entry)
from RecursiveAggregate 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?: (Entry -> Boolean, %) -> Boolean
from HomogeneousAggregate Entry
every?: (Record(key: Key, entry: Entry) -> Boolean, %) -> 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: (Record(key: Key, entry: Entry) -> Boolean, %) -> Union(Record(key: Key, entry: Entry), failed)
from Collection 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))
first: (%, NonNegativeInteger) -> %
from LinearAggregate Record(key: Key, entry: Entry)
hash: % -> SingleInteger if Entry has SetCategory or Record(key: Key, entry: Entry) has SetCategory
from SetCategory
hashUpdate!: (HashState, %) -> HashState if Entry has SetCategory or Record(key: Key, entry: Entry) has SetCategory
from SetCategory
index?: (Integer, %) -> Boolean
from IndexedAggregate(Integer, Record(key: Key, entry: Entry))
index?: (Key, %) -> Boolean
from IndexedAggregate(Key, Entry)
indices: % -> List Integer
from IndexedAggregate(Integer, Record(key: Key, entry: Entry))
indices: % -> List Key
from IndexedAggregate(Key, 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)
insert: (%, %, Integer) -> %
from LinearAggregate Record(key: Key, entry: Entry)
insert: (Record(key: Key, entry: Entry), %, Integer) -> %
from LinearAggregate 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: % -> Record(key: Key, entry: Entry)
from UnaryRecursiveAggregate Record(key: Key, entry: Entry)
last: (%, NonNegativeInteger) -> %
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!: (Entry -> Entry, %) -> %
from HomogeneousAggregate Entry
map!: (Record(key: Key, entry: Entry) -> Record(key: Key, entry: Entry), %) -> %
from HomogeneousAggregate Record(key: Key, entry: Entry)
map: ((Entry, Entry) -> Entry, %, %) -> %
from TableAggregate(Key, Entry)
map: ((Record(key: Key, entry: Entry), Record(key: Key, entry: Entry)) -> Record(key: Key, entry: Entry), %, %) -> %
from LinearAggregate Record(key: Key, entry: Entry)
map: (Entry -> Entry, %) -> %
from HomogeneousAggregate Entry
map: (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
maxIndex: % -> Integer
from IndexedAggregate(Integer, Record(key: Key, entry: Entry))
maxIndex: % -> Key if Key has OrderedSet
from IndexedAggregate(Key, 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 ExtensibleLinearAggregate Record(key: Key, entry: Entry)
merge!: ((Record(key: Key, entry: Entry), Record(key: Key, entry: Entry)) -> Boolean, %, %) -> %
from ExtensibleLinearAggregate Record(key: Key, entry: Entry)
merge: (%, %) -> % if Record(key: Key, entry: Entry) has OrderedSet
from LinearAggregate Record(key: Key, entry: Entry)
merge: ((Record(key: Key, entry: Entry), Record(key: Key, entry: Entry)) -> Boolean, %, %) -> %
from LinearAggregate Record(key: Key, entry: Entry)
min: (%, %) -> % if Record(key: Key, entry: Entry) has OrderedSet
from OrderedSet
minIndex: % -> Integer
from IndexedAggregate(Integer, Record(key: Key, entry: Entry))
minIndex: % -> Key if Key has OrderedSet
from IndexedAggregate(Key, 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: (Record(key: Key, entry: Entry) -> Boolean, %) -> 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: (%, Integer) -> Record(key: Key, entry: Entry)
from EltableAggregate(Integer, Record(key: Key, entry: Entry))
qelt: (%, Key) -> 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))
qsetelt!: (%, Key, Entry) -> Entry
from EltableAggregate(Key, 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: ((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: ((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: ((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!: (Key, %) -> Union(Entry, failed)
from KeyedDictionary(Key, Entry)
remove!: (Record(key: Key, entry: Entry) -> Boolean, %) -> %
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: (Record(key: Key, entry: Entry) -> Boolean, %) -> %
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)
removeDuplicates!: % -> % if Record(key: Key, entry: Entry) has BasicType
from ExtensibleLinearAggregate Record(key: Key, entry: Entry)
removeDuplicates: % -> % if Record(key: Key, entry: Entry) has BasicType
from Collection 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!: (Record(key: Key, entry: Entry) -> Boolean, %) -> %
from ExtensibleLinearAggregate Record(key: Key, entry: Entry)
select: (Record(key: Key, entry: Entry) -> Boolean, %) -> %
from Collection Record(key: Key, entry: Entry)
setchildren!: (%, List %) -> %
from RecursiveAggregate Record(key: Key, entry: Entry)
setelt!: (%, first, Record(key: Key, entry: Entry)) -> Record(key: Key, entry: Entry)
from UnaryRecursiveAggregate 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!: (%, Key, Entry) -> Entry
from TableAggregate(Key, Entry)
setelt!: (%, last, Record(key: Key, entry: Entry)) -> Record(key: Key, entry: Entry)
from UnaryRecursiveAggregate Record(key: Key, entry: Entry)
setelt!: (%, rest, %) -> %
from UnaryRecursiveAggregate 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)
setelt!: (%, value, Record(key: Key, entry: Entry)) -> Record(key: Key, entry: Entry)
from RecursiveAggregate 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!: ((Record(key: Key, entry: Entry), Record(key: Key, entry: Entry)) -> Boolean, %) -> %
from LinearAggregate Record(key: Key, entry: Entry)
sort: % -> % if Record(key: Key, entry: Entry) has OrderedSet
from LinearAggregate Record(key: Key, entry: Entry)
sort: ((Record(key: Key, entry: Entry), Record(key: Key, entry: Entry)) -> Boolean, %) -> %
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?: ((Record(key: Key, entry: Entry), Record(key: Key, entry: Entry)) -> Boolean, %) -> Boolean
from LinearAggregate Record(key: Key, entry: Entry)
split!: (%, NonNegativeInteger) -> %
from UnaryRecursiveAggregate Record(key: Key, entry: Entry)
swap!: (%, Integer, Integer) -> Void
from IndexedAggregate(Integer, Record(key: Key, entry: Entry))
swap!: (%, Key, Key) -> Void
from IndexedAggregate(Key, 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)

Aggregate

BagAggregate Record(key: Key, entry: Entry)

BasicType if Entry has BasicType or Record(key: Key, entry: Entry) has BasicType

CoercibleTo OutputForm if Entry has CoercibleTo OutputForm or Record(key: Key, entry: Entry) has CoercibleTo OutputForm

Collection Record(key: Key, entry: Entry)

Comparable if Record(key: Key, entry: Entry) has Comparable

ConvertibleTo InputForm if Record(key: Key, entry: Entry) has ConvertibleTo InputForm

Dictionary Record(key: Key, entry: Entry)

DictionaryOperations Record(key: Key, entry: Entry)

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

Eltable(Key, Entry)

Eltable(UniversalSegment Integer, %)

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

EltableAggregate(Key, Entry)

Evalable Entry if Entry has SetCategory and Entry has Evalable Entry

Evalable 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

ExtensibleLinearAggregate Record(key: Key, entry: Entry)

finiteAggregate

FiniteLinearAggregate Record(key: Key, entry: Entry)

HomogeneousAggregate Entry

HomogeneousAggregate Record(key: Key, entry: Entry)

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

IndexedAggregate(Key, Entry)

InnerEvalable(Entry, Entry) if Entry has SetCategory and Entry has Evalable Entry

InnerEvalable(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

KeyedDictionary(Key, Entry)

LinearAggregate Record(key: Key, entry: Entry)

ListAggregate Record(key: Key, entry: Entry)

OrderedSet if Record(key: Key, entry: Entry) has OrderedSet

PartialOrder if Record(key: Key, entry: Entry) has OrderedSet

RecursiveAggregate Record(key: Key, entry: Entry)

SetCategory if Entry has SetCategory or Record(key: Key, entry: Entry) has SetCategory

shallowlyMutable

StreamAggregate Record(key: Key, entry: Entry)

TableAggregate(Key, Entry)

UnaryRecursiveAggregate Record(key: Key, entry: Entry)