immutable

Jan 30, 2023

Changes in this version

type Map

+ func NewMapOf(hasher Hasher[K], entries map[K]V) *Map[K, V]

type Set

+ func (s Set[T]) Add(value T) Set[T]

+ func (s Set[T]) Items() []T

type SortedMap

+ func NewSortedMapOf(comparer Comparer[K], entries map[K]V) *SortedMap[K, V]

type SortedSet

+ func (s SortedSet[T]) Add(value T) SortedSet[T]

+ func (s SortedSet[T]) Items() []T

Dec 26, 2022

retracted

Changes in this version

+ type Set struct

+ func NewSet(hasher Hasher[T]) Set[T]

+ func (s Set[K]) Len() int

+ func (s Set[T]) Delete(val T) Set[T]

+ func (s Set[T]) Has(val T) bool

+ func (s Set[T]) Iterator() *SetIterator[T]

+ func (s Set[T]) Set(val T) Set[T]

+ type SetBuilder struct

+ func NewSetBuilder(hasher Hasher[T]) *SetBuilder[T]

+ func (s SetBuilder[T]) Delete(val T)

+ func (s SetBuilder[T]) Has(val T) bool

+ func (s SetBuilder[T]) Len() int

+ func (s SetBuilder[T]) Set(val T)

+ type SetIterator struct

+ func (itr *SetIterator[T]) Done() bool

+ func (itr *SetIterator[T]) First()

+ func (itr *SetIterator[T]) Next() (val T, ok bool)

+ type SortedSet struct

+ func NewSortedSet(comparer Comparer[T]) SortedSet[T]

+ func (s SortedSet[K]) Len() int

+ func (s SortedSet[T]) Delete(val T) SortedSet[T]

+ func (s SortedSet[T]) Has(val T) bool

+ func (s SortedSet[T]) Iterator() *SortedSetIterator[T]

+ func (s SortedSet[T]) Put(val T) SortedSet[T]

+ type SortedSetBuilder struct

+ func NewSortedSetBuilder(comparer Comparer[T]) *SortedSetBuilder[T]

+ func (s SortedSetBuilder[T]) Delete(val T)

+ func (s SortedSetBuilder[T]) Has(val T) bool

+ func (s SortedSetBuilder[T]) Len() int

+ func (s SortedSetBuilder[T]) Set(val T)

+ type SortedSetIterator struct

+ func (itr *SortedSetIterator[T]) Done() bool

+ func (itr *SortedSetIterator[T]) First()

+ func (itr *SortedSetIterator[T]) Last()

+ func (itr *SortedSetIterator[T]) Next() (val T, ok bool)

+ func (itr *SortedSetIterator[T]) Prev() (val T, ok bool)

+ func (itr *SortedSetIterator[T]) Seek(val T)

Nov 17, 2020

Changes in this version

type ListBuilder

+ func (b *ListBuilder) Iterator() *ListIterator

type MapBuilder

+ func (b *MapBuilder) Iterator() *MapIterator

type SortedMapBuilder

+ func (b *SortedMapBuilder) Iterator() *SortedMapIterator

Sep 22, 2020

Changes in this version

type Comparer

+ func NewComparer(key interface{}) Comparer

type Hasher

+ func NewHasher(key interface{}) Hasher

Mar 7, 2019

Changes in this version

+ type ListBuilder struct

+ func NewListBuilder(list *List) *ListBuilder

+ func (b *ListBuilder) Append(value interface{})

+ func (b *ListBuilder) Get(index int) interface{}

+ func (b *ListBuilder) Len() int

+ func (b *ListBuilder) List() *List

+ func (b *ListBuilder) Prepend(value interface{})

+ func (b *ListBuilder) Set(index int, value interface{})

+ func (b *ListBuilder) Slice(start, end int)

+ type MapBuilder struct

+ func NewMapBuilder(m *Map) *MapBuilder

+ func (b *MapBuilder) Delete(key interface{})

+ func (b *MapBuilder) Get(key interface{}) (value interface{}, ok bool)

+ func (b *MapBuilder) Len() int

+ func (b *MapBuilder) Map() *Map

+ func (b *MapBuilder) Set(key, value interface{})

+ type SortedMapBuilder struct

+ func NewSortedMapBuilder(m *SortedMap) *SortedMapBuilder

+ func (b *SortedMapBuilder) Delete(key interface{})

+ func (b *SortedMapBuilder) Get(key interface{}) (value interface{}, ok bool)

+ func (b *SortedMapBuilder) Len() int

+ func (b *SortedMapBuilder) Map() *SortedMap

+ func (b *SortedMapBuilder) Set(key, value interface{})

Mar 1, 2019

Changes in this version

+ type Comparer interface

+ Compare func(a, b interface{}) int

+ type Hasher interface

+ Equal func(a, b interface{}) bool

+ Hash func(key interface{}) uint32

+ type List struct

+ func NewList() *List

+ func (l *List) Append(value interface{}) *List

+ func (l *List) Get(index int) interface{}

+ func (l *List) Iterator() *ListIterator

+ func (l *List) Len() int

+ func (l *List) Prepend(value interface{}) *List

+ func (l *List) Set(index int, value interface{}) *List

+ func (l *List) Slice(start, end int) *List

+ type ListIterator struct

+ func (itr *ListIterator) Done() bool

+ func (itr *ListIterator) First()

+ func (itr *ListIterator) Last()

+ func (itr *ListIterator) Next() (index int, value interface{})

+ func (itr *ListIterator) Prev() (index int, value interface{})

+ func (itr *ListIterator) Seek(index int)

+ type Map struct

+ func NewMap(hasher Hasher) *Map

+ func (m *Map) Delete(key interface{}) *Map

+ func (m *Map) Get(key interface{}) (value interface{}, ok bool)

+ func (m *Map) Iterator() *MapIterator

+ func (m *Map) Len() int

+ func (m *Map) Set(key, value interface{}) *Map

+ type MapIterator struct

+ func (itr *MapIterator) Done() bool

+ func (itr *MapIterator) First()

+ func (itr *MapIterator) Next() (key, value interface{})

+ type SortedMap struct

+ func NewSortedMap(comparer Comparer) *SortedMap

+ func (m *SortedMap) Delete(key interface{}) *SortedMap

+ func (m *SortedMap) Get(key interface{}) (interface{}, bool)

+ func (m *SortedMap) Iterator() *SortedMapIterator

+ func (m *SortedMap) Len() int

+ func (m *SortedMap) Set(key, value interface{}) *SortedMap

+ type SortedMapIterator struct

+ func (itr *SortedMapIterator) Done() bool

+ func (itr *SortedMapIterator) First()

+ func (itr *SortedMapIterator) Last()

+ func (itr *SortedMapIterator) Next() (key, value interface{})

+ func (itr *SortedMapIterator) Prev() (key, value interface{})

+ func (itr *SortedMapIterator) Seek(key interface{})