iter

type BackwardMovable ¶

type BackwardMovable[It Iter[any]] interface {
	Prev() It
}

BackwardMovable represents iterators that can move backward.

type BidiIter ¶

type BidiIter[T any, It Iter[T]] interface {
	ForwardIter[T, It]
	BackwardMovable[It]
}

BidiIter is an iterator that moves both forward or backward.

type BidiReadWriter ¶

type BidiReadWriter[T any, It Iter[T]] interface {
	BidiIter[T, It]
	ReadWriter[T]
}

BidiReadWriter is an interface that groups BidiIter and ReadWriter.

type BidiReader ¶

type BidiReader[T any, It Iter[T]] interface {
	BidiIter[T, It]
	Reader[T]
}

BidiReader is an interface that groups BidiIter and Reader.

type BidiWriter ¶

type BidiWriter[T any, It Iter[T]] interface {
	BidiIter[T, It]
	Writer[T]
}

BidiWriter is an interface that groups BidiIter and Writer.

type Chan ¶

type Chan[Elem any] interface {
	~chan Elem
}

Chan is a constraint that matches channels of any element type.

type Comparable ¶

type Comparable[It Iter[any]] interface {
	Eq(It) bool
}

Comparable represents an iterator that can be compared.

type Complex ¶

type Complex interface {
	~complex64 | ~complex128
}

Complex is a constraint that permits any complex numeric type. If future releases of Go add new predeclared complex numeric types, this constraint will be modified to include them.

type Float ¶

type Float interface {
	~float32 | ~float64
}

Float is a constraint that permits any floating-point type. If future releases of Go add new predeclared floating-point types, this constraint will be modified to include them.

type ForwardIter ¶

type ForwardIter[T any, It Iter[T]] interface {
	ForwardMovable[It]
	Comparable[It]
	AllowMultiplePass() // a marker indicates it can be multiple passed.
}

ForwardIter is an iterator that moves forward.

type ForwardMovable ¶

type ForwardMovable[It Iter[any]] interface {
	Next() It
}

ForwardMovable represents iterators that can move forward.

type ForwardReadWriter ¶

type ForwardReadWriter[T any, It Iter[T]] interface {
	ForwardIter[T, It]
	ReadWriter[T]
}

ForwardReadWriter is an interface that groups ForwardIter and ReadWriter.

type ForwardReader ¶

type ForwardReader[T any, It Iter[T]] interface {
	ForwardIter[T, It]
	Reader[T]
}

ForwardReader is an interface that groups ForwardIter and Reader.

type ForwardWriter ¶

type ForwardWriter[T any, It Iter[T]] interface {
	ForwardIter[T, It]
	Writer[T]
}

ForwardWriter is an interface that groups ForwardIter and Writer.

type InputIter ¶

type InputIter[T any, It Iter[T]] interface {
	Reader[T]
	ForwardMovable[It]
	Comparable[It]
}

InputIter is a readable and forward movable iterator.

type Integer ¶

type Integer interface {
	Signed | Unsigned
}

Integer is a constraint that permits any integer type. If future releases of Go add new predeclared integer types, this constraint will be modified to include them.

type Iter ¶

type Iter[T any] interface{}

Iter represents an iterator, just an alias of any.

type Map ¶

type Map[Key comparable, Val any] interface {
	~map[Key]Val
}

Map is a constraint that matches maps of any element and value type.

type Numeric ¶

type Numeric interface {
	Integer | Float
}

Numeric is a constraint that permits any numeric type.

type Ordered ¶

type Ordered interface {
	Integer | Float | ~string
}

Ordered is a constraint that permits any ordered type: any type that supports the operators < <= >= >. If future releases of Go add new ordered types, this constraint will be modified to include them.

type OutputIter ¶

type OutputIter[T any] interface {
	Writer[T]
}

OutputIter is a writable and ForwardMovable iterator.

It may not implement the incremental interface, in which case the increment logic is done in Write().

type RandomIter ¶

type RandomIter[T any, It Iter[T]] interface {
	BidiIter[T, It]
	AdvanceN(n int) It
	Distance(It) int
	Less(It) bool
}

RandomIter is a random access iterator.

type RandomReadWriter ¶

type RandomReadWriter[T any, It Iter[T]] interface {
	RandomIter[T, It]
	ReadWriter[T]
}

RandomReadWriter is an interface that groups RandomIter and ReadWriter.

type RandomReader ¶

type RandomReader[T any, It Iter[T]] interface {
	RandomIter[T, It]
	Reader[T]
}

RandomReader is an interface that groups RandomIter and Reader.

type RandomWriter ¶

type RandomWriter[T any, It Iter[T]] interface {
	RandomIter[T, It]
	Writer[T]
}

RandomWriter is an interface that groups RandomIter and Writer.

type ReadWriter ¶

type ReadWriter[T any] interface {
	Reader[T]
	Writer[T]
}

ReadWriter is an interface that groups Reader and Writer.

type Reader ¶

type Reader[T any] interface {
	Read() T
}

Reader is a readable iterator.

type Signed ¶

type Signed interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64
}

Signed is a constraint that permits any signed integer type. If future releases of Go add new predeclared signed integer types, this constraint will be modified to include them.

type Slice ¶

type Slice[Elem any] interface {
	~[]Elem
}

Slice is a constraint that matches slices of any element type.

type Unsigned ¶

type Unsigned interface {
	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}

Unsigned is a constraint that permits any unsigned integer type. If future releases of Go add new predeclared unsigned integer types, this constraint will be modified to include them.

type Writer ¶

type Writer[T any] interface {
	Write(T)
}

Writer is a writable iterator.