iter

package
v1.3.13 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 19, 2025 License: MIT, Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AllMatch 

func AllMatch[T any](seq iter.Seq[T], test types.Predicate[T]) bool

AllMatch test if every element are all match the Predicate. 是否每个元素都满足条件 == Every

func AnyMatch 

func AnyMatch[T any](seq iter.Seq[T], test types.Predicate[T]) bool

AnyMatch test if any element matches the Predicate. 是否有任意元素满足条件 == Some

func At 

func At[T any](it iter.Seq[T], index int) (T, bool)

Return the element at index.

func Average 

func Average[T constraintsx.Number](it iter.Seq[T]) T

Returns the average of all the elements in the iterator.

func Chain 

func Chain[T any](seqs ...iter.Seq[T]) iter.Seq[T]

func ChannelAll2 

func ChannelAll2[C ~chan T, T any](c C) iter.Seq2[int, T]

func Collect 

func Collect[T any, S any, R any](it iter.Seq[T], collector interfaces.Collector[S, T, R]) R

Collecting via Collector.

func Contains 

func Contains[T comparable](it iter.Seq[T], target T) bool

Returns true if the target is included in the iterator.

func Count 

func Count[T any](seq iter.Seq[T]) (count int)

Count return the count of elements in the Seq. 返回序列中的元素个数

func Distinct 

func Distinct[T any, C comparable](seq iter.Seq[T], f types.UnaryFunction[T, C]) iter.Seq[T]

Distinct remove duplicate elements. 对序列中的元素去重

func Enumerate 

func Enumerate[T any](seq iter.Seq[T]) iter.Seq[types.Pair[int, T]]

func Every 

func Every[T any](seq iter.Seq[T], test types.Predicate[T]) bool

func Filter 

func Filter[T any](seq iter.Seq[T], test types.Predicate[T]) iter.Seq[T]

Filter keep elements which satisfy the Predicate. 保留满足断言的元素

func First 

func First[T any](seq iter.Seq[T]) (T, bool)

First find the first element in the Seq. 返回序列中的第一个元素(如有).

func FlatMap 

func FlatMap[T, R any](seq iter.Seq[T], flatten types.UnaryFunction[T, iter.Seq[R]]) iter.Seq[R]

FlatMap transform each element in Seq[T] to a new Seq[R]. 将原本序列中的每个元素都转换为一个新的序列， 并将所有转换后的序列依次连接起来生成一个新的序列

func Fold 

func Fold[T, R any](seq iter.Seq[T], initVal R, acc types.BinaryFunction[R, T, R]) (result R)

Fold accumulate each element using the BinaryFunction starting from the initial value. 从初始值开始, 通过 acc 函数累加每个元素

func ForEach 

func ForEach[T any](seq iter.Seq[T], accept types.Consumer[T])

ForEach consume every elements in the Seq. 消费序列中的每个元素

func IsEmpty 

func IsEmpty[T any](it iter.Seq[T]) bool

Ruturns true if the count of Iterator is 0.

func IsNotEmpty 

func IsNotEmpty[T any](it iter.Seq[T]) bool

Ruturns true if the count of Iterator is 0.

func IsSorted 

func IsSorted[T any](seq iter.Seq[T], cmp types.Comparator[T]) bool

IsSorted 对序列中的元素是否排序

func IterSeq 

func IterSeq[T any](iter Iterator[T]) iter.Seq[T]

func JoinBy 

func JoinBy[T any](it iter.Seq[T], toString func(T) string, sep string) string

func Last 

func Last[T any](it iter.Seq[T]) (T, bool)

Return the right element.

func Limit 

func Limit[T any](seq iter.Seq[T], limit int) iter.Seq[T]

Limit limits the number of elements in Seq. 限制元素个数

func Map 

func Map[T, R any](seq iter.Seq[T], f types.UnaryFunction[T, R]) iter.Seq[R]

Map transform the element use Fuction. 使用输入函数对每个元素进行转换

func Max 

func Max[T constraints.Ordered](it iter.Seq[T]) (T, bool)

Return the maximum value of all elements of the iterator.

func MaxBy 

func MaxBy[T any](it iter.Seq[T], greater cmp.LessFunc[T]) (T, bool)

Return the maximum value of all elements of the iterator.

func Mean 

func Mean[T constraintsx.Number](seq iter.Seq[T]) float64

Calculate the Mean of a slice of floats

func Merge 

func Merge[T any](iters ...iter.Seq[T]) iter.Seq[T]

func Min 

func Min[T constraints.Ordered](it iter.Seq[T]) (T, bool)

Return the minimum value of all elements of the iterator.

func Operator 

func Operator[T any](seq iter.Seq[T], add types.BinaryOperator[T]) T

func OperatorBy 

func OperatorBy[T any](it iter.Seq[T], f types.BinaryOperator[T]) T

func Peek 

func Peek[T any](seq iter.Seq[T], accept types.Consumer[T]) iter.Seq[T]

Peek visit every element in the Seq and leave them on the Seq. 访问序列中的每个元素而不消费它

func Product 

func Product[T constraintsx.Number](it iter.Seq[T]) T

Returns the product of all the elements in the iterator.

func RangeAll2 

func RangeAll2[T constraintsx.Number](begin, end, step T) iter.Seq2[int, T]

func Reduce 

func Reduce[T any](seq iter.Seq[T], acc types.BinaryOperator[T]) (T, bool)

Reduce accumulate each element using the binary operation. 使用给定的累加函数, 累加序列中的每个元素. 序列中可能没有元素因此返回的是 Optional

func Seq2Keys 

func Seq2Keys[K, V any](s iter.Seq2[K, V]) iter.Seq[K]

func Seq2Seq 

func Seq2Seq[K, V any](s iter.Seq2[K, V]) iter.Seq[types.Pair[K, V]]

func Seq2Values 

func Seq2Values[K, V any](s iter.Seq2[K, V]) iter.Seq[V]

func SeqSeq2 

func SeqSeq2[T any](seq iter.Seq[T]) iter.Seq2[int, T]

func Skip 

func Skip[T any](seq iter.Seq[T], skip int) iter.Seq[T]

Skip drop some elements of the Seq. 跳过指定个数的元素

func Some 

func Some[T any](seq iter.Seq[T], test types.Predicate[T]) bool

func Sorted 

func Sorted[T any](it iter.Seq[T], cmp types.Comparator[T]) iter.Seq[T]

Sorted sort elements in the Seq by Comparator. 对序列中的元素排序

func StringAll2 

func StringAll2[T ~string](input T) iter.Seq2[int, rune]

func Sum 

func Sum[T constraintsx.Number](it iter.Seq[T]) T

Returns the sum of all the elements in the iterator.

func SumComparable 

func SumComparable[T constraints.Ordered](seq iter.Seq[T]) T

func SumCount 

func SumCount[T constraintsx.Number](it iter.Seq[T]) (T, int)

Returns the sum of all the elements in the iterator.

func ToMap 

func ToMap[K comparable, V any](it iter.Seq[types.Pair[K, V]]) map[K]V

to built-in map.

func ToSlice 

func ToSlice[V any](it iter.Seq[V]) []V

func Until 

func Until[T any](seq iter.Seq[T], match types.Predicate[T]) iter.Seq[T]

func UntilComparable 

func UntilComparable[T comparable](seq iter.Seq[T], e T) iter.Seq[T]

func Unzip 

func Unzip[A any, B any](it iter.Seq[types.Pair[A, B]]) ([]A, []B)

Splitting an iterator whose elements are pair into two lists.

Types

type GoIter 

type GoIter[T any] interface {
	Iterator[T]
	Stop()
}

type Iterable 

type Iterable[T any] interface {
	Iter() Iterator[T]
}

type Iterator 

type Iterator[T any] interface {
	Next() (v T, ok bool)
}

func SeqIter 

func SeqIter[T any](seq iter.Seq[T]) Iterator[T]

type Seq 

type Seq[T any] iter.Seq[T]

func ChannelAll 

func ChannelAll[C ~chan T, T any](c C) Seq[T]

func HashMapAll 

func HashMapAll[M ~map[K]V, K comparable, V any](m M) Seq[types.Pair[K, V]]

func RangeAll 

func RangeAll[T constraintsx.Number](begin, end, step T) Seq[T]

func SliceAll 

func SliceAll[S ~[]T, T any](input S) Seq[types.Pair[int, T]]

func SliceAllValues 

func SliceAllValues[S ~[]T, T any](input S) Seq[T]

func SliceBackward 

func SliceBackward[S ~[]T, T any](input S) Seq[types.Pair[int, T]]

func SliceBackwardValues 

func SliceBackwardValues[S ~[]T, T any](input S) Seq[T]

func StringAll 

func StringAll[T ~string](input T) Seq[types.Pair[int, rune]]

func StringRunes 

func StringRunes[T ~string](input T) Seq[rune]

func (Seq[T]) All 

func (it Seq[T]) All(test types.Predicate[T]) bool

func (Seq[T]) Any 

func (it Seq[T]) Any(test types.Predicate[T]) bool

func (Seq[T]) Collect 

func (it Seq[T]) Collect() []T

func (Seq[T]) Count 

func (it Seq[T]) Count() int

func (Seq[T]) Distinct 

func (it Seq[T]) Distinct(f types.UnaryFunction[T, int]) Stream[T]

func (Seq[T]) Filter 

func (it Seq[T]) Filter(test types.Predicate[T]) Stream[T]

func (Seq[T]) First 

func (it Seq[T]) First() (T, bool)

func (Seq[T]) FlatMap 

func (it Seq[T]) FlatMap(f types.UnaryFunction[T, iter.Seq[T]]) Stream[T]

func (Seq[T]) Fold 

func (it Seq[T]) Fold(initVal T, acc types.BinaryOperator[T]) T

func (Seq[T]) ForEach 

func (it Seq[T]) ForEach(accept types.Consumer[T])

func (Seq[T]) IsSorted 

func (it Seq[T]) IsSorted(cmp types.Comparator[T]) bool

func (Seq[T]) Iter 

func (it Seq[T]) Iter() Iterator[T]

func (Seq[T]) Limit 

func (it Seq[T]) Limit(limit int) Stream[T]

func (Seq[T]) Map 

func (it Seq[T]) Map(f types.UnaryFunction[T, T]) Stream[T]

func (Seq[T]) Peek 

func (it Seq[T]) Peek(accept types.Consumer[T]) Stream[T]

func (Seq[T]) Reduce 

func (it Seq[T]) Reduce(acc types.BinaryOperator[T]) (T, bool)

func (Seq[T]) Seq 

func (it Seq[T]) Seq() iter.Seq[T]

func (Seq[T]) Skip 

func (it Seq[T]) Skip(skip int) Stream[T]

func (Seq[T]) Sorted 

func (it Seq[T]) Sorted(cmp types.Comparator[T]) Stream[T]

func (Seq[T]) Sum 

func (it Seq[T]) Sum(add types.BinaryOperator[T]) T

func (Seq[T]) Until 

func (it Seq[T]) Until(test types.Predicate[T]) Stream[T]

type Stream 

type Stream[T any] interface {
	Seq() iter.Seq[T]

	Filter(types.Predicate[T]) Stream[T]
	Map(types.UnaryFunction[T, T]) Stream[T]               //同类型转换,没啥意义
	FlatMap(types.UnaryFunction[T, iter.Seq[T]]) Stream[T] //同Map
	Peek(types.Consumer[T]) Stream[T]
	Sorted(types.Comparator[T]) Stream[T]
	Distinct(types.UnaryFunction[T, int]) Stream[T]
	Limit(int) Stream[T]
	Until(types.Predicate[T]) Stream[T]
	Skip(int) Stream[T]

	ForEach(types.Consumer[T])
	Collect() []T
	IsSorted(types.Comparator[T]) bool
	All(types.Predicate[T]) bool // every
	Any(types.Predicate[T]) bool // some
	Reduce(acc types.BinaryOperator[T]) (T, bool)
	Fold(initVal T, acc types.BinaryOperator[T]) T
	First() (T, bool)
	Count() int
	Sum(types.BinaryOperator[T]) T
}

func StreamOf 

func StreamOf[T any](seq iter.Seq[T]) Stream[T]

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.