sequence

Dec 19, 2023

Changes in this version

type Sequence

+ func Inspect[T any](s Sequence[T], inspect func(int, T) error) Sequence[T]

+ func (s Sequence[T]) Inspect(inspect func(int, T) error) Sequence[T]

Dec 15, 2023

Changes in this version

type Result

+ func NextResultErr[In, Out any](in Result[In], f func(In) (Out, error)) Result[Out]

Dec 15, 2023

Changes in this version

+ type Result struct

+ func MakeResult[T any](value T, err error) Result[T]

+ func NextResult[In, Out any](in Result[In], f func(In) (Out, error)) Result[Out]

+ func ResultError[T any](err error) Result[T]

+ func ResultValue[T any](value T) Result[T]

+ func (r Result[T]) Clean() Result[T]

+ func (r Result[T]) DropError() Result[T]

+ func (r Result[T]) Error() error

+ func (r Result[T]) HasError() bool

+ func (r Result[T]) Pair() (T, error)

+ func (r Result[T]) Value() T

type Sequence

+ func (s Sequence[T]) Count() Result[int]

Dec 12, 2023

Changes in this version

type Sequence

+ func SimulateOne[T any](prev Sequence[T], step func(T) T) Sequence[T]

+ func (s Sequence[T]) SimulateOne(step func(T) T) Sequence[T]

Dec 11, 2023

Changes in this version

type Sequence

+ func Simulate[T any](prev Sequence[T], step func(T) (T, bool)) Sequence[T]

+ func Simulation[T any](initial T, step func(T) (T, bool)) Sequence[T]

+ func (s Sequence[T]) Simulate(step func(T) (T, bool)) Sequence[T]

Dec 8, 2023

Changes in this version

+ func IntoMap[M ~map[K]V, K comparable, V any](dst M, s Sequence[Pair[K, V]]) error

+ func ToMap[K comparable, V any](s Sequence[Pair[K, V]]) (map[K]V, error)

+ func Unzip[A, B any](s Sequence[Pair[A, B]]) (Sequence[A], Sequence[B])

type Sequence

+ func FromMap[K comparable, V any](m map[K]V) Sequence[Pair[K, V]]

Dec 7, 2023

Changes in this version

+ func PairCompareFirst[A cmp.Ordered, B any](a, b Pair[A, B]) int

+ func PairCompareSecond[A, B cmp.Ordered](a, b Pair[A, B]) int

+ func PairCompare[A, B cmp.Ordered](a, b Pair[A, B]) int

type Sequence

+ func Reverse[T any](s Sequence[T]) Sequence[T]

+ func SortOrdered[T cmp.Ordered](s Sequence[T]) Sequence[T]

+ func SortStable[T any](s Sequence[T], cmp func(a, b T) int) Sequence[T]

+ func Sort[T any](s Sequence[T], cmp func(a, b T) int) Sequence[T]

+ func (s Sequence[T]) Reverse() Sequence[T]

+ func (s Sequence[T]) Sort(cmp func(T, T) int) Sequence[T]

+ func (s Sequence[T]) SortStable(cmp func(T, T) int) Sequence[T]

Dec 7, 2023

Changes in this version

+ var ErrEmptySequence = errors.New("empty sequence")

+ func MaxFunc[T any](s Sequence[T], less func(x, y T) bool) (T, error)

+ func Max[T cmp.Ordered](s Sequence[T]) (T, error)

+ func MinFunc[T any](s Sequence[T], less func(x, y T) bool) (T, error)

+ func Min[T cmp.Ordered](s Sequence[T]) (T, error)

+ func Product[T tools.Arithmetic](s Sequence[T]) (T, error)

Dec 7, 2023

Changes in this version

+ func Count[T any](s Sequence[T]) (int, error)

type Pair

+ func (p Pair[A, B]) String() string

type Sequence

+ func AsyncCPUs[T any](s Sequence[T]) Sequence[T]

+ func AsyncPool[T any](n int, s Sequence[T]) Sequence[T]

+ func AsyncProcs[T any](s Sequence[T]) Sequence[T]

+ func Async[T any](s Sequence[T]) Sequence[T]

+ func Buffer[T any](s Sequence[T]) Sequence[T]

+ func Counter[T tools.Arithmetic](start T) Sequence[T]

+ func Derive[Out, In any](input Sequence[In], f func(func(Out) error) error) Sequence[Out]

+ func NumberSequence[T tools.Integer | tools.Real](start, stop, step T) Sequence[T]

+ func Sync[T any](s Sequence[T]) Sequence[T]

+ func Until[T any](s Sequence[T], pred func(T) bool) Sequence[T]

+ func While[T any](s Sequence[T], pred func(T) bool) Sequence[T]

+ func ZipLongest[A, B any](aSeq Sequence[A], bSeq Sequence[B]) Sequence[Pair[A, B]]

+ func (s Sequence[T]) Async() Sequence[T]

+ func (s Sequence[T]) AsyncPool(n int) Sequence[T]

+ func (s Sequence[T]) Buffer() Sequence[T]

+ func (s Sequence[T]) IsAsync() bool

+ func (s Sequence[T]) Limit(n int) Sequence[T]

+ func (s Sequence[T]) Sync() Sequence[T]

+ func (s Sequence[T]) Until(pred func(T) bool) Sequence[T]

+ func (s Sequence[T]) While(pred func(T) bool) Sequence[T]

Dec 5, 2023

Changes in this version

+ func Sum[T tools.Arithmetic](s Sequence[T]) (T, error)

type Sequence

+ func PairSelectA[A, B any](s Sequence[Pair[A, B]]) Sequence[A]

+ func PairSelectB[A, B any](s Sequence[Pair[A, B]]) Sequence[B]

+ func PairSwap[A, B any](s Sequence[Pair[A, B]]) Sequence[Pair[B, A]]

+ func Scan[T, U any](s Sequence[T], initial U, op func(T, U) U) Sequence[U]

+ func (s Sequence[T]) Filter(pred func(T) bool) Sequence[T]

+ func (s Sequence[T]) First() (T, error)

+ func (s Sequence[T]) Last() (T, error)

+ func (s Sequence[T]) Scan(initial T, op func(T, T) T) Sequence[T]

Dec 5, 2023

Changes in this version

+ func Append[S ~[]T, T any](dst S, s Sequence[T]) (S, error)

+ func CollectErr[T, U any](s Sequence[T], initial U, process func(T, U) (U, error)) (U, error)

+ func Collect[T, U any](s Sequence[T], initial U, process func(T, U) U) (U, error)

+ func First[T any](s Sequence[T]) (T, error)

+ func IntoChanCtx[T any](ctx context.Context, ch chan<- T, s Sequence[T]) error

+ func IntoChanPair[T any](ch chan<- Pair[T, error], s Sequence[T])

+ func IntoChan[T any](ch chan<- T, s Sequence[T]) error

+ func Last[T any](s Sequence[T]) (T, error)

+ func ToChanCtx[T any](ctx context.Context, s Sequence[T]) (<-chan T, context.Context)

+ func ToChanErr[T any](s Sequence[T]) (<-chan T, <-chan error)

+ func ToChanPair[T any](s Sequence[T]) <-chan Pair[T, error]

+ func ToChan[T any](s Sequence[T]) <-chan T

+ func ToSlice[T any](s Sequence[T]) ([]T, error)

type Sequence

+ func AddFirst[A, T any](a A, s Sequence[T]) Sequence[Pair[A, T]]

+ func AddSecond[T, B any](s Sequence[T], b B) Sequence[Pair[T, B]]

+ func Concat[T any](seqs ...Sequence[T]) Sequence[T]

+ func Error[T any](err error) Sequence[T]

+ func FilterErr[T any](s Sequence[T], pred func(T) (bool, error)) Sequence[T]

+ func Filter[T any](s Sequence[T], pred func(T) bool) Sequence[T]

+ func FirstOnly[A, B any](s Sequence[Pair[A, B]]) Sequence[A]

+ func Flatten[T any, S ~[]T](src Sequence[S]) Sequence[T]

+ func FromChan[T any](ch <-chan T) Sequence[T]

+ func FromSlice[T any](items []T) Sequence[T]

+ func Infinite[T any](t T) Sequence[T]

+ func Limit[T any](s Sequence[T], n int) Sequence[T]

+ func MapErr[In, Out any](s Sequence[In], convert func(In) (Out, error)) Sequence[Out]

+ func MapFilter[In, Out any](s Sequence[In], convert func(In) (Out, bool, error)) Sequence[Out]

+ func Map[In, Out any](s Sequence[In], convert func(In) Out) Sequence[Out]

+ func Materialize[T any](s Sequence[T]) Sequence[T]

+ func New[T any](items ...T) Sequence[T]

+ func Process[In, Out any](src Sequence[In], proc func(In, func(Out)) error) Sequence[Out]

+ func Repeat[T any](t T, n int) Sequence[T]

+ func SecondOnly[A, B any](s Sequence[Pair[A, B]]) Sequence[B]

+ func Single[T any](t T) Sequence[T]

+ func SwapPairs[A, B any](s Sequence[Pair[A, B]]) Sequence[Pair[B, A]]

+ func ZipShortest[A, B any](aSeq Sequence[A], bSeq Sequence[B]) Sequence[Pair[A, B]]

+ func Zip[A, B any](aSeq Sequence[A], bSeq Sequence[B]) Sequence[Pair[A, B]]

+ func (s Sequence[T]) Concat(next ...Sequence[T]) Sequence[T]

+ func (s Sequence[T]) ToSlice() ([]T, error)

Dec 4, 2023

Changes in this version

type Sequence

+ func GenerateVolatile[T any](f func(func(T) error) error) Sequence[T]

+ func (s Sequence[T]) IsVolatile() bool

+ func (s Sequence[T]) Materialize() Sequence[T]

Dec 2, 2023

Changes in this version

+ var ErrRepeatedUse = errors.New("volatile sequence used more than once")

+ var ErrStopIteration = errors.New("iteration stopped")

+ func EachSimple[T any](s Sequence[T]) func(func(T) bool) error

+ func Each[T any](s Sequence[T]) func(func(T) error) error

+ func Iterator[T any](s Sequence[T]) func(func(T) bool)

+ type Pair struct

+ func MakePair[A, B any](a A, b B) Pair[A, B]

+ func (p Pair[A, B]) A() A

+ func (p Pair[A, B]) AB() (A, B)

+ func (p Pair[A, B]) B() B

+ func (p Pair[A, B]) BA() (B, A)

+ func (p Pair[A, B]) Swap() Pair[B, A]

+ type Sequence interface

+ Each func(func(T) error) error

+ func Generate[T any](f func(func(T) error) error) Sequence[T]

+ type VolatileSequence interface

+ func Volatile[T any](s Sequence[T]) VolatileSequence[T]