maps

Feb 11, 2025

Changes in this version

+ type SliceSet struct

+ func NewSliceSet[K comparable](values ...K) *SliceSet[K]

+ func (m *SliceSet[K]) Add(k ...K) SetI[K]

+ func (m *SliceSet[K]) All() iter.Seq[K]

+ func (m *SliceSet[K]) Clear()

+ func (m *SliceSet[K]) Clone() *SliceSet[K]

+ func (m *SliceSet[K]) Copy(in SetI[K])

+ func (m *SliceSet[K]) Delete(k K)

+ func (m *SliceSet[K]) DeleteFunc(del func(K) bool)

+ func (m *SliceSet[K]) Equal(m2 SetI[K]) bool

+ func (m *SliceSet[K]) Has(k K) bool

+ func (m *SliceSet[K]) Insert(seq iter.Seq[K])

+ func (m *SliceSet[K]) Len() int

+ func (m *SliceSet[K]) MarshalBinary() ([]byte, error)

+ func (m *SliceSet[K]) MarshalJSON() (out []byte, err error)

+ func (m *SliceSet[K]) Merge(in SetI[K])

+ func (m *SliceSet[K]) Range(f func(k K) bool)

+ func (m *SliceSet[K]) SetSortFunc(f func(val1, val2 K) bool)

+ func (m *SliceSet[K]) String() string

+ func (m *SliceSet[K]) UnmarshalBinary(data []byte) (err error)

+ func (m *SliceSet[K]) UnmarshalJSON(in []byte) (err error)

+ func (m *SliceSet[K]) Values() []K

Jan 25, 2025

Changes in this version

type OrderedSet

+ func (m *OrderedSet[K]) Clear()

+ func (m *OrderedSet[K]) Copy(in SetI[K])

+ func (m *OrderedSet[K]) Delete(k K)

+ func (m *OrderedSet[K]) DeleteFunc(del func(K) bool)

+ func (m *OrderedSet[K]) Equal(m2 SetI[K]) bool

+ func (m *OrderedSet[K]) Has(k K) bool

+ func (m *OrderedSet[K]) Insert(seq iter.Seq[K])

+ func (m *OrderedSet[K]) Len() int

+ func (m *OrderedSet[K]) String() string

type SetI

+ Copy func(in SetI[K])

Jan 24, 2025

Changes in this version

type OrderedSet

+ func (m *OrderedSet[K]) Add(k ...K) SetI[K]

+ func (m *OrderedSet[K]) Clone() *OrderedSet[K]

Jan 23, 2025

Changes in this version

+ type OrderedSet struct

+ func NewOrderedSet[K cmp.Ordered](values ...K) *OrderedSet[K]

+ func (m *OrderedSet[K]) All() iter.Seq[K]

+ func (m *OrderedSet[K]) MarshalJSON() (out []byte, err error)

+ func (m *OrderedSet[K]) Range(f func(k K) bool)

+ func (m *OrderedSet[K]) Values() []K

Nov 9, 2024

Changes in this version

+ func EqualFunc[K comparable, V1, V2 any](m1 MapI[K, V1], m2 MapI[K, V2], eq func(V1, V2) bool) bool

type Map

+ func CollectMap[K comparable, V any](seq iter.Seq2[K, V]) *Map[K, V]

+ func NewMap[K comparable, V any](sources ...map[K]V) *Map[K, V]

+ func (m *Map[K, V]) All() iter.Seq2[K, V]

+ func (m *Map[K, V]) Clone() *Map[K, V]

+ func (m *Map[K, V]) Copy(in MapI[K, V])

+ func (m *Map[K, V]) DeleteFunc(del func(K, V) bool)

+ func (m *Map[K, V]) Insert(seq iter.Seq2[K, V])

+ func (m *Map[K, V]) KeysIter() iter.Seq[K]

+ func (m *Map[K, V]) ValuesIter() iter.Seq[V]

type MapI

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

+ DeleteFunc func(del func(K, V) bool)

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

+ KeysIter func() iter.Seq[K]

+ String func() string

+ ValuesIter func() iter.Seq[V]

type SafeMap

+ func CollectSafeMap[K comparable, V any](seq iter.Seq2[K, V]) *SafeMap[K, V]

+ func NewSafeMap[K comparable, V any](sources ...map[K]V) *SafeMap[K, V]

+ func (m *SafeMap[K, V]) All() iter.Seq2[K, V]

+ func (m *SafeMap[K, V]) Clone() *SafeMap[K, V]

+ func (m *SafeMap[K, V]) Copy(in MapI[K, V])

+ func (m *SafeMap[K, V]) DeleteFunc(del func(K, V) bool)

+ func (m *SafeMap[K, V]) Insert(seq iter.Seq2[K, V])

+ func (m *SafeMap[K, V]) KeysIter() iter.Seq[K]

+ func (m *SafeMap[K, V]) ValuesIter() iter.Seq[V]

type SafeSliceMap

+ func CollectSafeSliceMap[K comparable, V any](seq iter.Seq2[K, V]) *SafeSliceMap[K, V]

+ func NewSafeSliceMap[K comparable, V any](sources ...map[K]V) *SafeSliceMap[K, V]

+ func (m *SafeSliceMap[K, V]) All() iter.Seq2[K, V]

+ func (m *SafeSliceMap[K, V]) Clone() *SafeSliceMap[K, V]

+ func (m *SafeSliceMap[K, V]) Copy(in MapI[K, V])

+ func (m *SafeSliceMap[K, V]) DeleteFunc(del func(K, V) bool)

+ func (m *SafeSliceMap[K, V]) Insert(seq iter.Seq2[K, V])

+ func (m *SafeSliceMap[K, V]) KeysIter() iter.Seq[K]

+ func (m *SafeSliceMap[K, V]) ValuesIter() iter.Seq[V]

type Set

+ func CollectSet[K comparable](seq iter.Seq[K]) *Set[K]

+ func NewSet[K comparable](values ...K) *Set[K]

+ func (m *Set[K]) All() iter.Seq[K]

+ func (m *Set[K]) Clone() *Set[K]

+ func (m *Set[K]) Copy(in SetI[K])

+ func (m *Set[K]) DeleteFunc(del func(K) bool)

+ func (m *Set[K]) Insert(seq iter.Seq[K])

type SetI

+ All func() iter.Seq[K]

+ Clone func() *Set[K]

+ DeleteFunc func(del func(K) bool)

+ Insert func(seq iter.Seq[K])

type SliceMap

+ func CollectSliceMap[K comparable, V any](seq iter.Seq2[K, V]) *SliceMap[K, V]

+ func NewSliceMap[K comparable, V any](sources ...map[K]V) *SliceMap[K, V]

+ func (m *SliceMap[K, V]) All() iter.Seq2[K, V]

+ func (m *SliceMap[K, V]) Clone() *SliceMap[K, V]

+ func (m *SliceMap[K, V]) Copy(in MapI[K, V])

+ func (m *SliceMap[K, V]) DeleteFunc(del func(K, V) bool)

+ func (m *SliceMap[K, V]) Insert(seq iter.Seq2[K, V])

+ func (m *SliceMap[K, V]) KeysIter() iter.Seq[K]

+ func (m *SliceMap[K, V]) ValuesIter() iter.Seq[V]

type StdMap

+ func CollectStdMap[K comparable, V any](seq iter.Seq2[K, V]) StdMap[K, V]

+ func (m StdMap[K, V]) All() iter.Seq2[K, V]

+ func (m StdMap[K, V]) Clone() StdMap[K, V]

+ func (m StdMap[K, V]) Copy(in MapI[K, V])

+ func (m StdMap[K, V]) DeleteFunc(del func(K, V) bool)

+ func (m StdMap[K, V]) Insert(seq iter.Seq2[K, V])

+ func (m StdMap[K, V]) KeysIter() iter.Seq[K]

+ func (m StdMap[K, V]) ValuesIter() iter.Seq[V]

Nov 2, 2022

Changes in this version

+ type Set struct

+ func (m *Set[K]) Add(k ...K) SetI[K]

+ func (m *Set[K]) Clear()

+ func (m *Set[K]) Delete(k K)

+ func (m *Set[K]) Equal(m2 SetI[K]) bool

+ func (m *Set[K]) Has(k K) bool

+ func (m *Set[K]) Len() int

+ func (m *Set[K]) MarshalBinary() ([]byte, error)

+ func (m *Set[K]) MarshalJSON() (out []byte, err error)

+ func (m *Set[K]) Merge(in SetI[K])

+ func (m *Set[K]) Range(f func(k K) bool)

+ func (m *Set[K]) String() string

+ func (m *Set[K]) UnmarshalBinary(data []byte) (err error)

+ func (m *Set[K]) UnmarshalJSON(in []byte) (err error)

+ func (m *Set[K]) Values() []K

+ type SetI interface

+ Add func(k ...K) SetI[K]

+ Clear func()

+ Delete func(k K)

+ Equal func(SetI[K]) bool

+ Has func(k K) bool

+ Len func() int

+ Merge func(SetI[K])

+ Range func(func(k K) bool)

+ Values func() []K

Mar 23, 2022

Changes in this version

+ type Getter interface

+ Get func(k K) (v V)

+ type Loader interface

+ Load func(k K) (v V, ok bool)

+ type Setter interface

+ Set func(K, V)

Mar 21, 2022

Changes in this version

+ type Equaler interface

+ Equal func(a any) bool

+ type Map struct

+ func (m *Map[K, V]) Clear()

+ func (m *Map[K, V]) Merge(in MapI[K, V])

+ func (m *Map[K, V]) Set(k K, v V)

+ func (m *Map[K, V]) UnmarshalBinary(data []byte) (err error)

+ func (m *Map[K, V]) UnmarshalJSON(in []byte) (err error)

+ func (m Map[K, V]) Delete(k K)

+ func (m Map[K, V]) Equal(m2 MapI[K, V]) bool

+ func (m Map[K, V]) Get(k K) V

+ func (m Map[K, V]) Has(k K) bool

+ func (m Map[K, V]) Keys() []K

+ func (m Map[K, V]) Len() int

+ func (m Map[K, V]) Load(k K) (V, bool)

+ func (m Map[K, V]) MarshalBinary() ([]byte, error)

+ func (m Map[K, V]) MarshalJSON() (out []byte, err error)

+ func (m Map[K, V]) Range(f func(k K, v V) bool)

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

+ func (m Map[K, V]) Values() []V

+ type MapI interface

+ Clear func()

+ Delete func(k K)

+ Equal func(MapI[K, V]) bool

+ Get func(k K) (v V)

+ Has func(k K) bool

+ Keys func() []K

+ Len func() int

+ Load func(k K) (v V, ok bool)

+ Merge func(MapI[K, V])

+ Range func(func(k K, v V) bool)

+ Set func(K, V)

+ Values func() []V

+ type SafeMap struct

+ func (m *SafeMap[K, V]) Clear()

+ func (m *SafeMap[K, V]) Delete(k K)

+ func (m *SafeMap[K, V]) Equal(m2 MapI[K, V]) bool

+ func (m *SafeMap[K, V]) Get(k K) (v V)

+ func (m *SafeMap[K, V]) Has(k K) (exists bool)

+ func (m *SafeMap[K, V]) Keys() (keys []K)

+ func (m *SafeMap[K, V]) Len() (l int)

+ func (m *SafeMap[K, V]) Load(k K) (v V, ok bool)

+ func (m *SafeMap[K, V]) MarshalBinary() ([]byte, error)

+ func (m *SafeMap[K, V]) MarshalJSON() (out []byte, err error)

+ func (m *SafeMap[K, V]) Merge(in MapI[K, V])

+ func (m *SafeMap[K, V]) Range(f func(k K, v V) bool)

+ func (m *SafeMap[K, V]) Set(k K, v V)

+ func (m *SafeMap[K, V]) String() string

+ func (m *SafeMap[K, V]) UnmarshalBinary(data []byte) (err error)

+ func (m *SafeMap[K, V]) UnmarshalJSON(in []byte) (err error)

+ func (m *SafeMap[K, V]) Values() (v []V)

+ type SafeSliceMap struct

+ func (m *SafeSliceMap[K, V]) Clear()

+ func (m *SafeSliceMap[K, V]) Delete(key K)

+ func (m *SafeSliceMap[K, V]) Equal(m2 MapI[K, V]) bool

+ func (m *SafeSliceMap[K, V]) Get(key K) (val V)

+ func (m *SafeSliceMap[K, V]) GetAt(position int) (val V)

+ func (m *SafeSliceMap[K, V]) GetKeyAt(position int) (key K)

+ func (m *SafeSliceMap[K, V]) Has(key K) (ok bool)

+ func (m *SafeSliceMap[K, V]) Keys() (keys []K)

+ func (m *SafeSliceMap[K, V]) Len() int

+ func (m *SafeSliceMap[K, V]) Load(key K) (val V, ok bool)

+ func (m *SafeSliceMap[K, V]) MarshalBinary() (data []byte, err error)

+ func (m *SafeSliceMap[K, V]) MarshalJSON() (data []byte, err error)

+ func (m *SafeSliceMap[K, V]) Merge(in MapI[K, V])

+ func (m *SafeSliceMap[K, V]) Range(f func(key K, value V) bool)

+ func (m *SafeSliceMap[K, V]) Set(key K, val V)

+ func (m *SafeSliceMap[K, V]) SetAt(index int, key K, val V)

+ func (m *SafeSliceMap[K, V]) SetSortFunc(f func(key1, key2 K, val1, val2 V) bool)

+ func (m *SafeSliceMap[K, V]) String() string

+ func (m *SafeSliceMap[K, V]) UnmarshalBinary(data []byte) (err error)

+ func (m *SafeSliceMap[K, V]) UnmarshalJSON(data []byte) (err error)

+ func (m *SafeSliceMap[K, V]) Values() (vals []V)

+ type SliceMap struct

+ func (m *SliceMap[K, V]) Clear()

+ func (m *SliceMap[K, V]) Delete(key K)

+ func (m *SliceMap[K, V]) Equal(m2 MapI[K, V]) bool

+ func (m *SliceMap[K, V]) Get(key K) (val V)

+ func (m *SliceMap[K, V]) GetAt(position int) (val V)

+ func (m *SliceMap[K, V]) GetKeyAt(position int) (key K)

+ func (m *SliceMap[K, V]) Has(key K) (ok bool)

+ func (m *SliceMap[K, V]) Keys() (keys []K)

+ func (m *SliceMap[K, V]) Len() int

+ func (m *SliceMap[K, V]) Load(key K) (val V, ok bool)

+ func (m *SliceMap[K, V]) MarshalBinary() (data []byte, err error)

+ func (m *SliceMap[K, V]) MarshalJSON() (data []byte, err error)

+ func (m *SliceMap[K, V]) Merge(in MapI[K, V])

+ func (m *SliceMap[K, V]) Range(f func(key K, value V) bool)

+ func (m *SliceMap[K, V]) Set(key K, val V)

+ func (m *SliceMap[K, V]) SetAt(index int, key K, val V)

+ func (m *SliceMap[K, V]) SetSortFunc(f func(key1, key2 K, val1, val2 V) bool)

+ func (m *SliceMap[K, V]) String() string

+ func (m *SliceMap[K, V]) UnmarshalBinary(data []byte) (err error)

+ func (m *SliceMap[K, V]) UnmarshalJSON(data []byte) (err error)

+ func (m *SliceMap[K, V]) Values() (vals []V)

+ type StdMap map[K]V

+ func Cast(m M) StdMap[K, V]

+ func NewStdMap(sources ...map[K]V) StdMap[K, V]

+ func (m *StdMap[K, V]) UnmarshalBinary(data []byte) (err error)

+ func (m *StdMap[K, V]) UnmarshalJSON(in []byte) (err error)

+ func (m StdMap[K, V]) Clear()

+ func (m StdMap[K, V]) Delete(k K)

+ func (m StdMap[K, V]) Equal(m2 MapI[K, V]) bool

+ func (m StdMap[K, V]) Get(k K) (v V)

+ func (m StdMap[K, V]) Has(k K) (exists bool)

+ func (m StdMap[K, V]) Keys() (keys []K)

+ func (m StdMap[K, V]) Len() int

+ func (m StdMap[K, V]) Load(k K) (v V, ok bool)

+ func (m StdMap[K, V]) MarshalBinary() ([]byte, error)

+ func (m StdMap[K, V]) MarshalJSON() (out []byte, err error)

+ func (m StdMap[K, V]) Merge(in MapI[K, V])

+ func (m StdMap[K, V]) Range(f func(k K, v V) bool)

+ func (m StdMap[K, V]) Set(k K, v V)

+ func (m StdMap[K, V]) String() string

+ func (m StdMap[K, V]) Values() (values []V)