mutable

package
v0.0.7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 5, 2023 License: MIT Imports: 22 Imported by: 0

Documentation

Overview

Package mutable provides implementations of mutable containers.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Map 

type Map[K comparable, V any] map[K]V

Map is a collection implementation that provides elements access by an unique key.

func MapFromLoop 

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

MapFromLoop creates a map with elements retrieved converter the 'next' function

func NewMap 

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

NewMap instantiates an map using key/value pairs

func NewMapCap 

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

NewMapCap instantiates Map with a predefined capacity

func NewMapOf 

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

NewMapOf instantiates Map populated by the 'elements' map key/values

func WrapMap 

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

WrapMap instantiates Map using a map as internal storage.

func (*Map[K, V]) Contains 

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

Contains checks is the map contains a key

func (*Map[K, V]) Conv 

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

Conv returns a breakable stream that applies the 'converter' function to the collection elements

func (Map[K, V]) ConvKey 

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

ConvKey returns a breabkable stream that applies the 'converter' function to keys of the map

func (Map[K, V]) ConvValue 

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

ConvValue returns a breakable stream that applies the 'converter' function to values of the map

func (*Map[K, V]) Convert 

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

Convert returns a stream that applies the 'converter' function to the collection elements

func (*Map[K, V]) ConvertKey 

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

ConvertKey returns a stream that applies the 'converter' function to keys of the map

func (*Map[K, V]) ConvertValue 

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

ConvertValue returns a stream that applies the 'converter' function to values of the map

func (*Map[K, V]) Delete 

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

Delete removes value by their keys from the map

func (*Map[K, V]) DeleteOne 

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

DeleteOne removes an value by the key from the map

func (*Map[K, V]) Filt 

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

Filt returns a breakable stream consisting of elements that satisfy the condition of the 'predicate' function

func (Map[K, V]) FiltKey 

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

FiltKey returns a breakable stream consisting of key/value pairs where the key satisfies the condition of the 'predicate' function

func (*Map[K, V]) FiltValue 

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

FiltValue returns a breakable stream consisting of key/value pairs where the value satisfies the condition of the 'predicate' function

func (*Map[K, V]) Filter 

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

Filter returns a stream consisting of elements that satisfy the condition of the 'predicate' function

func (*Map[K, V]) FilterKey 

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

FilterKey returns a stream consisting of key/value pairs where the key satisfies the condition of the 'predicate' function

func (*Map[K, V]) FilterValue 

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

FilterValue returns a stream consisting of key/value pairs where the value satisfies the condition of the 'predicate' function

func (*Map[K, V]) First 

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

First returns the first key/value pair of the map, an iterator to iterate over the remaining pair, and true\false marker of availability next pairs. If no more then ok==false.

func (*Map[K, V]) For 

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

For applies the 'walker' function for every key/value pair. Return the c.ErrBreak to stop.

func (*Map[K, V]) ForEach 

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

ForEach applies the 'walker' function for every element

func (*Map[K, V]) Get 

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

Get returns the value for a key. If ok==false, then the map does not contain the key.

func (*Map[K, V]) HasAny 

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

HasAny finds the first key/value pair that satisfies the 'predicate' function condition and returns true if successful

func (*Map[K, V]) Head 

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

Head creates an iterator and returns as implementation type value

func (*Map[K, V]) Immutable 

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

Immutable converts to an immutable map instance

func (*Map[K, V]) IsEmpty 

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

IsEmpty returns true if the map is empty

func (*Map[K, V]) Iter 

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

Iter creates an iterator and returns as interface

func (*Map[K, V]) Keys 

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

Keys resutrns keys collection

func (*Map[K, V]) Len 

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

Len returns amount of elements

func (*Map[K, V]) Loop 

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

Loop creates an iterator and returns as implementation type reference

func (*Map[K, V]) Map 

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

Map collects the key/value pairs to a map

func (*Map[K, V]) Reduce 

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

Reduce reduces the key/value pairs of the map into an one pair using the 'merge' function

func (*Map[K, V]) Remove 

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

Remove removes value by key and return it

func (*Map[K, V]) Set 

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

Set sets the value for a key

func (*Map[K, V]) SetMap 

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

SetMap inserts all elements from the 'other' map

func (*Map[K, V]) SetNew 

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

SetNew sets the value fo a key only if the key is not exists in the map

func (*Map[K, V]) String 

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

String string representation on the map

func (*Map[K, V]) Track 

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

Track applies the 'tracker' function for key/value pairs. Return the c.ErrBreak to stop.

func (*Map[K, V]) TrackEach 

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

TrackEach applies the 'tracker' function for every key/value pairs

func (*Map[K, V]) Values 

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

Values resutrns values collection

type Set 

type Set[T comparable] struct {
	// contains filtered or unexported fields
}

Set is a collection implementation that provides element uniqueness. The elements must be comparable.

func NewSet 

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

NewSet instantiates set and copies elements to it

func NewSetCap 

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

NewSetCap creates a set with a predefined capacity

func SetFromLoop 

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

SetFromLoop creates a set with elements retrieved by the 'next' function. The next returns an element with true or zero value with false if there are no more elements.

func WrapSet 

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

WrapSet creates a set using a map as the internal storage.

func (*Set[T]) Add 

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

Add adds elements in the collection

func (*Set[T]) AddAll 

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

AddAll inserts all elements from the "other" collection

func (*Set[T]) AddAllNew 

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

AddAllNew inserts elements from the "other" collection if they are not contained in the collection

func (*Set[T]) AddNew 

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

AddNew inserts elements if they are not contained in the collection

func (*Set[T]) AddOne 

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

AddOne adds an element in the collection

func (*Set[T]) AddOneNew 

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

AddOneNew inserts an element if it is not contained in the collection

func (*Set[T]) Append 

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

Append collects the values to the specified 'out' slice

func (*Set[T]) Clone 

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

Clone returns copy of the collection

func (*Set[T]) Contains 

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

Contains checks if the collection contains an element

func (*Set[T]) Conv 

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

Conv returns a breakable stream that applies the 'converter' function to the collection elements

func (*Set[T]) Convert 

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

Convert returns a stream that applies the 'converter' function to the collection elements

func (*Set[T]) Delete 

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

Delete removes elements from the collection

func (*Set[T]) DeleteActual 

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

DeleteActual removes elements only if they are contained in the collection

func (*Set[T]) DeleteActualOne 

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

DeleteActualOne removes an element only if it is contained in the collection

func (*Set[T]) DeleteOne 

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

DeleteOne removes an element from the collection

func (Set[T]) Filt 

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

Filt returns a breakable stream consisting of elements that satisfy the condition of the 'predicate' function

func (*Set[T]) Filter 

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

Filter returns a stream consisting of elements that satisfy the condition of the 'predicate' function

func (*Set[T]) First 

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

First returns the first element of the collection, an iterator to iterate over the remaining elements, and true\false marker of availability next elements. If no more elements then ok==false.

func (*Set[T]) For 

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

For applies the 'walker' function for the elements. Return the c.ErrBreak to stop.

func (*Set[T]) ForEach 

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

ForEach applies the 'walker' function for every element

func (*Set[K]) HasAny 

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

HasAny finds the first element that satisfies the 'predicate' function condition and returns true if successful

func (*Set[T]) Head 

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

Head creates an iterator and returns as implementation type value

func (*Set[T]) IsEmpty 

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

IsEmpty returns true if the collection is empty

func (*Set[T]) Iter 

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

Iter creates an iterator and returns as interface

func (*Set[T]) IterEdit 

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

IterEdit creates iterator that can delete iterable elements

func (*Set[T]) Len 

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

Len returns amount of the elements

func (*Set[T]) Loop 

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

Loop creates an iterator and returns as implementation type reference

func (*Set[T]) Reduce 

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

Reduce reduces the elements into an one using the 'merge' function

func (*Set[T]) Slice 

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

Slice collects the elements to a slice

func (*Set[T]) Sort 

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

Sort transforms to the ordered Set contains sorted elements

func (*Set[T]) StableSort 

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

StableSort transforms to the ordered Set contains sorted elements

func (*Set[T]) String 

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

type SetIter 

type SetIter[K comparable] struct {
	map_.KeyIter[K, struct{}]
	// contains filtered or unexported fields
}

SetIter is the Set Iterator implementation.

func NewSetIter 

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

NewSetIter creates SetIter instance.

func (*SetIter[K]) Delete 

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

Delete deletes the current element

func (*SetIter[K]) Next 

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

Next returns the next element if it exists

type SliceIter 

type SliceIter[T any] struct {
	// contains filtered or unexported fields
}

SliceIter is the Iterator implementation for mutable containers.

func NewHead 

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

NewHead instantiates Iter starting at the first element of a slice.

func NewTail 

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

NewTail instantiates Iter starting at the last element of a slice.

func (*SliceIter[T]) Cap 

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

Cap returns the iterator capacity

func (*SliceIter[T]) Delete 

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

Delete deletes the current element

func (*SliceIter[T]) DeleteNext 

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

DeleteNext deletes the next element if it exists

func (*SliceIter[T]) DeletePrev 

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

DeletePrev deletes the previos element if it exists

func (*SliceIter[T]) For 

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

For takes elements retrieved by the iterator. Can be interrupt by returning ErrBreak

func (*SliceIter[T]) ForEach 

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

ForEach FlatIter all elements retrieved by the iterator

func (*SliceIter[T]) Get 

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

Get returns the current element. The ok result indicates whether the element was returned by the iterator. If ok == false, then the iteration must be completed.

func (*SliceIter[T]) GetNext 

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

GetNext returns the next element

func (*SliceIter[T]) GetPrev 

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

GetPrev returns the previous element

func (*SliceIter[T]) HasNext 

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

HasNext checks the next element existing

func (*SliceIter[T]) HasPrev 

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

HasPrev checks the previous element existing

func (*SliceIter[T]) Next 

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

Next returns the next element. The ok result indicates whether the element was returned by the iterator. If ok == false, then the iteration must be completed.

func (*SliceIter[T]) Prev 

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

Prev returns the previous element. The ok result indicates whether the element was returned by the iterator. If ok == false, then the iteration must be completed.

type Vector 

type Vector[T any] []T

Vector is a collection implementation that provides elements order and index access

func NewVector 

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

NewVector instantiates Vector populated by the 'elements' slice

func NewVectorCap 

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

NewVectorCap instantiates Vector with a predefined capacity

func VectorFromLoop 

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

VectorFromLoop creates a vector with elements retrieved by the 'next' function. The next returns an element with true or zero value with false if there are no more elements.

func WrapVector 

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

WrapVector instantiates Vector using a slise as internal storage

func (*Vector[T]) Add 

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

Add adds elements to the end of the vector

func (*Vector[T]) AddAll 

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

AddAll inserts all elements from the "other" collection

func (*Vector[T]) AddOne 

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

AddOne adds an element to the end of the vector

func (*Vector[T]) Append 

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

Append collects the values to the specified 'out' slice

func (*Vector[T]) Clone 

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

Clone just makes a copy of the vector instance

func (*Vector[T]) Conv 

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

Conv returns a breakable stream that applies the 'converter' function to the collection elements

func (*Vector[T]) Convert 

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

Convert returns a stream that applies the 'converter' function to the collection elements

func (*Vector[T]) Delete 

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

Delete drops elements by indexes

func (*Vector[T]) DeleteActual 

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

DeleteActual drops elements by indexes with verification of no-op

func (*Vector[T]) DeleteActualOne 

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

DeleteActualOne removes an element by the index

func (*Vector[T]) DeleteOne 

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

DeleteOne removes an element by the index

func (*Vector[T]) Filt 

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

Filt returns a breakable stream consisting of elements that satisfy the condition of the 'predicate' function

func (*Vector[T]) Filter 

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

Filter returns a stream consisting of vector elements matching the filter

func (*Vector[T]) First 

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

First returns the first element of the collection, an iterator to iterate over the remaining elements, and true\false marker of availability next elements. If no more elements then ok==false.

func (*Vector[T]) For 

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

For applies the 'walker' function for the elements. Return the c.ErrBreak to stop.

func (*Vector[T]) ForEach 

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

ForEach applies walker to elements without error checking

func (*Vector[T]) Get 

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

Get returns an element by the index, otherwise, if the provided index is ouf of the vector len, returns zero T and false in the second result

func (*Vector[T]) HasAny 

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

HasAny finds the first element that satisfies the 'predicate' function condition and returns true if successful

func (*Vector[T]) Head 

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

Head creates an iterator and returns as implementation type value

func (*Vector[T]) IsEmpty 

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

IsEmpty returns true if the collection is empty

func (*Vector[T]) Iter 

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

Iter creates an iterator and returns as interface

func (*Vector[T]) IterEdit 

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

IterEdit creates iterator that can delete iterable elements

func (*Vector[T]) Last 

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

Last returns the latest element of the collection, an iterator to reverse iterate over the remaining elements, and true\false marker of availability previous elements. If no more elements then ok==false.

func (*Vector[T]) Len 

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

Len returns amount of elements

func (*Vector[T]) Loop 

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

Loop creates an iterator and returns as implementation type reference

func (*Vector[T]) Reduce 

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

Reduce reduces the elements into an one using the 'merge' function

func (*Vector[T]) Remove 

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

Remove removes and returns an element by the index

func (*Vector[T]) Set 

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

Set puts an element into the vector at the index

func (*Vector[T]) SetNew 

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

SetNew puts an element into the vector at the index

func (*Vector[T]) Slice 

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

Slice collects the elements to a slice

func (*Vector[T]) Sort 

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

Sort sorts the Vector in-place and returns it

func (*Vector[T]) StableSort 

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

StableSort stable sorts the Vector in-place and returns it

func (*Vector[T]) String 

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

String returns then string representation

func (*Vector[T]) Tail 

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

Tail creates an iterator pointing to the end of the collection

func (*Vector[T]) Track 

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

Track applies tracker to elements with error checking. Return the c.ErrBreak to stop tracking.

func (*Vector[T]) TrackEach 

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

TrackEach applies tracker to elements without error checking

Source Files

View all Source files

Directories

Path Synopsis
Package map_ provides unordered mutable.Map constructors
 Package map_ provides unordered mutable.Map constructors
Package ordered provides mutable ordered collection implementations
 Package ordered provides mutable ordered collection implementations
map_
Package map_ provides mutable ordered.Map constructors
 Package map_ provides mutable ordered.Map constructors
set
Package set provides mutable ordered.Set constructors and helpers
 Package set provides mutable ordered.Set constructors and helpers
Package set provides unordered mutable.Set constructors and helpers
 Package set provides unordered mutable.Set constructors and helpers
Package sync provides parametrized Map implementation
 Package sync provides parametrized Map implementation
Package vector provides mutable.Vector constructors and helpers
 Package vector provides mutable.Vector constructors and helpers

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.