generics

Documentation

Index

• Variables
• func All[Elem any](iterable Iterable[Elem], fn func(Elem) (bool, error)) (bool, error)
• func Any[Elem any](iterable Iterable[Elem], fn func(Elem) (bool, error)) (bool, error)
• func Each[Elem any](iterable Iterable[Elem], fn func(Elem) error) error
• func Find[Elem any](iterable Iterable[Elem], fn func(Elem) (bool, error)) (item Elem, err error)
• func FindLast[Elem any](iterable Iterable[Elem], fn func(Elem) (bool, error)) (item Elem, err error)
• func First[K, V, Elem any](c Collection[K, V, Elem]) (first Elem, err error)
• func Last[K, V, Elem any](c Collection[K, V, Elem]) (last Elem, err error)
• func Max[V, Elem any](iterable Iterable[Elem], comparator func(V, V) CompareResult) (max Elem, err error)
• func Min[V, Elem any](iterable Iterable[Elem], comparator func(V, V) CompareResult) (min Elem, err error)
• type Collection
  • func GroupBy[K, V, Elem any](c Collection[K, V, Elem], gfactory func() Collection[K, V, Elem], ...) (r Collection[K, V, Elem], err error)
  • func OrderBy[K, V, Elem any](c Collection[K, V, Elem], comparator func(V, V) CompareResult) (r Collection[K, V, Elem])
  • func Select[K, V, Elem, NewK, NewV, NewElem any](c Collection[K, V, Elem], n Collection[NewK, NewV, NewElem], ...) (Collection[NewK, NewV, NewElem], error)
  • func Skip[K, V any, Elem any](c Collection[K, V, Elem], n int) (r Collection[K, V, Elem])
  • func Take[K, V any, Elem any](c Collection[K, V, Elem], n int) (r Collection[K, V, Elem])
  • func Where[K, V, Elem any](c Collection[K, V, Elem], fn func(Elem) (bool, error)) (r Collection[K, V, Elem], err error)
• type Comparable
• type CompareResult
  • func NumericComparator[V LTGTConstraint](a, b V) CompareResult
  • func StringComparator(a, b string) CompareResult
• type Gettable
• type Iterable
• type Iterator
  • func NewIterator[T any](owner Iterable[T], args ...any) (it *Iterator[T])
  • func (it *Iterator[T]) Close()
  • func (it *Iterator[T]) Error() error
  • func (it *Iterator[T]) IterationDone()
  • func (it *Iterator[T]) Next() <-chan T
  • func (it *Iterator[T]) NextChannel() chan<- T
  • func (it *Iterator[T]) SetError(err error)
• type LTGTConstraint
• type Ptr
• type Settable
• type Sizable
• type Slicable

Variables

var ErrNotComparable = errors.New("collection not comparable")

var ErrNotFound = errors.New("item not found")

Functions

func All

func All[Elem any](iterable Iterable[Elem], fn func(Elem) (bool, error)) (bool, error)

All returns true if all items in the collection match the predicate.

func Any

func Any[Elem any](iterable Iterable[Elem], fn func(Elem) (bool, error)) (bool, error)

Any returns true if any item in the collection matches the predicate.

func Each

func Each[Elem any](iterable Iterable[Elem], fn func(Elem) error) error

Each iterates over the collection and calls the given function for each item.

func Find

func Find[Elem any](iterable Iterable[Elem], fn func(Elem) (bool, error)) (item Elem, err error)

Find returns the first item in the collection that matches the predicate.

func FindLast

func FindLast[Elem any](iterable Iterable[Elem], fn func(Elem) (bool, error)) (item Elem, err error)

FindLast returns the last item in the collection that matches the predicate.

func First

func First[K, V, Elem any](c Collection[K, V, Elem]) (first Elem, err error)

First returns the first item in the collection.

func Last

func Last[K, V, Elem any](c Collection[K, V, Elem]) (last Elem, err error)

Last returns the last item in the collection.

func Max

func Max[V, Elem any](iterable Iterable[Elem], comparator func(V, V) CompareResult) (max Elem, err error)

Max returns the maximum item in the collection.

func Min

func Min[V, Elem any](iterable Iterable[Elem], comparator func(V, V) CompareResult) (min Elem, err error)

Min returns the minimum item in the collection.

Types

type Collection

type Collection[K, V, Elem any] interface {
	Sizable
	Gettable[K, V]
	Settable[K, V, Elem]
	Iterable[Elem]

	// Factory returns a new collection of the same type.
	Factory() Collection[K, V, Elem]

	// FactoryFrom returns a new collection of the same type, initialized with the given elements.
	FactoryFrom([]V) Collection[K, V, Elem]

	// Clone returns a copy of the collection.
	Clone() Collection[K, V, Elem]

	// AsCollection returns the collection as a Collection[K, V, Elem].
	AsCollection() Collection[K, V, Elem]
}

Collection is a generic interface for collections. It is implemented by all collections in this package.

The generic parameters are:

	K: the key type
	V: the value type
 Elem: iterator element type, usually a Tuple[K, V]

func GroupBy

func GroupBy[K, V, Elem any](
	c Collection[K, V, Elem],
	gfactory func() Collection[K, V, Elem],
	keySelector func(Elem) (K, error),
) (r Collection[K, V, Elem], err error)

GroupBy returns a new collection grouped by the given key selector.

returns a slice of collections, each one containing the elements that match the key.

func OrderBy

func OrderBy[K, V, Elem any](c Collection[K, V, Elem], comparator func(V, V) CompareResult) (r Collection[K, V, Elem])

OrderBy returns a new collection ordered by the given comparator.

func Select

func Select[K, V, Elem, NewK, NewV, NewElem any](
	c Collection[K, V, Elem],
	n Collection[NewK, NewV, NewElem],
	fn func(Elem) (NewElem, error)) (Collection[NewK, NewV, NewElem], error)

Select returns a new collection with the items transformed by the given function. The n collection is the mapped collection, and it's preferred to be empty.

func Skip

func Skip[K, V any, Elem any](c Collection[K, V, Elem], n int) (r Collection[K, V, Elem])

Skip returns a new collection with the first n items skipped.

func Take

func Take[K, V any, Elem any](c Collection[K, V, Elem], n int) (r Collection[K, V, Elem])

Take returns a new collection with the first n items.

func Where

func Where[K, V, Elem any](c Collection[K, V, Elem], fn func(Elem) (bool, error)) (r Collection[K, V, Elem], err error)

Where returns a new collection with the items that match the predicate.

type Comparable

type Comparable[V, Iter any] interface {
	Compare(Iter, Iter, func(V, V) CompareResult) CompareResult
}

type CompareResult

type CompareResult int

const (
	LessThan CompareResult = iota
	EqualTo
	GreaterThan
)

func NumericComparator

func NumericComparator[V LTGTConstraint](a, b V) CompareResult

NumericComparator is a comparator for numeric types included in LTGTConstraint. It's meant to be used as compare handler in Comparable.Compare.

func StringComparator

func StringComparator(a, b string) CompareResult

StringComparator is a comparator for strings. It's meant to be used as compare handler in Comparable.Compare.

type Gettable

type Gettable[K, V any] interface {
	Get(K) V
	Values() []V
}

Gettable is a generic interface for collections that support reading.

type Iterable

type Iterable[T any] interface {
	// Iter returns an iterator for the collection.
	Iter() *Iterator[T]

	// IterHandler is the iterator handler goroutine.
	IterHandler(*Iterator[T])

	// AsIterable returns the iterator type.
	AsIterable() Iterable[T]
}

type Iterator

type Iterator[T any] struct {
	context.Context

	Args []any
	// contains filtered or unexported fields
}

Iterator is a generic iterator used to iterate over Collection. Use Iterator.Close for early loop termination.

func NewIterator

func NewIterator[T any](owner Iterable[T], args ...any) (it *Iterator[T])

NewIterator returns a new iterator. Used by owner.Iter().

func (*Iterator[T]) Close

func (it *Iterator[T]) Close()

Close stops the iterator. Used to stop iteration early.

func (*Iterator[T]) Error

func (it *Iterator[T]) Error() error

Error returns the error on the iterator. Used by Iterable.IterHandler to signal an error.

func (*Iterator[T]) IterationDone

func (it *Iterator[T]) IterationDone()

IterationDone closes the iterator channel. Used by Iterable.IterHandler to signal that iteration is done.

func (*Iterator[T]) Next

func (it *Iterator[T]) Next() <-chan T

Next returns the next item in the iterator.

Each time Next is called, current item will be returned and goroutine will read the next item. This might be costly for collections that a single iteration is heavy.

func (*Iterator[T]) NextChannel

func (it *Iterator[T]) NextChannel() chan<- T

NextChannel returns the receiving channel to be returned by Next(). used by Iterable.IterHandler to send items.

func (*Iterator[T]) SetError

func (it *Iterator[T]) SetError(err error)

SetError sets the error on the iterator. Used by Iterable.IterHandler to signal an error.

type LTGTConstraint

type LTGTConstraint interface {
	int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | uintptr | float32 | float64
}

LTGTConstraint is a constraint that requires the type to implement the < and > operators.

type Ptr

type Ptr[T any] interface {
	*T
}

type Settable

type Settable[K, V, Elem any] interface {
	Set(K, V)
	SetElem(Elem)
	Delete(K)
	Clear()
	AppendElem(Elem)
}

Settable is a generic interface for collections that support writing.

type Sizable

type Sizable interface {
	Len() int
	Cap() int
	IsEmpty() bool
}

Sizable is a generic interface for collections that can be sized.

type Slicable

type Slicable interface {
	Slice(start, end int) Slicable
}

Slicable is a collection that can be sliced.