iter

type AllOfIter[T any] interface {
	Iter[T]
	AllOf(predicate func(T) bool) bool
}

type AnyOfIter[T any] interface {
	Iter[T]
	AnyOf(predicate func(T) bool) bool
}

type CmpByIter[T any, U any] interface {
	Iter[T]
	CmpBy(other Iter[U], cmp func(T, U) int) int
}

type CmpByKeyIter[T any, K cmp.Ordered] interface {
	Iter[T]
	CmpByKey(other Iter[T], keyFn func(T) K) int
}

type CmpIter[T cmp.Ordered] interface {
	Iter[T]
	Cmp(other Iter[T]) int
}

type CountByIter[T any] interface {
	Iter[T]
	CountBy(predicate func(T) bool) int
}

type CountIter[T any] interface {
	Iter[T]
	Count() int
}

type EnumerateIter[T any] interface {
	Iter[T]
	Enumerate() Iter[tuple.Pair[int, T]]
}

type EqualByIter[T, U any] interface {
	Iter[T]
	EqualBy(other Iter[U], eq func(T, U) bool) bool
}

type EqualByKeyIter[T any, K comparable] interface {
	Iter[T]
	EqualByKey(other Iter[T], keyFn func(T) K) bool
}

type EqualIter[T comparable] interface {
	Iter[T]
	Equal(other Iter[T]) bool
}

type Extend[T any] interface{ Extend(iter Iter[T]) }

type FilterIter[T any] interface {
	Iter[T]
	Filter(f func(T) bool) Iter[T]
}

type FilterMapIter[T, U any] interface {
	Iter[T]
	FilterMap(f func(T) optional.Optional[U]) Iter[U]
}

type FindLeftIter[T any] interface {
	Iter[T]
	FindLeft(f func(T) bool) optional.Optional[T]
}

type FindMapIter[T, U any] interface {
	Iter[T]
	FindMap(f func(T) optional.Optional[U]) optional.Optional[U]
}

type FindRightIter[T any] interface {
	Iter[T]
	FindRight(f func(T) bool) optional.Optional[T]
}

type FoldLeftIter[T any, A any] interface {
	Iter[T]
	FoldLeft(init A, f func(A, T) A) A
}

type FoldRightIter[T any, A any] interface {
	PrevIter[T]
	FoldRight(init A, f func(A, T) A) A
}

type ForEachIter[T any] interface {
	Iter[T]
	ForEach(f func(T))
}

type IsSortedByIter[T any] interface {
	Iter[T]
	IsSortedBy(cmp func(T, T) int) bool
}

type IsSortedByKeyIter[T any, K cmp.Ordered] interface {
	Iter[T]
	IsSortedByKey(keyFn func(T) K) bool
}

type IsSortedIter[T cmp.Ordered] interface {
	Iter[T]
	IsSorted() bool
}

type Iter[T any] interface {
	// Next advances the iter and returns the next value.
	//
	// Returns [optional.None] when iteration is finished.
	//
	// Example:
	//  iter := slices.Iter(1, 2, 3)
	//  iter.Next() // Some(1)
	//  iter.Next() // Some(2)
	//  iter.Next() // Some(3)
	//  iter.Next() // None
	Next() optional.Optional[T]
}

type IterFunc[T any] func() optional.Optional[T]

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

type MapIter[T, U any] interface {
	Iter[T]
	Map(f func(T) U) Iter[U]
}

type MapWhileIter[T, U any] interface {
	Iter[T]
	MapWhile(f func(T) optional.Optional[U]) Iter[U]
}

type MaxByIter[T any] interface {
	Iter[T]
	MaxBy(cmp func(T, T) int) optional.Optional[T]
}

type MaxByKeyIter[T any, K cmp.Ordered] interface {
	Iter[T]
	MaxByKey(keyFn func(T) K) optional.Optional[T]
}

type MaxIter[T cmp.Ordered] interface {
	Iter[T]
	Max() optional.Optional[T]
}

type MinByIter[T any] interface {
	Iter[T]
	MinBy(cmp func(T, T) int) optional.Optional[T]
}

type MinByKeyIter[T any, K cmp.Ordered] interface {
	Iter[T]
	MinByKey(keyFn func(T) K) optional.Optional[T]
}

type MinIter[T any] interface {
	Iter[T]
	Min() optional.Optional[T]
}

type MinMaxByIter[T any] interface {
	Iter[T]
	MinMaxBy(cmp func(T, T) int) optional.Optional[tuple.Pair[T, T]]
}

type MinMaxByKeyIter[T any, K cmp.Ordered] interface {
	Iter[T]
	MinMaxByKey(keyFn func(T) K) optional.Optional[tuple.Pair[T, T]]
}

type MinMaxIter[T cmp.Ordered] interface {
	Iter[T]
	MinMax() optional.Optional[tuple.Pair[T, T]]
}

type NoneOfIter[T any] interface {
	Iter[T]
	NoneOf(predicate func(T) bool) bool
}

type PartitionIter[T any] interface {
	Iter[T]
	Partition(partition func(T) bool) (Iter[T], Iter[T])
}

type PositionLeftIter[T any] interface {
	Iter[T]
	PositionLeft(f func(T) bool) optional.Optional[int]
}

type PrevIter[T any] interface {
	Iter[T]
	Prev() optional.Optional[T]
}

type PrevIterable[T any] interface {
	PrevIter() PrevIter[T]
}

type SkipIter[T any] interface {
	Iter[T]
	Skip(n int) Iter[T]
}

type SkipWhileIter[T any] interface {
	Iter[T]
	SkipWhile(skip func(T) bool) Iter[T]
}

type StepByIter[T any] interface {
	Iter[T]
	StepBy(step int) Iter[T]
}

type TailIter[T any] interface {
	Iter[T]
	Tail() Iter[T]
}

type TakeIter[T any] interface {
	Iter[T]
	Take(n int) Iter[T]
}

type TakeWhileIter[T any] interface {
	Iter[T]
	TakeWhile(take func(T) bool) Iter[T]
}

type ToStringByIter[T any] interface {
	Iter[T]
	ToStringBy(sep string, f func(T) string) string
}

type ToStringIter[T fmt.Stringer] interface {
	Iter[T]
	ToString(sep string) string
}

type UnzipByIter[A, B, C any] interface {
	Iter[A]
	UnzipBy(unzip func(A) (B, C)) (Iter[B], Iter[C])
}

type ZipByIter[A, B, C any] interface {
	Iter[A]
	ZipBy(other Iter[B], f func(A, B) C) Iter[C]
}