Documentation
¶
Index ¶
- func All[T any](iter Iterator[T], f func(x T) bool) bool
- func Any[T any](iter Iterator[T], f func(x T) bool) bool
- func Find[T any](iter Iterator[T], f func(x T) bool) (int, Option[T])
- func Fold[T any, R any](iter Iterator[T], init R, f func(_acc R, _elem T) R) R
- func MapReduce[T, R any](iter Iterator[T], init R, mapper func(x T) R, reducer func(R, R) R) R
- func ParMapReduce[T, R any](iter Iterator[T], init R, mapper func(x T) R, reducer func(R, R) R) R
- func Partitioned[T any](iter Iterator[T], f func(x T) bool) (Iterator[T], Iterator[T])
- type Iterator
- func ChunkSlice[T any](iter Iterator[T], size int) Iterator[[]T]
- func Concat[T any](iterators ...Iterator[T]) Iterator[T]
- func Empty[T any]() Iterator[T]
- func FlatMap[T, R any](iter Iterator[T], mapper func(x T) Iterator[R]) Iterator[R]
- func Flatten[T any](iterators Iterator[Iterator[T]]) Iterator[T]
- func FromChannel[T any](inCh <-chan T) Iterator[T]
- func FromMap[K comparable, V any](m map[K]V) Iterator[Pair[K, V]]
- func FromSlice[T any](xs []T) Iterator[T]
- func FromValues[T any](xs ...T) Iterator[T]
- func Intersperse[T any](iter Iterator[T], sep T) Iterator[T]
- func Map[T any, R any](iter Iterator[T], f func(T) R) Iterator[R]
- func Once[T any](x T) Iterator[T]
- func OnceWith[T any](f func() T) Iterator[T]
- func ParMap[T, R any](iter Iterator[T], f func(x T) R) Iterator[R]
- func ParMapUnord[T, R any](iter Iterator[T], f func(x T) R) Iterator[R]
- func Range(from int, to int) Iterator[int]
- func RangeInclusive(first int, last int) Iterator[int]
- func Repeat[T any](x T) Iterator[T]
- func RepeatN[T any](x T, num int) Iterator[T]
- func Select[T any](buffer int64, iters ...Iterator[T]) Iterator[T]
- func Successor[T any](init Option[T], f func(T) Option[T]) Iterator[T]
- func TailAppender[T any](buffer int64) (Iterator[T], chan<- Option[T])
- func WithIndex[T any](iter Iterator[T]) Iterator[Pair[int64, T]]
- func Zip[T, P any](lhs Iterator[T], rhs Iterator[P]) Iterator[Pair[T, P]]
- func (iter Iterator[T]) AdvanceBy(num int) Iterator[T]
- func (iter Iterator[T]) Chain(other Iterator[T]) Iterator[T]
- func (iter Iterator[T]) Count() int
- func (iter Iterator[T]) CountIf(fi func(x T) bool) int
- func (iter Iterator[T]) Cycle() Iterator[T]
- func (iter Iterator[T]) Filter(f func(x T) bool) Iterator[T]
- func (iter Iterator[T]) ForEach(f func(T))
- func (iter Iterator[T]) ForEachWithIndex(f func(int, T))
- func (iter Iterator[T]) Last() Option[T]
- func (iter Iterator[T]) Next() Option[T]
- func (iter Iterator[T]) Reduce(init T, f func(T, T) T) T
- func (iter Iterator[T]) Slice() []T
- func (iter Iterator[T]) String(sep string) string
- func (iter Iterator[T]) Tail() Iterator[T]
- func (iter Iterator[T]) Take(num int) Iterator[T]
- type Pair
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Find ¶
Find returns the element index and the element if it is found; otherwise returns (-1, None); Caller should check if the element "IsNone" before consuming the index.
func Fold ¶
Fold is haskell's foldLeft It takes each element out of the iterator, apply a computation `f func(_acc R, _elem T) R` then update the init value; When there is no more element to process, it returns the init value as the final result.
func ParMapReduce ¶
Types ¶
type Iterator ¶
type Iterator[T any] struct { // contains filtered or unexported fields }
Iterator is essentially a generic read-channel with behaviors. The write-end of the channel must signal the termination by sending through a None value.
func ChunkSlice ¶
ChunkSlice given an iterator that yields: 1, 2, 3, 4, 5 ...... n given a chunk size of p It produces a new iterator that yields a slice of p elements at a time (or less) from the original sequence: (1, 2, 3 ... p), (p+1, .... p+p), ...
func Concat ¶
Concat creates a new iterator from an arbitrary number of iterators of type Iterator[T], concatenating their elements
func FromChannel ¶ added in v0.0.6
func FromValues ¶ added in v0.0.4
func Intersperse ¶
Intersperse creates a new Iterator of the same type. It yields each element from the original iterator, inserting <sep> between two adjacent elements, e.g. given 1, 2, 3, 4 ... and sep = 100 it produces 1, 100, 2, 100, 3, 100, 4 ...
func Map ¶
Map applies a function to each element and produces a new value; The results are yield in the new iterator.
func ParMap ¶
ParMap respects the original order, but this causes significant overhead. If order is not important, use ParMapUnord instead. See parmap_test.go for a rough comparison between these two versions.
func ParMapUnord ¶
ParMapUnord disregard the order but can achieve better performance.
func Successor ¶
Successor is copycat of Rust's successor function. It is an iterator-creator (or source). It repeatedly applies f to init (an Option[T]), yielding the result, till init becomes None. You can think of it as a series defined in the recursive form: Pn+1 = F( Pn )
func TailAppender ¶
func Zip ¶
Zip takes two iterators (with element type T and P), returning a new iterator that yields Pair[T, P]. The number of pairs is determined by the shortest iterator, i.e. Zip(lhs, rhs).Count() == min(lhs.Count(), rhs.Count())
func (Iterator[T]) AdvanceBy ¶
AdvanceBy advances the iterator position by <num> which is equivalent to repeatedly calling Next() <num> times
func (Iterator[T]) Chain ¶
Chain is a simpler form of Concat: It concatenates itself and another iterator of the same type.
func (Iterator[T]) CountIf ¶
CountIf applies a filter function to each element. It counts the number of elements passing the check.
func (Iterator[T]) Cycle ¶
Cycle creates an infinite sequence using the given iterator; When it yields the last element from the original iterator, it repeats the sequence from the first element again.
func (Iterator[T]) Filter ¶
Filter applies a function to each element and gets a boolean value. If the value is true, the element is included in the resulting new iterator, otherwise it is discarded.
func (Iterator[T]) ForEach ¶
func (iter Iterator[T]) ForEach(f func(T))
ForEach applies a function to each element and discard the result.
func (Iterator[T]) ForEachWithIndex ¶ added in v0.0.4
ForEachWithIndex adds the element index for the caller's convenience;
func (Iterator[T]) Reduce ¶
func (iter Iterator[T]) Reduce(init T, f func(T, T) T) T
Reduce to apply f to each pair of elements concurrently and feed the result back to the input o o o o o o o o o o o .... ^^^ ^^^ ^^^ ^^^ ^^^
o o o o o
^^^^^ ^^^^^
o o
^^^^^^^^^
o
Source Files
¶
- chain.go
- chunk_slice.go
- concat.go
- count.go
- cycle.go
- empty.go
- enumerate.go
- filter.go
- find.go
- flatmap.go
- flatten.go
- fold.go
- foreach.go
- fromchannel.go
- frommap.go
- fromslice.go
- fromvalues.go
- intersperse.go
- iterator.go
- map.go
- once.go
- pair.go
- parmap.go
- partition.go
- predicates.go
- range.go
- reduce.go
- repeat.go
- select.go
- slice.go
- string.go
- successor.go
- tail_appender.go
- take.go
- testutils.go
- zip.go
Directories