mutable

package

Go to main page

Versions in this module

v0

v0.0.14

Jul 2, 2024

v0.0.13

Jun 16, 2024

v0.0.12

Mar 31, 2024

Changes in this version

type Map

+ func (m *Map[K, V]) All(consumer func(K, V) bool)

type Set

+ func (s *Set[T]) All(consumer func(T) bool)

type SliceIter

+ func (i *SliceIter[T]) All(consumer func(element T) bool)

+ func (i *SliceIter[T]) Size() int

type Vector

+ func (v *Vector[T]) All(consumer func(int, T) bool)

v0.0.11

Nov 15, 2023

Changes in this version

type Map

+ func (m *Map[K, V]) Sort(comparer slice.Comparer[K]) *ordered.Map[K, V]

+ func (m *Map[K, V]) StableSort(comparer slice.Comparer[K]) *ordered.Map[K, V]

v0.0.10

Jun 11, 2023

Changes in this version

type SetIter

+ func (i *SetIter[K]) Start() (*SetIter[K], K, bool)

type SliceIter

+ func (i *SliceIter[T]) Start() (*SliceIter[T], T, bool)

v0.0.9

May 26, 2023

v0.0.8

May 17, 2023

v0.0.7

May 5, 2023

Changes in this version

+ type Map map[K]V

+ func MapFromLoop(next func() (K, V, bool)) *Map[K, V]

+ func NewMap(elements ...c.KV[K, V]) *Map[K, V]

+ func NewMapCap(capacity int) *Map[K, V]

+ func NewMapOf(elements map[K]V) *Map[K, V]

+ func WrapMap(elements map[K]V) *Map[K, V]

+ func (m *Map[K, V]) Contains(key K) (ok bool)

+ func (m *Map[K, V]) Conv(converter func(K, V) (K, V, error)) breakKvStream.Iter[K, V, map[K]V]

+ func (m *Map[K, V]) Convert(converter func(K, V) (K, V)) stream.Iter[K, V, map[K]V]

+ func (m *Map[K, V]) ConvertKey(converter func(K) K) stream.Iter[K, V, map[K]V]

+ func (m *Map[K, V]) ConvertValue(converter func(V) V) stream.Iter[K, V, map[K]V]

+ func (m *Map[K, V]) Delete(keys ...K)

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

+ func (m *Map[K, V]) Filt(predicate func(K, V) (bool, error)) breakKvStream.Iter[K, V, map[K]V]

+ func (m *Map[K, V]) FiltValue(predicate func(V) (bool, error)) breakKvStream.Iter[K, V, map[K]V]

+ func (m *Map[K, V]) Filter(predicate func(K, V) bool) stream.Iter[K, V, map[K]V]

+ func (m *Map[K, V]) FilterKey(predicate func(K) bool) stream.Iter[K, V, map[K]V]

+ func (m *Map[K, V]) FilterValue(predicate func(V) bool) stream.Iter[K, V, map[K]V]

+ func (m *Map[K, V]) First() (map_.Iter[K, V], K, V, bool)

+ func (m *Map[K, V]) For(walker func(c.KV[K, V]) error) error

+ func (m *Map[K, V]) ForEach(walker func(c.KV[K, V]))

+ func (m *Map[K, V]) Get(key K) (val V, ok bool)

+ func (m *Map[K, V]) HasAny(predicate func(K, V) bool) bool

+ func (m *Map[K, V]) Head() map_.Iter[K, V]

+ func (m *Map[K, V]) Immutable() immutable.Map[K, V]

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

+ func (m *Map[K, V]) Iter() kv.Iterator[K, V]

+ func (m *Map[K, V]) Keys() immutable.MapKeys[K, V]

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

+ func (m *Map[K, V]) Loop() *map_.Iter[K, V]

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

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

+ func (m *Map[K, V]) Remove(key K) (v V, ok bool)

+ func (m *Map[K, V]) Set(key K, value V)

+ func (m *Map[K, V]) SetMap(other c.TrackEachLoop[K, V])

+ func (m *Map[K, V]) SetNew(key K, value V) bool

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

+ func (m *Map[K, V]) Track(tracker func(K, V) error) error

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

+ func (m *Map[K, V]) Values() immutable.MapValues[K, V]

+ func (m Map[K, V]) ConvKey(converter func(K) (K, error)) breakKvStream.Iter[K, V, map[K]V]

+ func (m Map[K, V]) ConvValue(converter func(V) (V, error)) breakKvStream.Iter[K, V, map[K]V]

+ func (m Map[K, V]) FiltKey(predicate func(K) (bool, error)) breakKvStream.Iter[K, V, map[K]V]

+ type Set struct

+ func NewSet(elements ...T) *Set[T]

+ func NewSetCap(capacity int) *Set[T]

+ func SetFromLoop(next func() (T, bool)) *Set[T]

+ func WrapSet(elements map[T]struct{}) *Set[T]

+ func (s *Set[K]) HasAny(predicate func(K) bool) bool

+ func (s *Set[T]) Add(elements ...T)

+ func (s *Set[T]) AddAll(elements c.ForEachLoop[T])

+ func (s *Set[T]) AddAllNew(other c.ForEachLoop[T]) (ok bool)

+ func (s *Set[T]) AddNew(elements ...T) bool

+ func (s *Set[T]) AddOne(element T)

+ func (s *Set[T]) AddOneNew(element T) (ok bool)

+ func (s *Set[T]) Append(out []T) []T

+ func (s *Set[T]) Clone() *Set[T]

+ func (s *Set[T]) Contains(element T) (ok bool)

+ func (s *Set[T]) Conv(converter func(T) (T, error)) breakStream.Iter[T]

+ func (s *Set[T]) Convert(converter func(T) T) stream.Iter[T]

+ func (s *Set[T]) Delete(elements ...T)

+ func (s *Set[T]) DeleteActual(elements ...T) bool

+ func (s *Set[T]) DeleteActualOne(element T) (ok bool)

+ func (s *Set[T]) DeleteOne(element T)

+ func (s *Set[T]) Filter(predicate func(T) bool) stream.Iter[T]

+ func (s *Set[T]) First() (SetIter[T], T, bool)

+ func (s *Set[T]) For(walker func(T) error) error

+ func (s *Set[T]) ForEach(walker func(T))

+ func (s *Set[T]) Head() SetIter[T]

+ func (s *Set[T]) IsEmpty() bool

+ func (s *Set[T]) Iter() c.Iterator[T]

+ func (s *Set[T]) IterEdit() c.DelIterator[T]

+ func (s *Set[T]) Len() int

+ func (s *Set[T]) Loop() *SetIter[T]

+ func (s *Set[T]) Reduce(merge func(T, T) T) (t T)

+ func (s *Set[T]) Slice() (out []T)

+ func (s *Set[T]) Sort(less slice.Less[T]) *ordered.Set[T]

+ func (s *Set[T]) StableSort(less slice.Less[T]) *ordered.Set[T]

+ func (s *Set[T]) String() string

+ func (s Set[T]) Filt(predicate func(T) (bool, error)) breakStream.Iter[T]

+ type SetIter struct

+ func NewSetIter(uniques map[K]struct{}, del func(element K)) SetIter[K]

+ func (i *SetIter[K]) Delete()

+ func (i *SetIter[K]) Next() (key K, ok bool)

+ type SliceIter struct

+ func NewHead(elements *TS, del func(int) bool) SliceIter[T]

+ func NewTail(elements *TS, del func(int) bool) SliceIter[T]

+ func (i *SliceIter[T]) Cap() int

+ func (i *SliceIter[T]) Delete()

+ func (i *SliceIter[T]) DeleteNext() bool

+ func (i *SliceIter[T]) DeletePrev() bool

+ func (i *SliceIter[T]) For(walker func(element T) error) error

+ func (i *SliceIter[T]) ForEach(walker func(element T))

+ func (i *SliceIter[T]) Get() (t T, ok bool)

+ func (i *SliceIter[T]) GetNext() (t T)

+ func (i *SliceIter[T]) GetPrev() (t T)

+ func (i *SliceIter[T]) HasNext() bool

+ func (i *SliceIter[T]) HasPrev() bool

+ func (i *SliceIter[T]) Next() (T, bool)

+ func (i *SliceIter[T]) Prev() (T, bool)

+ type Vector []T

+ func NewVector(elements ...T) *Vector[T]

+ func NewVectorCap(capacity int) *Vector[T]

+ func VectorFromLoop(next func() (T, bool)) *Vector[T]

+ func WrapVector(elements []T) *Vector[T]

+ func (v *Vector[T]) Add(elements ...T)

+ func (v *Vector[T]) AddAll(other c.ForEachLoop[T])

+ func (v *Vector[T]) AddOne(element T)

+ func (v *Vector[T]) Append(out []T) []T

+ func (v *Vector[T]) Clone() *Vector[T]

+ func (v *Vector[T]) Conv(converter func(T) (T, error)) breakStream.Iter[T]

+ func (v *Vector[T]) Convert(converter func(T) T) stream.Iter[T]

+ func (v *Vector[T]) Delete(indexes ...int)

+ func (v *Vector[T]) DeleteActual(indexes ...int) bool

+ func (v *Vector[T]) DeleteActualOne(index int) bool

+ func (v *Vector[T]) DeleteOne(index int)

+ func (v *Vector[T]) Filt(predicate func(T) (bool, error)) breakStream.Iter[T]

+ func (v *Vector[T]) Filter(filter func(T) bool) stream.Iter[T]

+ func (v *Vector[T]) First() (SliceIter[T], T, bool)

+ func (v *Vector[T]) For(walker func(T) error) error

+ func (v *Vector[T]) ForEach(walker func(T))

+ func (v *Vector[T]) Get(index int) (t T, ok bool)

+ func (v *Vector[T]) HasAny(predicate func(T) bool) (ok bool)

+ func (v *Vector[T]) Head() SliceIter[T]

+ func (v *Vector[T]) IsEmpty() bool

+ func (v *Vector[T]) Iter() c.Iterator[T]

+ func (v *Vector[T]) IterEdit() c.DelIterator[T]

+ func (v *Vector[T]) Last() (SliceIter[T], T, bool)

+ func (v *Vector[T]) Len() int

+ func (v *Vector[T]) Loop() *SliceIter[T]

+ func (v *Vector[T]) Reduce(merge func(T, T) T) (out T)

+ func (v *Vector[T]) Remove(index int) (t T, ok bool)

+ func (v *Vector[T]) Set(index int, value T)

+ func (v *Vector[T]) SetNew(index int, value T) bool

+ func (v *Vector[T]) Slice() (out []T)

+ func (v *Vector[T]) Sort(less slice.Less[T]) *Vector[T]

+ func (v *Vector[T]) StableSort(less slice.Less[T]) *Vector[T]

+ func (v *Vector[T]) String() string

+ func (v *Vector[T]) Tail() SliceIter[T]

+ func (v *Vector[T]) Track(tracker func(int, T) error) error

+ func (v *Vector[T]) TrackEach(tracker func(int, T))

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