TableAggregate(Key, Entry)

aggcat.spad line 910 [edit on github]

• Key: Type

• Entry: Type

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

from BasicType

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

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

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

from Aggregate

empty: () -> %

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

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

max: % -> Entry if Entry has OrderedSet and % has finiteAggregate

from HomogeneousAggregate Entry

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

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

max: ((Entry, Entry) -> Boolean, %) -> Entry if % has finiteAggregate

from HomogeneousAggregate Entry

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

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

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 % has finiteAggregate and 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, %) -> % if % has finiteAggregate

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

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

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

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

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

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

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

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

KeyedDictionary(Key, Entry)

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

shallowlyMutable