c

Documentation

Overview

Package c provides common types of containers, utility types and functions

Index

• Variables
• type Access
• type Addable
• type AddableAll
• type AddableAllNew
• type AddableNew
• type All
• type Checkable
• type Collection
• type Convertable
• type DelIterator
• type Deleteable
• type DeleteableVerify
• type Filterable
• type For
• type ForEach
• type ImmutableMapConvert
• type Iterable
• type Iterator
• type KV
  • func (k KV[K, V]) Get() (K, V)
  • func (k KV[K, V]) Key() K
  • func (k KV[K, V]) Value() V
• type KVAll
• type KeyVal
• type Keys
• type MapFactory
• type Number
• type PrevIterator
• type Removable
• type Settable
• type SettableMap
• type SettableNew
• type Sized
• type SliceFactory
• type Summable
• type Track
• type TrackEach
• type Values

Variables

var Break = errors.New("Break")

Break is the 'break' statement of the For, Track methods

var Continue error = nil

Continue is an alias of the nil value used to continue iterating by For, Track methods.

Types

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

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

AddableAll provides appending the collection by elements retrieved from another collection

type AddableAllNew

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

AddableAllNew provides appending the collection by elements retrieved from another collection

type AddableNew

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

AddableNew provides appending the collection by elements.

type All

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

All provides the `All` function used for iterating over a sequence of elements by `for e := range collection.All`. Supported since go 1.22.

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 {
	For[T]
	ForEach[T]
	SliceFactory[T]

	Reduce(merge func(T, T) T) T
	HasAny(func(T) bool) bool
}

Collection is the base interface of non-associative collections

type Convertable

type Convertable[T any, Loop ~func() (T, bool), LoopErr ~func() (T, bool, error)] interface {
	Convert(converter func(T) T) Loop
	Conv(converter func(T) (T, error)) LoopErr
}

Convertable provides converaton of collection elements functionality

type DelIterator

type DelIterator[T any] interface {
	Iterator[T]
	Delete()
}

DelIterator is the Iterator provides deleting of current element.

type Deleteable

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

Deleteable provides removing any elements from the collection.

type DeleteableVerify

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

DeleteableVerify provides removing any elements from the collection.

type Filterable

type Filterable[T any, Loop ~func() (T, bool), LoopErr ~func() (T, bool, error)] interface {
	Filter(predicate func(T) bool) Loop
	Filt(predicate func(T) (bool, error)) LoopErr
}

Filterable provides filtering content functionality

type For

type For[IT any] interface {
	//For takes elements of the collection. Can be interrupt by returning Break.
	For(func(element IT) error) error
}

For is the interface of a collection that provides traversing of the elements.

type ForEach

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

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

ImmutableMapConvert provides converting to an immutable map instance.

type Iterable

type Iterable[T any, Loop ~func() (T, bool)] interface {
	Loop() Loop
}

Iterable is a loop supplier interface

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)

	For[T]
	ForEach[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 (KV[K, V]) Get

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

Get returns the key/value pair

func (KV[K, V]) Key

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

Key returns the key

func (KV[K, V]) Value

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

Value returns the value

type KVAll

type KVAll[K, V any] interface {
	All(consumer func(K, V) bool)
}

KVAll provides the `All` function used for iterating over a sequence of key\value pairs by `for k, v := range collection.All`. Supported since go 1.22.

type KeyVal

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

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

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

type MapFactory

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 Number

type Number interface {
	constraints.Integer | constraints.Float | constraints.Complex
}

Number is a type that supports the operators +, -, /, *

type PrevIterator

type PrevIterator[T any] interface {
	Iterator[T]
	//retrieves a prev element and true or zero value of T and false if no more elements
	Prev() (T, bool)
}

PrevIterator is the Iterator that provides reverse iteration over elements of a collection

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

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

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

type SettableNew

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

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

Sized - storage interface with measurable size

type SliceFactory

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

SliceFactory collects the elements of the collection into a slice

type Summable

type Summable interface {
	constraints.Ordered | constraints.Complex | string
}

Summable is a type that supports the operator +

type Track

type Track[P any, T any] interface {
	// return Break for loop breaking
	Track(func(position P, element T) error) error
}

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

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

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

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