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 Checkable
• type Collection
• type Convertable
• type DelIterator
• type Deleteable
• type DeleteableVerify
• type Filterable
• type ForEachLoop
• type ForLoop
• type ImmutableMapConvert
• type IterFor
• 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 KeyVal
• type MapFactory
• type Number
• type PrevIterator
• type Removable
• type Settable
• type SettableMap
• type SettableNew
• type Sized
• type SliceFactory
• type Summable
• type TrackEachLoop
• type TrackLoop

Variables

var ErrBreak = errors.New("Break")

ErrBreak is the 'break' statement of the 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 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 {
	Iterable[T]
	ForLoop[T]
	ForEachLoop[T]
	SliceFactory[T]

	Reduce(merger func(T, T) T) T
}

Collection is the base interface of non-associative collections

type Convertable

type Convertable[T, Stream, StreamBreakable any] interface {
	Convert(converter func(T) T) Stream
	Conv(converter func(T) (T, error)) StreamBreakable
}

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, Stream, StreamBreakable any] interface {
	Filter(predicate func(T) bool) Stream
	Filt(predicate func(T) (bool, error)) StreamBreakable
}

Filterable provides filtering content functionality

type ForEachLoop

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

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

type ForLoop

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

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

type ImmutableMapConvert

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

ImmutableMapConvert provides converting to an immutable map instance.

type IterFor

type IterFor[T any, I Iterator[T]] interface {
	// Start is used with for loop construct.
	// Returns the iterator itself, the first element, and ok == false if the iteration must be completed.
	//
	// 	var i IterFor = ...
	// 	for i, val, ok := i.Start(); ok; val, ok = i.Next() {
	//  	_ = val
	//	}
	Start() (iterator I, val T, ok bool)
}

IterFor extends an iterator type by a 'Start' function implementation

type Iterable

type Iterable[T any] interface {
	Iter() Iterator[T]
}

Iterable is an iterator 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)

	ForLoop[T]
	ForEachLoop[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 KeyVal

type KeyVal[Keys any, Vals any] interface {
	Keys() Keys
	Values() Vals
}

KeyVal provides extracing of a keys or values collection from key/value pairs

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 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 capacity or -1 if the capacity cannot be calculated
	Cap() int
}

Sized - storage interface with measurable capacity

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 TrackEachLoop

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

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

type TrackLoop

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

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