package 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

Example (Any)

Code: 

{
	// `Any` function that simply returns the boolean identity
	anyBool := Any(F.Identity[bool])

	fmt.Println(anyBool(FromArray(A.From(true, false, false))))
	fmt.Println(anyBool(FromArray(A.From(false, false, false))))
	fmt.Println(anyBool(Empty[bool]()))

	// Output:
	// true
	// false
	// false
}

Output:

true
false
false
Example (Next)

Code: 

{

	seq := MakeBy(F.Identity[int])

	first := seq()

	value := F.Pipe1(
		first,
		O.Map(Current[int]),
	)

	fmt.Println(value)

	// Output:
	// Some[int](0)
}

Output:

Some[int](0)

Index

Examples

Functions

func Any 

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 

func Ap[V, U any](ma Iterator[U]) func(Iterator[func(U) V]) Iterator[V]

Ap is the applicative functor for iterators

func ApS 

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 

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 

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 

func Chain[U, V any](f func(U) Iterator[V]) func(Iterator[U]) Iterator[V]

func ChainFirst 

func ChainFirst[U, V any](f func(U) Iterator[V]) func(Iterator[U]) Iterator[U]

func Compress 

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 Current 

func Current[U any](m P.Pair[Iterator[U], U]) U

Current returns the current element in an Iterator `P.Pair`

func DropWhile 

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 Filter 

func Filter[U any](f func(U) bool) func(ma Iterator[U]) Iterator[U]

Filter filters the content of an iterator

func FilterChain 

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 

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 

func First[U any](mu Iterator[U]) O.Option[U]

First returns the first item in an iterator if such an item exists

func Fold 

func Fold[U any](m M.Monoid[U]) func(Iterator[U]) U

Fold folds the iterator using the provided Monoid.

func FoldMap 

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

Code: 

{
	src := From("a", "b", "c")

	fold := FoldMap[string](S.Monoid)(strings.ToUpper)

	fmt.Println(fold(src))

	// Output: ABC

}

Output:

ABC

func Last 

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 

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 

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 Map 

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 

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 Monoid 

func Monoid[U any]() M.Monoid[Iterator[U]]

Monoid contructs a [M.Monoid] that concatenates two [Iterator]s

func Reduce 

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 Scan 

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 Take 

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 

func ToArray[U any](u Iterator[U]) []U

ToArray converts the iterator to an array

func Uniq 

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 

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

Types

type Iterator 

type Iterator[U any] L.Lazy[O.Option[P.Pair[Iterator[U], U]]]

Iterator represents a stateless, pure way to iterate over a sequence

func Count 

func Count(start int) Iterator[int]

Count creates an Iterator containing a consecutive sequence of integers starting with the provided start value

func Cycle 

func Cycle[U any](ma 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 Do 

func Do[S any](
	empty S,
) Iterator[S]

Bind creates an empty context of type [S] to be used with the Bind operation

func Empty 

func Empty[U any]() Iterator[U]

Empty returns the empty iterator

func Flatten 

func Flatten[U any](ma Iterator[Iterator[U]]) Iterator[U]

Flatten converts an Iterator of Iterator into a simple Iterator

func From 

func From[U any](data ...U) Iterator[U]

From constructs an Iterator from a set of variadic arguments

func FromArray 

func FromArray[U any](as []U) Iterator[U]

FromArray returns an iterator from multiple elements

func FromIO 

func FromIO[U any](io IO.IO[U]) Iterator[U]

FromIO returns an Iterator on top of an IO function

func FromLazy 

func FromLazy[U any](l L.Lazy[U]) Iterator[U]

FromLazy returns an Iterator on top of a lazy function

func FromReflect 

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 MakeBy 

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 MonadAp 

func MonadAp[V, U any](fab Iterator[func(U) V], ma Iterator[U]) Iterator[V]

MonadAp is the applicative functor for iterators

func MonadChain 

func MonadChain[U, V any](ma Iterator[U], f func(U) Iterator[V]) Iterator[V]

func MonadChainFirst 

func MonadChainFirst[U, V any](ma Iterator[U], f func(U) Iterator[V]) Iterator[U]

func MonadMap 

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 Next 

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 

func Of[U any](a U) Iterator[U]

Of returns an iterator with one single element

func Repeat 

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 

func Replicate[U any](a U) Iterator[U]

Replicate creates an Iterator containing a value repeated an infinite number of times.

func StrictUniq 

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 ZipWith 

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.

Source Files

any.go bind.go compress.go cycle.go doc.go dropwhile.go first.go io.go iterator.go last.go monad.go monoid.go reflect.go scan.go take.go uniq.go zip.go

Directories

PathSynopsis
iterator/stateless/generic
Version
v1.0.151 (latest)
Published
Nov 23, 2024
Platform
linux/amd64
Imports
8 packages
Last checked
4 months ago –

Tools for package owners.