XHashTable(Key, Entry)

xhash.spad line 1 [edit on github]

• Key : Hashable
• Entry : Type

An implementation of a hash table that uses equality of the key domain to decide upon equality of keys.

# : % -> NonNegativeInteger

from Aggregate

= : (%, %) -> Boolean if Record(key : Key, entry : Entry) has BasicType or Entry has BasicType

from BasicType

any? : (Mapping(Boolean, Entry), %) -> Boolean

from HomogeneousAggregate(Entry)

any? : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> Boolean

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, %) -> NonNegativeInteger if Entry has BasicType

from HomogeneousAggregate(Entry)

count : (Mapping(Boolean, Entry), %) -> NonNegativeInteger

from HomogeneousAggregate(Entry)

count : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> 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))

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

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

from HomogeneousAggregate(Entry)

every? : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> Boolean

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

from SetCategory

less? : (%, NonNegativeInteger) -> Boolean

from Aggregate

map : (Mapping(Entry, Entry), %) -> %

from HomogeneousAggregate(Entry)

map : (Mapping(Entry, Entry, Entry), %, %) -> %

from TableAggregate(Key, Entry)

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

from HomogeneousAggregate(Entry)

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

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 : (Mapping(Boolean, Record(key : Key, entry : Entry), 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 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))

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

minIndex : % -> Key if Key has OrderedSet

from IndexedAggregate(Key, Entry)

more? : (%, NonNegativeInteger) -> Boolean

from Aggregate

parts : % -> List(Entry)

from HomogeneousAggregate(Entry)

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

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)

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)

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

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

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

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

remove! : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> %

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

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

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

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

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

select! : (Mapping(Boolean, Record(key : Key, entry : Entry)), %) -> %

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

setelt! : (%, Key, Entry) -> Entry

from TableAggregate(Key, Entry)

size? : (%, NonNegativeInteger) -> Boolean

from Aggregate

swap! : (%, Key, Key) -> Void

from IndexedAggregate(Key, Entry)

table : () -> %

from TableAggregate(Key, Entry)

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

from TableAggregate(Key, Entry)

table : Mapping(SingleInteger, Key) -> %

table(h) creates an empty hash table that uses h instead of hash$Key. Note that h should be a mathematical function in the sense that from k1=k2 follows h(k1)=h(k2). If that is not the case, k1 and k2 will internally be considered as being different keys. For XHashTable to work correctly, the function h must only yield non-negative values.

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

from BasicType

ConvertibleTo(InputForm)

shallowlyMutable

Aggregate

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

BasicType

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

KeyedDictionary(Key, Entry)

HomogeneousAggregate(Entry)

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

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

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

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

Evalable(Entry)

SetCategory

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

Eltable(Key, Entry)

IndexedAggregate(Key, Entry)

InnerEvalable(Entry, Entry)

EltableAggregate(Key, Entry)

CoercibleTo(OutputForm)

finiteAggregate

TableAggregate(Key, Entry)