c

type Access ¶

type Access[P any, V any] interface {
	Get(P) (V, bool)
}

Access provides access to an element by its pointer (index, key, coordinate, etc.) Where:

P - a type of pointer to a value (index, map key, coordinates)
V - any arbitrary type of the value

type Addable ¶

type Addable[T any] interface {
	Add(...T)
	AddOne(T)
}

Addable provides appending the collection by elements.

type AddableAll ¶ added in v0.0.7

type AddableAll[Iterable any] interface {
	AddAll(Iterable)
}

AddableAll provides appending the collection by elements retrieved from another collection

type AddableAllNew ¶ added in v0.0.7

type AddableAllNew[Iterable any] interface {
	AddAllNew(Iterable) bool
}

AddableAllNew provides appending the collection by elements retrieved from another collection

type AddableNew ¶ added in v0.0.7

type AddableNew[T any] interface {
	AddNew(...T) bool
	AddOneNew(T) bool
}

AddableNew provides appending the collection by elements.

type Checkable ¶

type Checkable[T any] interface {
	Contains(T) bool
}

Checkable is container with ability to check if an element is present.

type Collection ¶

type Collection[T any] interface {
	Sized
	Range[T]
	ForEach[T]
	SliceFactory[T]

	Head() (T, bool)
	First(func(T) bool) (T, bool)
	Reduce(merge func(T, T) T) T

	HasAny(func(T) bool) bool
}

Collection is the base interface of non-associative collections

type Convertable ¶ added in v0.0.7

type Convertable[T any, Seq ~func(yield func(T) bool), SeqE ~func(yield func(T, error) bool)] interface {
	Convert(converter func(T) T) Seq
	Conv(converter func(T) (T, error)) SeqE
}

Convertable provides converaton of collection elements functionality

type Deleteable ¶

type Deleteable[k any] interface {
	Delete(...k)
	DeleteOne(k)
}

Deleteable provides removing any elements from the collection.

type DeleteableVerify ¶ added in v0.0.7

type DeleteableVerify[k any] interface {
	DeleteActual(...k) bool
	DeleteActualOne(k) bool
}

DeleteableVerify provides removing any elements from the collection.

type Filterable ¶ added in v0.0.7

type Filterable[T any, Seq ~func(yield func(T) bool), SeqE ~func(yield func(T, error) bool)] interface {
	Filter(predicate func(T) bool) Seq
	Filt(predicate func(T) (bool, error)) SeqE
}

Filterable provides filtering content functionality

type ForEach ¶ added in v0.0.12

type ForEach[T any] interface {
	// ForEach takes all elements of the collection
	ForEach(func(element T))
}

ForEach is the interface of a collection that provides traversing of the elements without error checking.

type ImmutableMapConvert ¶ added in v0.0.7

type ImmutableMapConvert[M any] interface {
	Immutable() M
}

ImmutableMapConvert provides converting to an immutable map instance.

type Iterator ¶

type Iterator[T any] interface {
	// 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.
	Next() (out T, ok bool)

	ForEach[T]
	Range[T]
}

Iterator provides iterate over elements of a collection

type KV ¶

type KV[k any, v any] struct {
	K k
	V v
}

KV is the simplest implementation of a key/value pair.

func (k KV[K, V]) Get() (K, V)

func (k KV[K, V]) Key() K

func (k KV[K, V]) Value() V

type KVRange ¶ added in v0.0.15

type KVRange[K, V any] interface {
	All(yield func(K, V) bool)
}

KVRange provides an All function used for iterating over a sequence of key\value pairs by `for k, v := range collection.All`.

type KeyVal ¶ added in v0.0.7

type KeyVal[K, V any] interface {
	Keys[K]
	Values[V]
}

KeyVal provides access to all keys and values of a key/value based collection.

type Keys ¶ added in v0.0.13

type Keys[K any] interface {
	Keys() K
}

Keys provides access to all keys of a key/value based collection.

type MapFactory ¶ added in v0.0.7

type MapFactory[K comparable, V any, Map map[K]V | map[K][]V] interface {
	Map() Map
}

MapFactory collects the key/value pairs of the collection into a new map

type OrderedRange ¶ added in v0.0.15

type OrderedRange[T any] interface {
	IAll(yield func(int, T) bool)
}

OrderedRange provides an IAll function used for iterating over an ordered sequence of elements by `for i, e := range collection.IAll`.

type Range ¶ added in v0.0.15

type Range[T any] interface {
	All(yield func(T) bool)
}

Range provides an All function used for iterating over a sequence of elements by `for e := range collection.All`.

type Removable ¶

type Removable[P any, V any] interface {
	Remove(P) (V, bool)
}

Removable provides removing an element by its pointer (index or key).

type Settable ¶

type Settable[P any, V any] interface {
	Set(key P, value V)
}

Settable provides element insertion or replacement by its pointer (index or key).

type SettableMap ¶ added in v0.0.7

type SettableMap[Map any] interface {
	SetMap(m Map)
}

SettableMap provides element insertion or replacement with an equal key element of a map.

type SettableNew ¶ added in v0.0.7

type SettableNew[P any, V any] interface {
	SetNew(key P, value V) bool
}

SettableNew provides element insertion by its pointer (index or key) only if the specified place is not occupied.

type Sized ¶ added in v0.0.4

type Sized interface {
	// returns an estimated internal storage size or -1 if the size cannot be calculated
	Len() int
}

Sized - storage interface with measurable size

type SliceFactory ¶ added in v0.0.7

type SliceFactory[T any] interface {
	Slice() []T
	Append([]T) []T
}

SliceFactory collects the elements of the collection into a slice

type TrackEach ¶

type TrackEach[P any, T any] interface {
	TrackEach(func(position P, element T))
}

TrackEach is the interface of a collection that provides traversing of the elements with position tracking (index, key, coordinates, etc.) without error checking.

type Values ¶ added in v0.0.13

type Values[V any] interface {
	Values() V
}

Values provides access to all values of a key/value based collection.