TableAggregate(Key, Entry)ΒΆ

aggcat.spad line 892

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 BasicType and % has finiteAggregate or Record(key: Key, entry: Entry) has SetCategory or % has finiteAggregate and Entry has BasicType
from BasicType
~=: (%, %) -> Boolean if Entry has SetCategory or Record(key: Key, entry: Entry) has BasicType and % has finiteAggregate or Record(key: Key, entry: Entry) has SetCategory or % has finiteAggregate and Entry has BasicType
from BasicType
any?: (Entry -> Boolean, %) -> Boolean if % has finiteAggregate
from HomogeneousAggregate Entry
any?: (Record(key: Key, entry: Entry) -> Boolean, %) -> 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 -> Boolean, %) -> NonNegativeInteger if % has finiteAggregate
from HomogeneousAggregate Entry
count: (Entry, %) -> NonNegativeInteger if % has finiteAggregate and Entry has BasicType
from HomogeneousAggregate Entry
count: (Record(key: Key, entry: Entry) -> Boolean, %) -> 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 % has finiteAggregate and Entry has BasicType
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?: (Entry -> Boolean, %) -> Boolean if % has finiteAggregate
from HomogeneousAggregate Entry
every?: (Record(key: Key, entry: Entry) -> Boolean, %) -> 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: (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)
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?: (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!: (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, %, %) -> %
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: (Entry -> Entry, %) -> %
from HomogeneousAggregate Entry
map: (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)
member?: (Entry, %) -> Boolean if % has finiteAggregate and Entry has BasicType
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)
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: ((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: ((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: ((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!: (Key, %) -> Union(Entry, failed)
from KeyedDictionary(Key, Entry)
remove!: (Record(key: Key, entry: Entry) -> Boolean, %) -> % 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: (Record(key: Key, entry: Entry) -> Boolean, %) -> % 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)
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!: (Record(key: Key, entry: Entry) -> Boolean, %) -> % if % has finiteAggregate
from DictionaryOperations Record(key: Key, entry: Entry)
select: (Record(key: Key, entry: Entry) -> Boolean, %) -> % if % has finiteAggregate
from Collection 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.

Aggregate

BagAggregate Record(key: Key, entry: Entry)

BasicType if Entry has SetCategory or Record(key: Key, entry: Entry) has BasicType and % has finiteAggregate or Record(key: Key, entry: Entry) has SetCategory or % has finiteAggregate and 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)

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

Dictionary Record(key: Key, entry: Entry)

DictionaryOperations Record(key: Key, entry: Entry)

Eltable(Key, 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

HomogeneousAggregate Entry

HomogeneousAggregate 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)

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

shallowlyMutable