collections

Dec 15, 2022

Changes in this version

type CatalogLike

+ func CatalogFromArray(array []Binding[K, V]) CatalogLike[K, V]

Nov 14, 2022

Changes in this version

+ func CompareValues(first Value, second Value) bool

+ func FormatValue(value Value) string

+ func FormatValueWithIndentation(value Value, indentation int) string

+ func RankValues(first Value, second Value) int

+ func ReverseArray(array []V)

+ func ShuffleArray(array []V)

+ func SortArray(array []V, rank RankingFunction)

+ type Array []V

+ func (v Array[V]) AsArray() []V

+ func (v Array[V]) ContainsAll(values Sequential[V]) bool

+ func (v Array[V]) ContainsAny(values Sequential[V]) bool

+ func (v Array[V]) ContainsValue(value V) bool

+ func (v Array[V]) GetIndex(value V) int

+ func (v Array[V]) GetSize() int

+ func (v Array[V]) GetValue(index int) V

+ func (v Array[V]) GetValues(first int, last int) Sequential[V]

+ func (v Array[V]) GoIndex(index int) int

+ func (v Array[V]) IsEmpty() bool

+ func (v Array[V]) SetValue(index int, value V)

+ func (v Array[V]) SetValues(index int, values Sequential[V])

+ func (v Array[V]) String() string

+ type ArrayLike interface

+ type AssociationLike interface

+ func Association(key K, value V) AssociationLike[K, V]

+ type Associative interface

+ AddAssociation func(association Binding[K, V])

+ AddAssociations func(associations Sequential[Binding[K, V]])

+ GetKeys func() Sequential[K]

+ GetValue func(key K) V

+ GetValues func(keys Sequential[K]) Sequential[V]

+ RemoveAll func()

+ RemoveValue func(key K) V

+ RemoveValues func(keys Sequential[K]) Sequential[V]

+ SetValue func(key K, value V)

+ type Binding interface

+ GetKey func() K

+ GetValue func() V

+ SetValue func(value V)

+ type Canonical interface

+ AppendNewline func()

+ AppendString func(s string)

+ FormatValue func(value Value)

+ GetIndentation func() int

+ GetResult func() string

+ type CatalogLike interface

+ func Catalog() CatalogLike[K, V]

+ func CatalogFromSequence(sequence Sequential[Binding[K, V]]) CatalogLike[K, V]

+ func Extract(catalog CatalogLike[K, V], keys Sequential[K]) CatalogLike[K, V]

+ func Merge(first, second CatalogLike[K, V]) CatalogLike[K, V]

+ type CollatorLike interface

+ func Collator() CollatorLike

+ type ComparisonFunction func(first Value, second Value) bool

+ type Discerning interface

+ CompareValues func(first Value, second Value) bool

+ RankValues func(first Value, second Value) int

+ type FIFO interface

+ AddValue func(value V)

+ AddValues func(values Sequential[V])

+ CloseQueue func()

+ GetCapacity func() int

+ RemoveHead func() (head V, ok bool)

+ func Join(wg *syn.WaitGroup, inputs Sequential[FIFO[V]]) FIFO[V]

+ type Flexible interface

+ AddValue func(value V)

+ AddValues func(values Sequential[V])

+ RemoveAll func()

+ RemoveValue func(value V)

+ RemoveValues func(values Sequential[V])

+ type FormatterLike interface

+ func Formatter(indentation int) FormatterLike

+ type Indexed interface

+ GetIndex func(value V) int

+ GetValue func(index int) V

+ GetValues func(first int, last int) Sequential[V]

+ GoIndex func(index int) int

+ type IteratorLike interface

+ func Iterator(sequence Sequential[V]) IteratorLike[V]

+ type Key any

+ type LIFO interface

+ AddValue func(value V)

+ AddValues func(values Sequential[V])

+ GetCapacity func() int

+ GetTop func() V

+ RemoveAll func()

+ RemoveTop func() V

+ type ListLike interface

+ func Concatenate(first, second ListLike[V]) ListLike[V]

+ func List() ListLike[V]

+ func ListFromArray(array []V) ListLike[V]

+ func ListFromSequence(sequence Sequential[V]) ListLike[V]

+ func ListWithComparer(compare ComparisonFunction) ListLike[V]

+ type Malleable interface

+ AddValue func(value V)

+ AddValues func(values Sequential[V])

+ InsertValue func(slot int, value V)

+ InsertValues func(slot int, values Sequential[V])

+ RemoveAll func()

+ RemoveValue func(index int) V

+ RemoveValues func(first int, last int) Sequential[V]

+ type Map map[K]V

+ func (v Map[K, V]) AddAssociation(association Binding[K, V])

+ func (v Map[K, V]) AddAssociations(associations Sequential[Binding[K, V]])

+ func (v Map[K, V]) AsArray() []Binding[K, V]

+ func (v Map[K, V]) GetKeys() Sequential[K]

+ func (v Map[K, V]) GetSize() int

+ func (v Map[K, V]) GetValue(key K) V

+ func (v Map[K, V]) GetValues(keys Sequential[K]) Sequential[V]

+ func (v Map[K, V]) IsEmpty() bool

+ func (v Map[K, V]) RemoveAll()

+ func (v Map[K, V]) RemoveValue(key K) V

+ func (v Map[K, V]) RemoveValues(keys Sequential[K]) Sequential[V]

+ func (v Map[K, V]) SetValue(key K, value V)

+ func (v Map[K, V]) String() string

+ type MapLike interface

+ type QueueLike interface

+ func Queue() QueueLike[V]

+ func QueueWithCapacity(capacity int) QueueLike[V]

+ type RankingFunction func(first Value, second Value) int

+ type Ratcheted interface

+ GetNext func() V

+ GetPrevious func() V

+ GetSlot func() int

+ HasNext func() bool

+ HasPrevious func() bool

+ ToEnd func()

+ ToSlot func(slot int)

+ ToStart func()

+ type Searchable interface

+ ContainsAll func(values Sequential[V]) bool

+ ContainsAny func(values Sequential[V]) bool

+ ContainsValue func(value V) bool

+ type Sequential interface

+ AsArray func() []V

+ GetSize func() int

+ IsEmpty func() bool

+ func Fork(wg *syn.WaitGroup, input FIFO[V], size int) Sequential[FIFO[V]]

+ func Split(wg *syn.WaitGroup, input FIFO[V], size int) Sequential[FIFO[V]]

+ type SetLike interface

+ func And(first, second SetLike[V]) SetLike[V]

+ func Not(set SetLike[V]) SetLike[V]

+ func Or(first, second SetLike[V]) SetLike[V]

+ func Sans(first, second SetLike[V]) SetLike[V]

+ func Set() SetLike[V]

+ func SetFromArray(array []V) SetLike[V]

+ func SetFromSequence(sequence Sequential[V]) SetLike[V]

+ func SetWithRanker(rank RankingFunction) SetLike[V]

+ func Xor(first, second SetLike[V]) SetLike[V]

+ type Sort func(array []V, rank RankingFunction)

+ type Sortable interface

+ ReverseValues func()

+ ShuffleValues func()

+ SortValues func()

+ SortValuesWithRanker func(rank RankingFunction)

+ type SorterLike interface

+ func Sorter(rank RankingFunction) SorterLike[V]

+ type StackLike interface

+ func Stack() StackLike[V]

+ func StackWithCapacity(capacity int) StackLike[V]

+ type Systematic interface

+ ReverseArray func(array []V)

+ ShuffleArray func(array []V)

+ SortArray func(array []V)

+ type Updatable interface

+ SetValue func(index int, value V)

+ SetValues func(index int, values Sequential[V])

+ type Value any