AssociationListAggregate(Key, Entry)

aggcat.spad line 2460 [edit on github]

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!: List % -> %

from UnaryRecursiveAggregate 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?: % -> Boolean

from Aggregate

empty: () -> %

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 SetCategory and Record(key: Key, entry: Entry) has Evalable Record(key: Key, entry: Entry)

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 SetCategory and Record(key: Key, entry: Entry) has Evalable Record(key: Key, entry: Entry)

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 SetCategory and Record(key: Key, entry: Entry) has Evalable Record(key: Key, entry: Entry)

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 SetCategory and Record(key: Key, entry: Entry) has Evalable Record(key: Key, entry: Entry)

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: % -> Entry if Entry has OrderedSet

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: (%, %) -> % if Record(key: Key, entry: Entry) has OrderedSet

from OrderedSet

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

from HomogeneousAggregate Entry

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

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

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: % -> 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)

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 SetCategory and Record(key: Key, entry: Entry) has Evalable Record(key: Key, entry: Entry)

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 SetCategory and Record(key: Key, entry: Entry) has Evalable Record(key: Key, entry: Entry)

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)