seq

func Convert ¶

func Convert[S ~seq[From], From, To any](seq S, converter func(From) To) Seq[To]

Convert creates an iterator that applies the 'converter' function to each iterable element.

func ConvertNilSafe ¶ added in v0.0.17

func ConvertNilSafe[S ~seq[*From], From, To any](seq S, converter func(*From) *To) Seq[*To]

ConvertNilSafe creates a seq that filters not nil elements, converts that ones, filters not nils after converting and returns them.

func ConvertOK ¶ added in v0.0.15

func ConvertOK[S ~seq[From], From, To any](seq S, converter func(from From) (To, bool)) Seq[To]

ConvertOK creates an iterator that applies the 'converter' function to each iterable element. The converter may returns a value or ok=false to exclude the value from the sequence.

func Filter ¶

func Filter[S ~seq[T], T any](seq S, filter func(T) bool) Seq[T]

Filter creates an iterator that iterates only those elements for which the 'filter' function returns true.

func Flat ¶

func Flat[S ~seq[From], STo ~[]To, From any, To any](seq S, flattener func(From) STo) Seq[To]

Flat is used to iterate over a two-dimensional sequence in single dimension form, like:

var arrays iter.Seq[[]int]
...
for e := range seq.Flat(arrays, as.Is) {
    ...
}

func FlatSeq ¶ added in v0.0.15

func FlatSeq[S ~seq[From], STo ~seq[To], From any, To any](seq S, flattener func(From) STo) Seq[To]

FlatSeq is used to iterate over a two-dimensional sequence in single dimension form, like:

var arrays iter.Seq[[]int]
...
for e := range s.FlatSeq(arrays, slices.Values) {
    ...
}

func NotNil ¶ added in v0.0.17

func NotNil[T any](seq Seq[*T]) Seq[*T]

NotNil returns the seq without nil elements.

func Of ¶

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

Of creates an iterator over the elements.

func OfIndexed ¶ added in v0.0.15

func OfIndexed[T any](amount int, getAt func(int) T) Seq[T]

OfIndexed builds a Seq iterator by extracting elements from an indexed source. the len is length ot the source. the getAt retrieves an element by its index from the source.

func OfNext ¶ added in v0.0.15

func OfNext[T any](hasNext func() bool, pushNext func(*T)) Seq[T]

OfNext builds an iterator by iterating elements of a source. The hasNext specifies a predicate that tests existing of a next element in the source. The pushNext copy the element to the next pointer.

func OfNextGet ¶ added in v0.0.15

func OfNextGet[T any](hasNext func() bool, getNext func() T) Seq[T]

OfNextGet builds an iterator 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 OfSourceNext ¶ added in v0.0.15

func OfSourceNext[S, T any](source S, hasNext func(S) bool, pushNext func(S, *T)) Seq[T]

OfSourceNext builds an iterator by iterating elements of the source. The hasNext specifies a predicate that tests existing of a next element in the source. The pushNext copy the element to the next pointer.

func OfSourceNextGet ¶ added in v0.0.15

func OfSourceNextGet[S, T any](source S, hasNext func(S) bool, getNext func(S) T) Seq[T]

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

func Range ¶ added in v0.0.15

func Range[T constraints.Integer | rune](from T, toExclusive T) Seq[T]

Range creates a sequence that generates integers in the range defined by from and to exclusive

func RangeClosed ¶ added in v0.0.15

func RangeClosed[T constraints.Integer | rune](from T, toInclusive T) Seq[T]

RangeClosed creates a sequence that generates integers in the range defined by from and to inclusive

func Series ¶ added in v0.0.15

func Series[T any](first T, next func(T) (T, bool)) Seq[T]

Series makes a sequence by applying the 'next' function to the previous step generated value.

func Skip ¶ added in v0.0.15

func Skip[S ~seq[T], T any](n int, seq S) Seq[T]

Skip returns the seq without first n elements.

func SkipWhile ¶ added in v0.0.16

func SkipWhile[S ~seq[T], T any](seq S, filter func(T) bool) Seq[T]

SkipWhile returns a sequence without first elements of the seq that dont'math the filter.

func Top ¶ added in v0.0.15

func Top[S ~seq[T], T any](n int, seq S) Seq[T]

Top returns a sequence of top n elements.

func Union ¶ added in v0.0.15

func Union[S ~seq[T], T any](seq ...S) Seq[T]

Union combines several sequences into one.

func While ¶ added in v0.0.16

func While[S ~seq[T], T any](seq S, filter func(T) bool) Seq[T]

While cuts tail elements of the seq that don't match the filter.

func KeyValues ¶ added in v0.0.15

func KeyValues[S ~seq[T], T, K, V any](seq S, keyExtractor func(T) K, valsExtractor func(T) []V) Seq2[K, V]

KeyValues converts the seq iterator to a key/value pairs iterator by applying the key, values extractors to each iterable element.

func Of2 ¶ added in v0.0.17

func Of2[T any](elements ...T) Seq2[int, T]

Of2 creates an index/value pairs iterator over the elements.

func ToKV ¶ added in v0.0.17

func ToKV[S ~seq[T], T, K, V any](seq S, keyExtractor func(T) K, valExtractor func(T) V) Seq2[K, V]

ToKV converts the seq iterator to a key/value pairs iterator by applying the key, value extractors to each iterable element.

func ToSeq2 ¶

func ToSeq2[S ~seq[T], T, K, V any](seq S, converter func(T) (K, V)) Seq2[K, V]

ToSeq2 converts an iterator of single elements to an iterator of key/value pairs by applying the 'converter' function to each iterable element.

func Conv ¶

func Conv[S ~seq[From], From, To any](seq S, converter func(From) (To, error)) SeqE[To]

Conv creates an errorable seq that applies the 'converter' function to the iterable elements. The error should be checked at every iteration step, like:

var integers iter.Seq[int]
...
for s, err := range seq.Conv(integers,  strconv.Itoa) {
    if err != nil {
        break
    }
    ...
}

func ConvOK ¶ added in v0.0.15

func ConvOK[S ~seq[From], From, To any](seq S, converter func(from From) (To, bool, error)) SeqE[To]

ConvOK creates a iterator that applies the 'converter' function to each iterable element. The converter may returns a value or ok=false to exclude the value from iteration. It may also return an error to abort the iteration.

func Filt ¶

func Filt[S ~seq[T], T any](seq S, filter func(T) (bool, error)) SeqE[T]

Filt creates an erroreable iterator that iterates only those elements for which the 'filter' function returns true.

func Flatt ¶ added in v0.0.15

func Flatt[S ~seq[From], STo ~[]To, From any, To any](seq S, flattener func(From) (STo, error)) SeqE[To]

Flatt is used to iterate over a two-dimensional sequence in single dimension form, like:

var (
	input     iter.Seq[[]string]
	flattener func([]string) ([]int, error)
	out       seq.SeqE[int]

)

flattener = convertEveryBy(strconv.Atoi)
out = seq.Flatt(input, flattener)
for i, err := range out {
	if err != nil {
		panic(err)
	}
	...
}

func FlattSeq ¶ added in v0.0.15

func FlattSeq[S ~seq[From], STo ~seqE[To], From any, To any](seq S, flattener func(From) STo) SeqE[To]

FlattSeq is used to iterate over a two-dimensional sequence in single dimension form, like:

var (
	input     iter.Seq[[]string]
	flattener func([]string) seq.SeqE[int]
	out       seq.SeqE[int]

)

flattener = convertEveryBy(strconv.Atoi)
out = seq.Flatt(input, flattener)
for i, err := range out {
	if err != nil {
		panic(err)
	}
	...
}