TableAggregate(Key, Entry)

aggcat.spad line 910 [edit on github]

A table aggregate is a model of a table, i.e. a discrete many-to-one mapping from keys to entries.

# : % -> NonNegativeInteger if % has finiteAggregate
from Aggregate
= : (%, %) -> Boolean if Entry has SetCategory or Record(key : Key, entry : Entry) has SetCategory or Record(key : Key, entry : Entry) has BasicType and % has finiteAggregate or Entry has BasicType and % has finiteAggregate
from BasicType
any? : (Mapping(Boolean, Entry), %) -> Boolean if % has finiteAggregate
from HomogeneousAggregate(Entry)
any? : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> Boolean if % has finiteAggregate
from HomogeneousAggregate(Record(key : Key, entry : Entry))
coerce : % -> OutputForm if Entry has CoercibleTo(OutputForm) or Record(key : Key, entry : Entry) has CoercibleTo(OutputForm)
from CoercibleTo(OutputForm)
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
count : (Entry, %) -> NonNegativeInteger if Entry has BasicType and % has finiteAggregate
from HomogeneousAggregate(Entry)
count : (Mapping(Boolean, Entry), %) -> NonNegativeInteger if % has finiteAggregate
from HomogeneousAggregate(Entry)
count : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> NonNegativeInteger if % has finiteAggregate
from HomogeneousAggregate(Record(key : Key, entry : Entry))
count : (Record(key : Key, entry : Entry), %) -> NonNegativeInteger if Record(key : Key, entry : Entry) has BasicType and % has finiteAggregate
from HomogeneousAggregate(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))
elt : (%, Key) -> Entry
from Eltable(Key, Entry)
elt : (%, Key, Entry) -> Entry
from EltableAggregate(Key, Entry)
empty : () -> %
from Aggregate
empty? : % -> Boolean
from Aggregate
entries : % -> List(Entry)
from IndexedAggregate(Key, Entry)
entry? : (Entry, %) -> Boolean if Entry has BasicType and % has finiteAggregate
from IndexedAggregate(Key, 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 if % has finiteAggregate
from HomogeneousAggregate(Entry)
every? : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> Boolean if % has finiteAggregate
from HomogeneousAggregate(Record(key : Key, entry : Entry))
extract! : % -> Record(key : Key, entry : Entry)
from BagAggregate(Record(key : Key, entry : Entry))
fill! : (%, Entry) -> %
from IndexedAggregate(Key, Entry)
find : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> Union(Record(key : Key, entry : Entry), "failed")
from Collection(Record(key : Key, entry : Entry))
first : % -> Entry if Key has OrderedSet
from IndexedAggregate(Key, Entry)
index? : (Key, %) -> Boolean
from IndexedAggregate(Key, Entry)
indices : % -> List(Key)
from IndexedAggregate(Key, Entry)
insert! : (Record(key : Key, entry : Entry), %) -> %
from BagAggregate(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)
latex : % -> String if Entry has SetCategory or Record(key : Key, entry : Entry) has SetCategory
from SetCategory
less? : (%, NonNegativeInteger) -> Boolean
from Aggregate
map : (Mapping(Entry, Entry), %) -> %
from HomogeneousAggregate(Entry)
map : (Mapping(Entry, Entry, Entry), %, %) -> %

map(fn, t1, t2) creates a new table t from given tables t1 and t2 with elements fn(x, y) where x and y are corresponding elements from t1 and t2 respectively.

map : (Mapping(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %) -> %
from HomogeneousAggregate(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 : % -> Entry if Entry has OrderedSet and % has finiteAggregate
from HomogeneousAggregate(Entry)
max : (Mapping(Boolean, Entry, Entry), %) -> Entry if % has finiteAggregate
from HomogeneousAggregate(Entry)
max : % -> Record(key : Key, entry : Entry) if Record(key : Key, entry : Entry) has OrderedSet and % has finiteAggregate
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) if % has finiteAggregate
from HomogeneousAggregate(Record(key : Key, entry : Entry))
maxIndex : % -> Key if Key has OrderedSet
from IndexedAggregate(Key, Entry)
member? : (Entry, %) -> Boolean if Entry has BasicType and % has finiteAggregate
from HomogeneousAggregate(Entry)
member? : (Record(key : Key, entry : Entry), %) -> Boolean if Record(key : Key, entry : Entry) has BasicType and % has finiteAggregate
from HomogeneousAggregate(Record(key : Key, entry : Entry))
members : % -> List(Entry) if % has finiteAggregate
from HomogeneousAggregate(Entry)
members : % -> List(Record(key : Key, entry : Entry)) if % has finiteAggregate
from HomogeneousAggregate(Record(key : Key, entry : Entry))
min : % -> Entry if Entry has OrderedSet and % has finiteAggregate
from HomogeneousAggregate(Entry)
min : % -> Record(key : Key, entry : Entry) if Record(key : Key, entry : Entry) has OrderedSet and % has finiteAggregate
from HomogeneousAggregate(Record(key : Key, entry : Entry))
minIndex : % -> Key if Key has OrderedSet
from IndexedAggregate(Key, Entry)
more? : (%, NonNegativeInteger) -> Boolean
from Aggregate
parts : % -> List(Entry) if % has finiteAggregate
from HomogeneousAggregate(Entry)
parts : % -> List(Record(key : Key, entry : Entry)) if % has finiteAggregate
from HomogeneousAggregate(Record(key : Key, entry : Entry))
qelt : (%, Key) -> Entry
from EltableAggregate(Key, Entry)
qsetelt! : (%, Key, Entry) -> Entry
from EltableAggregate(Key, Entry)
reduce : (Mapping(Record(key : Key, entry : Entry), Record(key : Key, entry : Entry), Record(key : Key, entry : Entry)), %) -> Record(key : Key, entry : Entry) if % has finiteAggregate
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) if % has finiteAggregate
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 and % has finiteAggregate
from Collection(Record(key : Key, entry : Entry))
remove : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> % if % has finiteAggregate
from Collection(Record(key : Key, entry : Entry))
remove : (Record(key : Key, entry : Entry), %) -> % if Record(key : Key, entry : Entry) has BasicType and % has finiteAggregate
from Collection(Record(key : Key, entry : Entry))
remove! : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> % if % has finiteAggregate
from DictionaryOperations(Record(key : Key, entry : Entry))
remove! : (Record(key : Key, entry : Entry), %) -> % if Record(key : Key, entry : Entry) has BasicType and % has finiteAggregate
from DictionaryOperations(Record(key : Key, entry : Entry))
remove! : (Key, %) -> Union(Entry, "failed")
from KeyedDictionary(Key, Entry)
removeDuplicates : % -> % if Record(key : Key, entry : Entry) has BasicType and % has finiteAggregate
from Collection(Record(key : Key, entry : Entry))
sample : () -> %
from Aggregate
search : (Key, %) -> Union(Entry, "failed")
from KeyedDictionary(Key, Entry)
select : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> % if % has finiteAggregate
from Collection(Record(key : Key, entry : Entry))
select! : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> % if % has finiteAggregate
from DictionaryOperations(Record(key : Key, entry : Entry))
setelt! : (%, Key, Entry) -> Entry

setelt!(t, k, e) (also written t.k := e) is equivalent to (insert!([k, e], t); e).

size? : (%, NonNegativeInteger) -> Boolean
from Aggregate
swap! : (%, Key, Key) -> Void
from IndexedAggregate(Key, Entry)
table : () -> %

table()$T creates an empty table of type T.

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

table([x, y, ..., z]) creates a table consisting of entries x, y, ..., z.

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

ConvertibleTo(InputForm)

Aggregate

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

KeyedDictionary(Key, Entry)

Eltable(Key, Entry)

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

HomogeneousAggregate(Entry)

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

Evalable(Entry)

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

SetCategory

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

IndexedAggregate(Key, Entry)

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

InnerEvalable(Entry, Entry)

EltableAggregate(Key, Entry)

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

CoercibleTo(OutputForm)

shallowlyMutable

BasicType