collections

package module

Go to main page

Versions in this module

v0

v0.3.1

Jan 16, 2026

v0.3.0

Jan 16, 2026

Changes in this version

type ConcurrentMap

+ RemoveAndGet func(key K) (V, bool)

type Map

+ RemoveAll func(keys ...K) int

+ RemoveSeq func(seq iter.Seq[K]) int

v0.2.0

Jan 5, 2026

Changes in this version

type PriorityQueue

+ func UnmarshalPriorityQueueGob[T any](data []byte, comparator Comparator[T]) (PriorityQueue[T], error)

+ func UnmarshalPriorityQueueJSON[T any](data []byte, comparator Comparator[T]) (PriorityQueue[T], error)

+ func UnmarshalPriorityQueueOrderedGob[T Ordered](data []byte) (PriorityQueue[T], error)

+ func UnmarshalPriorityQueueOrderedJSON[T Ordered](data []byte) (PriorityQueue[T], error)

type SortedMap

+ func UnmarshalTreeMapGob[K, V any](data []byte, comparator Comparator[K]) (SortedMap[K, V], error)

+ func UnmarshalTreeMapJSON[K, V any](data []byte, comparator Comparator[K]) (SortedMap[K, V], error)

+ func UnmarshalTreeMapOrderedGob[K Ordered, V any](data []byte) (SortedMap[K, V], error)

+ func UnmarshalTreeMapOrderedJSON[K Ordered, V any](data []byte) (SortedMap[K, V], error)

type SortedSet

+ func UnmarshalTreeSetGob[T any](data []byte, comparator Comparator[T]) (SortedSet[T], error)

+ func UnmarshalTreeSetJSON[T any](data []byte, comparator Comparator[T]) (SortedSet[T], error)

+ func UnmarshalTreeSetOrderedGob[T Ordered](data []byte) (SortedSet[T], error)

+ func UnmarshalTreeSetOrderedJSON[T Ordered](data []byte) (SortedSet[T], error)

v0.1.1

Jan 5, 2026

v0.1.0

Jan 4, 2026

Changes in this version

+ type Collection interface

+ Clear func()

+ IsEmpty func() bool

+ Size func() int

+ String func() string

+ ToSlice func() []T

+ type Comparator func(a, b T) int

+ func CompareFunc[T Ordered]() Comparator[T]

+ type ConcurrentMap interface

+ CompareAndDelete func(key K, value V, eq Equaler[V]) bool

+ CompareAndSwap func(key K, old, new V, eq Equaler[V]) bool

+ GetOrCompute func(key K, compute func() V) (V, bool)

+ LoadAndDelete func(key K) (V, bool)

+ LoadOrStore func(key K, value V) (V, bool)

+ func NewConcurrentHashMapFrom[K comparable, V any](src map[K]V) ConcurrentMap[K, V]

+ func NewConcurrentHashMap[K comparable, V any]() ConcurrentMap[K, V]

+ type ConcurrentSet interface

+ AddIfAbsent func(element T) bool

+ RemoveAndGet func(element T) (T, bool)

+ func NewConcurrentHashSetFrom[T comparable](elements ...T) ConcurrentSet[T]

+ func NewConcurrentHashSet[T comparable]() ConcurrentSet[T]

+ type ConcurrentSortedMap interface

+ func NewConcurrentSkipMapFrom[K Ordered, V any](src map[K]V) ConcurrentSortedMap[K, V]

+ func NewConcurrentSkipMap[K Ordered, V any]() ConcurrentSortedMap[K, V]

+ func NewConcurrentTreeMapFrom[K comparable, V any](cmpK Comparator[K], m map[K]V) ConcurrentSortedMap[K, V]

+ func NewConcurrentTreeMapOrdered[K Ordered, V any]() ConcurrentSortedMap[K, V]

+ func NewConcurrentTreeMap[K any, V any](cmpK Comparator[K]) ConcurrentSortedMap[K, V]

+ type ConcurrentSortedSet interface

+ func NewConcurrentSkipSetFrom[T Ordered](elements ...T) ConcurrentSortedSet[T]

+ func NewConcurrentSkipSet[T Ordered]() ConcurrentSortedSet[T]

+ func NewConcurrentTreeSetFrom[T any](cmpT Comparator[T], elements ...T) ConcurrentSortedSet[T]

+ func NewConcurrentTreeSetOrdered[T Ordered]() ConcurrentSortedSet[T]

+ func NewConcurrentTreeSet[T any](cmpT Comparator[T]) ConcurrentSortedSet[T]

+ type Deque interface

+ Clear func()

+ IsEmpty func() bool

+ PeekBack func() (T, bool)

+ PeekFront func() (T, bool)

+ PopBack func() (T, bool)

+ PopFront func() (T, bool)

+ PushBack func(element T)

+ PushFront func(element T)

+ Reversed func() iter.Seq[T]

+ Seq func() iter.Seq[T]

+ Size func() int

+ String func() string

+ ToSlice func() []T

+ func NewArrayDequeFrom[T any](elements ...T) Deque[T]

+ func NewArrayDequeWithCapacity[T any](capacity int) Deque[T]

+ func NewArrayDeque[T any]() Deque[T]

+ type Entry struct

+ Key K

+ Value V

+ func (e Entry[K, V]) Unpack() (K, V)

+ type Equaler func(a, b T) bool

+ func EqualFunc[T comparable]() Equaler[T]

+ type GoMapView interface

+ ToGoMap func() map[K]V

+ type Iterable interface

+ ForEach func(action func(element T) bool)

+ Seq func() iter.Seq[T]

+ type List interface

+ Add func(element T)

+ AddAll func(elements ...T)

+ AddSeq func(seq iter.Seq[T])

+ Any func(predicate func(element T) bool) bool

+ Clone func() List[T]

+ Contains func(element T, eq Equaler[T]) bool

+ Every func(predicate func(element T) bool) bool

+ Filter func(predicate func(element T) bool) List[T]

+ Find func(predicate func(element T) bool) (T, bool)

+ FindIndex func(predicate func(element T) bool) int

+ First func() (T, bool)

+ Get func(index int) (T, bool)

+ IndexOf func(element T, eq Equaler[T]) int

+ Insert func(index int, element T) bool

+ InsertAll func(index int, elements ...T) bool

+ Last func() (T, bool)

+ LastIndexOf func(element T, eq Equaler[T]) int

+ Remove func(element T, eq Equaler[T]) bool

+ RemoveAt func(index int) (T, bool)

+ RemoveFirst func() (T, bool)

+ RemoveFunc func(predicate func(element T) bool) int

+ RemoveLast func() (T, bool)

+ RetainFunc func(predicate func(element T) bool) int

+ Reversed func() iter.Seq[T]

+ Set func(index int, element T) (T, bool)

+ Sort func(cmp Comparator[T])

+ SubList func(from, to int) List[T]

+ func NewArrayListFrom[T any](elements ...T) List[T]

+ func NewArrayListWithCapacity[T any](capacity int) List[T]

+ func NewArrayList[T any]() List[T]

+ func NewCOWListFrom[T any](elements ...T) List[T]

+ func NewCOWList[T any]() List[T]

+ func NewLinkedListFrom[T any](elements ...T) List[T]

+ func NewLinkedList[T any]() List[T]

+ func NewLockFreeListFrom[T any](eq Equaler[T], elements ...T) List[T]

+ func NewLockFreeListOrdered[T comparable]() List[T]

+ func NewLockFreeList[T any](eq Equaler[T]) List[T]

+ func NewSegmentedListFrom[T any](elements ...T) List[T]

+ func NewSegmentedListWithSegments[T any](segmentCount int) List[T]

+ func NewSegmentedList[T any]() List[T]

+ type Map interface

+ Clear func()

+ Clone func() Map[K, V]

+ Compute func(key K, remapping func(key K, oldValue V, exists bool) (newValue V, keep bool)) (V, bool)

+ ComputeIfAbsent func(key K, mapping func(key K) V) V

+ ComputeIfPresent func(key K, remapping func(key K, oldValue V) (newValue V, keep bool)) (V, bool)

+ ContainsKey func(key K) bool

+ ContainsValue func(value V, eq Equaler[V]) bool

+ Entries func() []Entry[K, V]

+ Equals func(other Map[K, V], valueEq Equaler[V]) bool

+ Filter func(predicate func(key K, value V) bool) Map[K, V]

+ ForEach func(action func(key K, value V) bool)

+ Get func(key K) (V, bool)

+ GetOrDefault func(key K, defaultValue V) V

+ IsEmpty func() bool

+ Keys func() []K

+ Merge func(key K, value V, ...) (V, bool)

+ Put func(key K, value V) (V, bool)

+ PutAll func(other Map[K, V])

+ PutIfAbsent func(key K, value V) (V, bool)

+ PutSeq func(seq iter.Seq2[K, V]) int

+ Remove func(key K) (V, bool)

+ RemoveFunc func(predicate func(key K, value V) bool) int

+ RemoveIf func(key K, value V, eq Equaler[V]) bool

+ RemoveKeys func(keys ...K) int

+ RemoveKeysSeq func(seq iter.Seq[K]) int

+ Replace func(key K, value V) (V, bool)

+ ReplaceAll func(function func(key K, value V) V)

+ ReplaceIf func(key K, oldValue, newValue V, eq Equaler[V]) bool

+ Seq func() iter.Seq2[K, V]

+ SeqKeys func() iter.Seq[K]

+ SeqValues func() iter.Seq[V]

+ Size func() int

+ String func() string

+ Values func() []V

+ func NewHashMapFrom[K comparable, V any](src map[K]V) Map[K, V]

+ func NewHashMapWithCapacity[K comparable, V any](capacity int) Map[K, V]

+ func NewHashMap[K comparable, V any]() Map[K, V]

+ type Ordered = cmp.Ordered

+ type PriorityQueue interface

+ Clear func()

+ IsEmpty func() bool

+ Peek func() (T, bool)

+ Pop func() (T, bool)

+ Push func(element T)

+ PushAll func(elements ...T)

+ Seq func() iter.Seq[T]

+ Size func() int

+ String func() string

+ ToSlice func() []T

+ ToSortedSlice func() []T

+ func NewMaxPriorityQueue[T Ordered]() PriorityQueue[T]

+ func NewPriorityQueueFrom[T any](cmp Comparator[T], elements ...T) PriorityQueue[T]

+ func NewPriorityQueueOrdered[T Ordered]() PriorityQueue[T]

+ func NewPriorityQueueWithCapacity[T any](cmp Comparator[T], capacity int) PriorityQueue[T]

+ func NewPriorityQueue[T any](cmp Comparator[T]) PriorityQueue[T]

+ type Queue interface

+ Clear func()

+ Dequeue func() (T, bool)

+ Enqueue func(element T)

+ EnqueueAll func(elements ...T)

+ IsEmpty func() bool

+ Peek func() (T, bool)

+ Seq func() iter.Seq[T]

+ Size func() int

+ String func() string

+ ToSlice func() []T

+ func NewArrayQueueFrom[T any](elements ...T) Queue[T]

+ func NewArrayQueueWithCapacity[T any](capacity int) Queue[T]

+ func NewArrayQueue[T any]() Queue[T]

+ type Set interface

+ Add func(element T) bool

+ AddAll func(elements ...T) int

+ AddSeq func(seq iter.Seq[T]) int

+ Any func(predicate func(element T) bool) bool

+ Clone func() Set[T]

+ Contains func(element T) bool

+ ContainsAll func(elements ...T) bool

+ ContainsAny func(elements ...T) bool

+ Difference func(other Set[T]) Set[T]

+ Equals func(other Set[T]) bool

+ Every func(predicate func(element T) bool) bool

+ Filter func(predicate func(element T) bool) Set[T]

+ Find func(predicate func(element T) bool) (T, bool)

+ Intersection func(other Set[T]) Set[T]

+ IsDisjoint func(other Set[T]) bool

+ IsProperSubsetOf func(other Set[T]) bool

+ IsProperSupersetOf func(other Set[T]) bool

+ IsSubsetOf func(other Set[T]) bool

+ IsSupersetOf func(other Set[T]) bool

+ Pop func() (T, bool)

+ Remove func(element T) bool

+ RemoveAll func(elements ...T) int

+ RemoveFunc func(predicate func(element T) bool) int

+ RemoveSeq func(seq iter.Seq[T]) int

+ RetainFunc func(predicate func(element T) bool) int

+ SymmetricDifference func(other Set[T]) Set[T]

+ Union func(other Set[T]) Set[T]

+ func NewHashSetFrom[T comparable](elements ...T) Set[T]

+ func NewHashSetWithCapacity[T comparable](capacity int) Set[T]

+ func NewHashSet[T comparable]() Set[T]

+ type SortedMap interface

+ Ascend func(action func(key K, value V) bool)

+ AscendFrom func(pivot K, action func(key K, value V) bool)

+ CeilingEntry func(k K) (Entry[K, V], bool)

+ CeilingKey func(k K) (K, bool)

+ CloneSorted func() SortedMap[K, V]

+ Descend func(action func(key K, value V) bool)

+ DescendFrom func(pivot K, action func(key K, value V) bool)

+ FirstEntry func() (Entry[K, V], bool)

+ FirstKey func() (K, bool)

+ FloorEntry func(k K) (Entry[K, V], bool)

+ FloorKey func(k K) (K, bool)

+ GetByRank func(rank int) (Entry[K, V], bool)

+ HeadMap func(to K, inclusive bool) SortedMap[K, V]

+ HigherEntry func(k K) (Entry[K, V], bool)

+ HigherKey func(k K) (K, bool)

+ LastEntry func() (Entry[K, V], bool)

+ LastKey func() (K, bool)

+ LowerEntry func(k K) (Entry[K, V], bool)

+ LowerKey func(k K) (K, bool)

+ PopFirst func() (Entry[K, V], bool)

+ PopLast func() (Entry[K, V], bool)

+ Range func(from, to K, action func(key K, value V) bool)

+ RangeFrom func(from K, action func(key K, value V) bool)

+ RangeSeq func(from, to K) iter.Seq2[K, V]

+ RangeTo func(to K, action func(key K, value V) bool)

+ RankOfKey func(key K) int

+ Reversed func() iter.Seq2[K, V]

+ SubMap func(from, to K) SortedMap[K, V]

+ TailMap func(from K, inclusive bool) SortedMap[K, V]

+ func NewTreeMapFrom[K comparable, V any](cmpK Comparator[K], m map[K]V) SortedMap[K, V]

+ func NewTreeMapOrdered[K Ordered, V any]() SortedMap[K, V]

+ func NewTreeMap[K any, V any](cmpK Comparator[K]) SortedMap[K, V]

+ type SortedSet interface

+ Ascend func(action func(element T) bool)

+ AscendFrom func(pivot T, action func(element T) bool)

+ Ceiling func(x T) (T, bool)

+ CloneSorted func() SortedSet[T]

+ Descend func(action func(element T) bool)

+ DescendFrom func(pivot T, action func(element T) bool)

+ First func() (T, bool)

+ Floor func(x T) (T, bool)

+ GetByRank func(rank int) (T, bool)

+ HeadSet func(to T, inclusive bool) SortedSet[T]

+ Higher func(x T) (T, bool)

+ Last func() (T, bool)

+ Lower func(x T) (T, bool)

+ Max func() (T, bool)

+ Min func() (T, bool)

+ PopFirst func() (T, bool)

+ PopLast func() (T, bool)

+ Range func(from, to T, action func(element T) bool)

+ RangeSeq func(from, to T) iter.Seq[T]

+ Rank func(x T) int

+ Reversed func() iter.Seq[T]

+ SubSet func(from, to T) SortedSet[T]

+ TailSet func(from T, inclusive bool) SortedSet[T]

+ func NewTreeSetFrom[T any](c Comparator[T], elements ...T) SortedSet[T]

+ func NewTreeSetOrdered[T Ordered]() SortedSet[T]

+ func NewTreeSet[T any](c Comparator[T]) SortedSet[T]

+ type Stack interface

+ Clear func()

+ IsEmpty func() bool

+ Peek func() (T, bool)

+ Pop func() (T, bool)

+ Push func(element T)

+ PushAll func(elements ...T)

+ Seq func() iter.Seq[T]

+ Size func() int

+ String func() string

+ ToSlice func() []T

+ func NewArrayStackFrom[T any](elements ...T) Stack[T]

+ func NewArrayStackWithCapacity[T any](capacity int) Stack[T]

+ func NewArrayStack[T any]() Stack[T]

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL