iterator/stateless
import "github.com/IBM/fp-go/iterator/stateless"
Package stateless defines a stateless (pure) iterator, i.e. one that can be iterated over multiple times without side effects, it is threadsafe
Functions
func Any[U any](pred func(U) bool) func(ma Iterator[U]) bool
Any returns true if any element of the iterable is true. If the iterable is empty, return false
Similar to the [https://docs.python.org/3/library/functions.html#any] function
func Ap[V, U any](ma Iterator[U]) func(Iterator[func(U) V]) Iterator[V]
Ap is the applicative functor for iterators
func ApS[S1, S2, T any]( setter func(T) func(S1) S2, fa Iterator[T], ) func(Iterator[S1]) Iterator[S2]
ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
func Bind[S1, S2, T any]( setter func(T) func(S1) S2, f func(S1) Iterator[T], ) func(Iterator[S1]) Iterator[S2]
Bind attaches the result of a computation to a context [S1] to produce a context [S2]
func BindTo[S1, T any]( setter func(T) S1, ) func(Iterator[T]) Iterator[S1]
BindTo initializes a new state [S1] from a value [T]
func Chain[U, V any](f func(U) Iterator[V]) func(Iterator[U]) Iterator[V]
func ChainFirst[U, V any](f func(U) Iterator[V]) func(Iterator[U]) Iterator[U]
func Compress[U any](sel Iterator[bool]) func(Iterator[U]) Iterator[U]
Compress returns an [Iterator] that filters elements from a data [Iterator] returning only those that have a corresponding element in selector [Iterator] that evaluates to true.
Stops when either the data or selectors iterator has been exhausted.
func Count(start int) Iterator[int]
Count creates an [Iterator] containing a consecutive sequence of integers starting with the provided start value
func Current[U any](m P.Pair[Iterator[U], U]) U
Current returns the current element in an [Iterator] P.Pair
func Cycle[U any](ma Iterator[U]) Iterator[U]
Cycle creates an [Iterator] containing an [Iterator] repeated an infinite number of times.
func Do[S any]( empty S, ) Iterator[S]
Bind creates an empty context of type [S] to be used with the [Bind] operation
func DropWhile[U any](pred func(U) bool) func(Iterator[U]) Iterator[U]
DropWhile creates an [Iterator] that drops elements from the [Iterator] as long as the predicate is true; afterwards, returns every element. Note, the [Iterator] does not produce any output until the predicate first becomes false
func Empty[U any]() Iterator[U]
Empty returns the empty iterator
func Filter[U any](f func(U) bool) func(ma Iterator[U]) Iterator[U]
Filter filters the content of an iterator
func FilterChain[U, V any](f func(U) O.Option[Iterator[V]]) func(ma Iterator[U]) Iterator[V]
FilterChain filters and transforms the content of an iterator
func FilterMap[U, V any](f func(U) O.Option[V]) func(ma Iterator[U]) Iterator[V]
FilterMap filters and transforms the content of an iterator
func First[U any](mu Iterator[U]) O.Option[U]
First returns the first item in an iterator if such an item exists
func Flatten[U any](ma Iterator[Iterator[U]]) Iterator[U]
Flatten converts an [Iterator] of [Iterator] into a simple [Iterator]
func Fold[U any](m M.Monoid[U]) func(Iterator[U]) U
Fold folds the iterator using the provided Monoid.
func FoldMap[U, V any](m M.Monoid[V]) func(func(U) V) func(ma Iterator[U]) V
FoldMap maps and folds an iterator. Map the iterator passing each value to the iterating function. Then fold the results using the provided Monoid.
Example
{
src := From("a", "b", "c")
fold := FoldMap[string](S.Monoid)(strings.ToUpper)
fmt.Println(fold(src))
}Output:
ABCfunc From[U any](data ...U) Iterator[U]
From constructs an [Iterator] from a set of variadic arguments
func FromArray[U any](as []U) Iterator[U]
FromArray returns an iterator from multiple elements
func FromIO[U any](io IO.IO[U]) Iterator[U]
FromIO returns an [Iterator] on top of an IO function
func FromLazy[U any](l L.Lazy[U]) Iterator[U]
FromLazy returns an [Iterator] on top of a lazy function
func FromReflect(val R.Value) Iterator[R.Value]
FromReflect creates an iterator that can iterate over types that define [R.Index] and [R.Len]
func Last[U any](mu Iterator[U]) O.Option[U]
Last returns the last item in an iterator if such an item exists Note that the function will consume the [Iterator] in this call completely, to identify the last element. Do not use this for infinite iterators
func Let[S1, S2, T any]( setter func(T) func(S1) S2, f func(S1) T, ) func(Iterator[S1]) Iterator[S2]
Let attaches the result of a computation to a context [S1] to produce a context [S2]
func LetTo[S1, S2, T any]( setter func(T) func(S1) S2, b T, ) func(Iterator[S1]) Iterator[S2]
LetTo attaches the a value to a context [S1] to produce a context [S2]
func MakeBy[FCT ~func(int) U, U any](f FCT) Iterator[U]
MakeBy returns an [Iterator] with an infinite number of elements initialized with f(i)
func Map[U, V any](f func(U) V) func(ma Iterator[U]) Iterator[V]
Map transforms an [Iterator] of type [U] into an [Iterator] of type [V] via a mapping function
func Monad[A, B any]() monad.Monad[A, B, Iterator[A], Iterator[B], Iterator[func(A) B]]
Monad returns the monadic operations for an [Iterator]
func MonadAp[V, U any](fab Iterator[func(U) V], ma Iterator[U]) Iterator[V]
MonadAp is the applicative functor for iterators
func MonadChain[U, V any](ma Iterator[U], f func(U) Iterator[V]) Iterator[V]
func MonadChainFirst[U, V any](ma Iterator[U], f func(U) Iterator[V]) Iterator[U]
func MonadMap[U, V any](ma Iterator[U], f func(U) V) Iterator[V]
MonadMap transforms an [Iterator] of type [U] into an [Iterator] of type [V] via a mapping function
func Monoid[U any]() M.Monoid[Iterator[U]]
Monoid contructs a [M.Monoid] that concatenates two [Iterator]s
func Next[U any](m P.Pair[Iterator[U], U]) Iterator[U]
Next returns the [Iterator] for the next element in an iterator P.Pair
func Of[U any](a U) Iterator[U]
Of returns an iterator with one single element
func Reduce[U, V any](f func(V, U) V, initial V) func(Iterator[U]) V
Reduce applies a function for each value of the iterator with a floating result
func Repeat[U any](n int, a U) Iterator[U]
Repeat creates an [Iterator] containing a value repeated the specified number of times. Alias of [Replicate]
func Replicate[U any](a U) Iterator[U]
Replicate creates an [Iterator] containing a value repeated an infinite number of times.
func Scan[FCT ~func(V, U) V, U, V any](f FCT, initial V) func(ma Iterator[U]) Iterator[V]
Scan takes an [Iterator] and returns a new [Iterator] of the same length, where the values
of the new [Iterator] are the result of the application of f to the value of the
source iterator with the previously accumulated value
func StrictUniq[A comparable](as Iterator[A]) Iterator[A]
StrictUniq converts an [Iterator] of arbitrary items into an [Iterator] or unique items where uniqueness is determined by the built-in uniqueness constraint
func Take[U any](n int) func(ma Iterator[U]) Iterator[U]
Take limits the number of values in the [Iterator] to a maximum number
func ToArray[U any](u Iterator[U]) []U
ToArray converts the iterator to an array
func Uniq[A any, K comparable](f func(A) K) func(as Iterator[A]) Iterator[A]
Uniq converts an [Iterator] of arbitrary items into an [Iterator] or unique items where uniqueness is determined based on a key extractor function
func Zip[A, B any](fb Iterator[B]) func(Iterator[A]) Iterator[P.Pair[A, B]]
Zip takes two iterators and returns an iterators of corresponding pairs. If one input iterators is short, excess elements of the longer iterator are discarded
func ZipWith[FCT ~func(A, B) C, A, B, C any](fa Iterator[A], fb Iterator[B], f FCT) Iterator[C]
ZipWith applies a function to pairs of elements at the same index in two iterators, collecting the results in a new iterator. If one input iterator is short, excess elements of the longer iterator are discarded.
Types
type Iterator
Iterator represents a stateless, pure way to iterate over a sequence
type Iterator[U any] L.Lazy[O.Option[P.Pair[Iterator[U], U]]]