slice

Documentation

Overview

Package slice provides generic functions for slice types

Index

• Constants
• Variables
• func BehaveAsStrings[T ~string, TS ~[]T](elements TS) []string
• func CanIterateByRange(first, last, current int) bool
• func Clone[TS ~[]T, T any](elements TS) TS
• func Contains[TS ~[]T, T comparable](elements TS, example T) bool
• func Conv[FS ~[]From, From, To any](elements FS, by func(From) (To, error)) ([]To, error)
• func Convert[FS ~[]From, From, To any](elements FS, by func(From) To) []To
• func ConvertAndFilter[FS ~[]From, From, To any](elements FS, by func(From) To, filter func(To) bool) []To
• func ConvertCheck[FS ~[]From, From, To any](elements FS, by func(from From) (To, bool)) []To
• func ConvertCheckIndexed[FS ~[]From, From, To any](elements FS, by func(index int, from From) (To, bool)) []To
• func ConvertIndexed[FS ~[]From, From, To any](elements FS, converter func(index int, from From) To) []To
• func DeepClone[TS ~[]T, T any](elements TS, copier func(T) T) TS
• func Delete[TS ~[]T, T any](index int, elements TS) TS
• func Downcast[TS ~[]T, T any](elements []T) TS
• func DowncastRef[TS ~[]T, T any](elements *[]T) *TS
• func Empty[TS ~[]T, T any](elements TS) bool
• func Filled[TS ~[]T, T any](elements TS, ifEmpty []T) TS
• func Filt[TS ~[]T, T any](elements TS, filter func(T) (bool, error)) ([]T, error)
• func Filter[TS ~[]T, T any](elements TS, filter func(T) bool) []T
• func FilterAndConvert[FS ~[]From, From, To any](elements FS, filter func(From) bool, by func(From) To) []To
• func FilterAndConvertIndexed[FS ~[]From, From, To any](elements FS, filter func(index int, from From) bool, ...) []To
• func FilterAndFlatt[FS ~[]From, From, To any](elements FS, filter func(From) bool, flattener func(From) []To) []To
• func FilterConvertFilter[FS ~[]From, From, To any](elements FS, filter func(From) bool, by func(From) To, ...) []To
• func FilterFlattFilter[FS ~[]From, From, To any](elements FS, filterFrom func(From) bool, by func(From) []To, ...) []To
• func First[TS ~[]T, T any](elements TS, by func(T) bool) (no T, ok bool)
• func Firstt[TS ~[]T, T any](elements TS, by func(T) (bool, error)) (no T, ok bool, err error)
• func Flat[FS ~[]From, From, To any](elements FS, flattener func(From) ([]To, error)) ([]To, error)
• func Flatt[FS ~[]From, From, To any](elements FS, flattener func(From) []To) []To
• func FlattAndConvert[FS ~[]From, From, I, To any](elements FS, flattener func(From) []I, convert func(I) To) []To
• func FlattAndFiler[FS ~[]From, From, To any](elements FS, by func(From) []To, filter func(To) bool) []To
• func FlattKeys[TS ~[]T, T, K any](elements TS, keysExtractor func(T) []K) []c.KV[K, T]
• func FlattValues[TS ~[]T, T, V any](elements TS, valsExtractor func(T) []V) []c.KV[T, V]
• func For[TS ~[]T, T any](elements TS, walker func(T) error) error
• func ForEach[TS ~[]T, T any](elements TS, walker func(T))
• func ForEachRef[T any, TS ~[]*T](references TS, walker func(T))
• func Generate[T any](next func() (T, bool)) []T
• func Get[TS ~[]T, T any](elements TS, current int) T
• func GetFilled[TS ~[]T, T any](elementsFactory func() TS, ifEmpty []T) TS
• func GetValues[TS ~[]*T, T any](elements TS) []T
• func Gett[TS ~[]T, T any](elements TS, current int) (element T, ok bool)
• func Group[TS ~[]T, T any, K comparable, V any](elements TS, keyExtractor func(T) K, valExtractor func(T) V) map[K][]V
• func GroupInMultiple[TS ~[]T, T any, K comparable, V any](elements TS, keysExtractor func(T) []K, valsExtractor func(T) []V) map[K][]V
• func GroupInMultipleKeys[TS ~[]T, T any, K comparable, V any](elements TS, keysExtractor func(T) []K, valExtractor func(T) V) map[K][]V
• func GroupInMultipleValues[TS ~[]T, T any, K comparable, V any](elements TS, keyExtractor func(T) K, valsExtractor func(T) []V) map[K][]V
• func Has[TS ~[]T, T any](elements TS, condition func(T) bool) bool
• func HasAny[TS ~[]T, T any](elements TS, predicate func(T) bool) bool
• func HasNext[T any](elements []T, current int) bool
• func HasNextBySize(size int, current int) bool
• func HasPrev[T any](elements []T, current int) bool
• func HasPrevBySize(size, current int) bool
• func IsValidIndex(size, index int) bool
• func Last[TS ~[]T, T any](elements TS, by func(T) bool) (no T, ok bool)
• func Lastt[TS ~[]T, T any](elements TS, by func(T) (bool, error)) (no T, ok bool, err error)
• func Len[TS ~[]T, T any](elements TS) int
• func NotEmpty[TS ~[]T, T any](elements TS) bool
• func NotNil[TS ~[]*T, T any](elements TS) TS
• func Of[T any](elements ...T) []T
• func OfLoop[S, T any](source S, hasNext func(S) bool, getNext func(S) (T, error)) ([]T, error)
• func Range[T constraints.Integer](from T, to T) []T
• func Reduce[TS ~[]T, T any](elements TS, merge func(T, T) T) T
• func Reverse[TS ~[]T, T any](elements TS) []T
• func Sort[TS ~[]T, T any](elements TS, sorter Sorter, less Less[T]) TS
• func SortByOrdered[T any, o constraints.Ordered, TS ~[]T](elements TS, sorter Sorter, by func(T) o) TS
• func StringsBehaveAs[TS ~[]T, T ~string](elements []string) TS
• func Sum[TS ~[]T, T c.Summable](elements TS) T
• func ToKV[TS ~[]T, T, K, V any](elements TS, keyExtractor func(T) K, valExtractor func(T) V) []c.KV[K, V]
• func ToKVs[TS ~[]T, T, K, V any](elements TS, keysExtractor func(T) []K, valsExtractor func(T) []V) []c.KV[K, V]
• func ToMapResolv[TS ~[]T, T any, K comparable, V, VR any](elements TS, keyExtractor func(T) K, valExtractor func(T) V, ...) map[K]VR
• func ToString[TS ~[]T, T any](elements TS) string
• func ToStringRefs[T any, TS ~[]*T](references TS) string
• func ToStringRefsf[T any, TS ~[]*T](references TS, elementFormat, nilValue, delimeter string) string
• func ToStringf[TS ~[]T, T any](elements TS, elementFormat, delimeter string) string
• func ToValues[TS ~[]*T, T any](pointers TS) []T
• func Track[TS ~[]T, T any](elements TS, tracker func(int, T) error) error
• func TrackEach[TS ~[]T, T any](elements TS, tracker func(int, T))
• func Upcast[TS ~[]T, T any](elements TS) []T
• func UpcastRef[TS ~[]T, T any](elements *TS) *[]T
• type Iter
  • func NewHead[TS ~[]T, T any](elements TS) Iter[T]
  • func NewHeadS[TS ~[]T, T any](elements TS, elementSize uintptr) Iter[T]
  • func NewIter[TS ~[]T, T any](elements TS) *Iter[T]
  • func NewTail[T any](elements []T) Iter[T]
  • func NewTailS[T any](elements []T, elementSize uintptr) Iter[T]
  • func (i *Iter[T]) Cap() int
  • func (i *Iter[T]) For(walker func(element T) error) error
  • func (i *Iter[T]) ForEach(walker func(element T))
  • func (i *Iter[T]) Get() (v T, ok bool)
  • func (i *Iter[T]) GetNext() T
  • func (i *Iter[T]) GetPrev() T
  • func (i *Iter[T]) HasNext() bool
  • func (i *Iter[T]) HasPrev() bool
  • func (i *Iter[T]) Next() (v T, ok bool)
  • func (i *Iter[T]) Prev() (v T, ok bool)
• type Less
• type Sorter

Constants

const IterNoStarted = -1

IterNoStarted is the head Iterator position

Variables

var ErrBreak = loop.ErrBreak

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

Functions

func BehaveAsStrings

func BehaveAsStrings[T ~string, TS ~[]T](elements TS) []string

BehaveAsStrings draws a string inherited type slice as the slice of strings

func CanIterateByRange

func CanIterateByRange(first, last, current int) bool

CanIterateByRange checks if an iterator can go further or stop

func Clone

func Clone[TS ~[]T, T any](elements TS) TS

Clone makes new slice instance with copied elements

func Contains

func Contains[TS ~[]T, T comparable](elements TS, example T) bool

Contains checks is the 'elements' slice contains the example

func Conv

func Conv[FS ~[]From, From, To any](elements FS, by func(From) (To, error)) ([]To, error)

Conv creates a slice consisting of the transformed elements using the converter 'by'

func Convert

func Convert[FS ~[]From, From, To any](elements FS, by func(From) To) []To

Convert creates a slice consisting of the transformed elements using the converter 'by'

func ConvertAndFilter

func ConvertAndFilter[FS ~[]From, From, To any](elements FS, by func(From) To, filter func(To) bool) []To

ConvertAndFilter additionally filters 'To' elements

func ConvertCheck

func ConvertCheck[FS ~[]From, From, To any](elements FS, by func(from From) (To, bool)) []To

ConvertCheck is similar to ConvertFit, but it checks and transforms elements together

func ConvertCheckIndexed

func ConvertCheckIndexed[FS ~[]From, From, To any](elements FS, by func(index int, from From) (To, bool)) []To

ConvertCheckIndexed additionally filters 'From' elements

func ConvertIndexed

func ConvertIndexed[FS ~[]From, From, To any](elements FS, converter func(index int, from From) To) []To

ConvertIndexed creates a slice consisting of the transformed elements using the 'converter' function which additionally applies the index of the element being converted

func DeepClone

func DeepClone[TS ~[]T, T any](elements TS, copier func(T) T) TS

DeepClone copies slice elements using a copier function and returns them as a new slice

func Delete

func Delete[TS ~[]T, T any](index int, elements TS) TS

Delete removes an element by index from the slice 'elements'

func Downcast

func Downcast[TS ~[]T, T any](elements []T) TS

Downcast transforms a slice type to an user-defined type slice based on that type

func DowncastRef

func DowncastRef[TS ~[]T, T any](elements *[]T) *TS

DowncastRef transforms a slice typeref to an user-defined type ref slice based on that type

func Empty

func Empty[TS ~[]T, T any](elements TS) bool

Empty checks whether the specified slice is empty

func Filled

func Filled[TS ~[]T, T any](elements TS, ifEmpty []T) TS

Filled returns the 'ifEmpty' if the 'elements' slise is empty

func Filt

func Filt[TS ~[]T, T any](elements TS, filter func(T) (bool, error)) ([]T, error)

Filt creates a slice containing only the filtered elements

func Filter

func Filter[TS ~[]T, T any](elements TS, filter func(T) bool) []T

Filter creates a slice containing only the filtered elements

func FilterAndConvert

func FilterAndConvert[FS ~[]From, From, To any](elements FS, filter func(From) bool, by func(From) To) []To

FilterAndConvert returns a stream that filters source elements and converts them

func FilterAndConvertIndexed

func FilterAndConvertIndexed[FS ~[]From, From, To any](elements FS, filter func(index int, from From) bool, converter func(index int, from From) To) []To

FilterAndConvertIndexed additionally filters 'From' elements

func FilterAndFlatt

func FilterAndFlatt[FS ~[]From, From, To any](elements FS, filter func(From) bool, flattener func(From) []To) []To

FilterAndFlatt filters source elements and extracts slices of 'To' by the 'flattener' function

func FilterConvertFilter

func FilterConvertFilter[FS ~[]From, From, To any](elements FS, filter func(From) bool, by func(From) To, filterConverted func(To) bool) []To

FilterConvertFilter filters source, converts, and filters converted elements

func FilterFlattFilter

func FilterFlattFilter[FS ~[]From, From, To any](elements FS, filterFrom func(From) bool, by func(From) []To, filterTo func(To) bool) []To

FilterFlattFilter unfolds the n-dimensional slice 'elements' into a n-1 dimensional slice with additinal filtering of 'From' and 'To' elements.

func First

func First[TS ~[]T, T any](elements TS, by func(T) bool) (no T, ok bool)

First returns the first element that satisfies requirements of the predicate 'by'

func Firstt

func Firstt[TS ~[]T, T any](elements TS, by func(T) (bool, error)) (no T, ok bool, err error)

Firstt returns the first element that satisfies the condition of the 'by' function

func Flat

func Flat[FS ~[]From, From, To any](elements FS, flattener func(From) ([]To, error)) ([]To, error)

Flat unfolds the n-dimensional slice into a n-1 dimensional slice

func Flatt

func Flatt[FS ~[]From, From, To any](elements FS, flattener func(From) []To) []To

Flatt unfolds the n-dimensional slice into a n-1 dimensional slice

func FlattAndConvert

func FlattAndConvert[FS ~[]From, From, I, To any](elements FS, flattener func(From) []I, convert func(I) To) []To

FlattAndConvert unfolds the n-dimensional slice into a n-1 dimensional slice and converts the elements

func FlattAndFiler

func FlattAndFiler[FS ~[]From, From, To any](elements FS, by func(From) []To, filter func(To) bool) []To

FlattAndFiler unfolds the n-dimensional slice into a n-1 dimensional slice with additinal filtering of 'To' elements.

func FlattKeys

func FlattKeys[TS ~[]T, T, K any](elements TS, keysExtractor func(T) []K) []c.KV[K, T]

FlattKeys transforms iterable elements to key/value iterator based on applying key, value extractor to the elements

func FlattValues

func FlattValues[TS ~[]T, T, V any](elements TS, valsExtractor func(T) []V) []c.KV[T, V]

FlattValues transforms iterable elements to key/value iterator based on applying key, value extractor to the elements

func For

func For[TS ~[]T, T any](elements TS, walker func(T) error) error

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

func ForEach

func ForEach[TS ~[]T, T any](elements TS, walker func(T))

ForEach applies the 'walker' function for the elements

func ForEachRef

func ForEachRef[T any, TS ~[]*T](references TS, walker func(T))

ForEachRef applies the 'walker' function for the references

func Generate

func Generate[T any](next func() (T, bool)) []T

Generate builds a slice by an generator function. The generator returns an element, or false if the generation is over, or an error.

func Get

func Get[TS ~[]T, T any](elements TS, current int) T

Get safely returns an element of the 'elements' slice by the 'current' index or return zero value of T if the index is more than size-1 or less 0

func GetFilled

func GetFilled[TS ~[]T, T any](elementsFactory func() TS, ifEmpty []T) TS

GetFilled returns the 'notEmpty' if the 'elementsFactory' return an empty slice

func GetValues

func GetValues[TS ~[]*T, T any](elements TS) []T

GetValues returns values referenced by the pointers. All nil pointers are excluded from the final result.

func Gett

func Gett[TS ~[]T, T any](elements TS, current int) (element T, ok bool)

Gett safely returns an element of the 'elements' slice by the 'current' index or return zero value of T if the index is more than size-1 or less 0 ok == true if success

func Group

func Group[TS ~[]T, T any, K comparable, V any](elements TS, keyExtractor func(T) K, valExtractor func(T) V) map[K][]V

Group converts the 'elements' slice into a map, extracting a key for each element applying the converter 'keyExtractor'. The keyExtractor converts an element to a key. The valExtractor converts an element to an value.

func GroupInMultiple

func GroupInMultiple[TS ~[]T, T any, K comparable, V any](elements TS, keysExtractor func(T) []K, valsExtractor func(T) []V) map[K][]V

GroupInMultiple converts the 'elements' slice into a map, extracting multiple keys, values per each element applying the 'keysExtractor' and 'valsExtractor' functions. The keysExtractor retrieves one or more keys per element. The valsExtractor retrieves one or more values per element.

func GroupInMultipleKeys

func GroupInMultipleKeys[TS ~[]T, T any, K comparable, V any](elements TS, keysExtractor func(T) []K, valExtractor func(T) V) map[K][]V

GroupInMultipleKeys converts the 'elements' slice into a map, extracting multiple keys, one value per each element applying the 'keysExtractor' and 'valExtractor' functions. The keysExtractor retrieves one or more keys per element. The valExtractor converts an element to a value.

func GroupInMultipleValues

func GroupInMultipleValues[TS ~[]T, T any, K comparable, V any](elements TS, keyExtractor func(T) K, valsExtractor func(T) []V) map[K][]V

GroupInMultipleValues converts the 'elements' slice into a map, extracting one key, multiple values per each element applying the 'keyExtractor' and 'valsExtractor' functions. The keyExtractor converts an element to a key. The valsExtractor retrieves one or more values per element.

func Has

func Has[TS ~[]T, T any](elements TS, condition func(T) bool) bool

Has checks is the 'elements' slice contains a value that satisfies the specified condition

func HasAny

func HasAny[TS ~[]T, T any](elements TS, predicate func(T) bool) bool

HasAny tests if the 'elements' slice contains an element that satisfies the "predicate" condition

func HasNext

func HasNext[T any](elements []T, current int) bool

HasNext checks if an iterator can go forward

func HasNextBySize

func HasNextBySize(size int, current int) bool

HasNextBySize checks if an iterator can go forward

func HasPrev

func HasPrev[T any](elements []T, current int) bool

HasPrev checks if an iterator can go backwards

func HasPrevBySize

func HasPrevBySize(size, current int) bool

HasPrevBySize checks if an iterator can go backwards

func IsValidIndex

func IsValidIndex(size, index int) bool

IsValidIndex checks if index is out of range

func Last

func Last[TS ~[]T, T any](elements TS, by func(T) bool) (no T, ok bool)

Last returns the latest element that satisfies requirements of the predicate 'filter'

func Lastt

func Lastt[TS ~[]T, T any](elements TS, by func(T) (bool, error)) (no T, ok bool, err error)

Lastt returns the latest element that satisfies requirements of the predicate 'filter'

func Len

func Len[TS ~[]T, T any](elements TS) int

Len return the length of the 'elements' slice

func NotEmpty

func NotEmpty[TS ~[]T, T any](elements TS) bool

NotEmpty checks whether the specified slice is not empty

func NotNil

func NotNil[TS ~[]*T, T any](elements TS) TS

NotNil returns only not nil elements

func Of

func Of[T any](elements ...T) []T

Of is generic slice constructor

func OfLoop

func OfLoop[S, T any](source S, hasNext func(S) bool, getNext func(S) (T, error)) ([]T, error)

OfLoop builds a slice by iterating elements of a source. The hasNext specifies a predicate that tests existing of a next element in the source. The getNext extracts the element.

func Range

func Range[T constraints.Integer](from T, to T) []T

Range generates a slice of integers in the range defined by from and to inclusive.

func Reduce

func Reduce[TS ~[]T, T any](elements TS, merge func(T, T) T) T

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

func Reverse

func Reverse[TS ~[]T, T any](elements TS) []T

Reverse inverts elements order

func Sort

func Sort[TS ~[]T, T any](elements TS, sorter Sorter, less Less[T]) TS

Sort sorts elements in place using a function that checks if an element is smaller than the others

func SortByOrdered

func SortByOrdered[T any, o constraints.Ordered, TS ~[]T](elements TS, sorter Sorter, by func(T) o) TS

SortByOrdered sorts elements in place by converting them to constraints.Ordered values and applying the operator <

func StringsBehaveAs

func StringsBehaveAs[TS ~[]T, T ~string](elements []string) TS

StringsBehaveAs draws a string slice as the slice of a string inherited type

func Sum

func Sum[TS ~[]T, T c.Summable](elements TS) T

Sum returns the sum of all elements

func ToKV

func ToKV[TS ~[]T, T, K, V any](elements TS, keyExtractor func(T) K, valExtractor func(T) V) []c.KV[K, V]

ToKV transforms slice elements to key/value pairs slice. One pair per one element

func ToKVs

func ToKVs[TS ~[]T, T, K, V any](elements TS, keysExtractor func(T) []K, valsExtractor func(T) []V) []c.KV[K, V]

ToKVs transforms slice elements to key/value pairs slice. Multiple pairs per one element

func ToMapResolv

func ToMapResolv[TS ~[]T, T any, K comparable, V, VR any](elements TS, keyExtractor func(T) K, valExtractor func(T) V, resolver func(bool, K, VR, V) VR) map[K]VR

ToMapResolv collects key\value elements to a map by iterating over the elements with resolving of duplicated key values

func ToString

func ToString[TS ~[]T, T any](elements TS) string

ToString converts the elements to their default string representation

func ToStringRefs

func ToStringRefs[T any, TS ~[]*T](references TS) string

ToStringRefs converts references to the default string representation

func ToStringRefsf

func ToStringRefsf[T any, TS ~[]*T](references TS, elementFormat, nilValue, delimeter string) string

ToStringRefsf converts references to a string representation defined by the delimiter and the nilValue representation

func ToStringf

func ToStringf[TS ~[]T, T any](elements TS, elementFormat, delimeter string) string

ToStringf converts the elements to a string representation defined by the elementFormat and a delimiter

func ToValues

func ToValues[TS ~[]*T, T any](pointers TS) []T

ToValues returns values referenced by the pointers. If a pointer is nil then it is replaced by the zero value.

func Track

func Track[TS ~[]T, T any](elements TS, tracker func(int, T) error) error

Track applies the 'tracker' function to the elements. Return the c.ErrBreak to stop tracking

func TrackEach

func TrackEach[TS ~[]T, T any](elements TS, tracker func(int, T))

TrackEach applies the 'tracker' function to the elements

func Upcast

func Upcast[TS ~[]T, T any](elements TS) []T

Upcast transforms a user-defined type slice to a underlying slice type

func UpcastRef

func UpcastRef[TS ~[]T, T any](elements *TS) *[]T

UpcastRef transforms a user-defined reference type slice to a underlying slice reference type

Types

type Iter

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

Iter is the Iterator implementation.

func NewHead

func NewHead[TS ~[]T, T any](elements TS) Iter[T]

NewHead instantiates Iter based on elements slice

func NewHeadS

func NewHeadS[TS ~[]T, T any](elements TS, elementSize uintptr) Iter[T]

NewHeadS instantiates Iter based on elements slice with predefined element size

func NewIter

func NewIter[TS ~[]T, T any](elements TS) *Iter[T]

NewIter instantiates an iterator based on the 'elements' slice

func NewTail

func NewTail[T any](elements []T) Iter[T]

NewTail instantiates Iter based on elements slice for reverse iterating

func NewTailS

func NewTailS[T any](elements []T, elementSize uintptr) Iter[T]

NewTailS instantiates Iter based on elements slice with predefined element size for reverse iterating

func (*Iter[T]) Cap

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

Cap returns the iterator capacity

func (*Iter[T]) For

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

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

func (*Iter[T]) ForEach

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

ForEach takes all elements retrieved by the iterator.

func (*Iter[T]) Get

func (i *Iter[T]) Get() (v 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 (*Iter[T]) GetNext

func (i *Iter[T]) GetNext() T

GetNext returns the next element

func (*Iter[T]) GetPrev

func (i *Iter[T]) GetPrev() T

GetPrev returns the previous element

func (*Iter[T]) HasNext

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

HasNext checks the next element existing

func (*Iter[T]) HasPrev

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

HasPrev checks the previous element existing

func (*Iter[T]) Next

func (i *Iter[T]) Next() (v T, ok 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 (*Iter[T]) Prev

func (i *Iter[T]) Prev() (v T, ok bool)

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

type Less

type Less[T any] func(first, second T) bool

Less less element qualifier alias. Is a function that must return true it the first element is less the second

type Sorter

type Sorter func(x any, less func(i, j int) bool)

Sorter is alias for sort.Slice or SliceStable functions