g

Aug 10, 2026

Changes in this version

+ const ASCIILetters

+ const ASCIILowercase

+ const ASCIIUppercase

+ const Digits

+ const HexDigits

+ const OctDigits

+ const Punctuation

type Int

+ func (i Int) Uint() uint

+ func (i Int) Uint16() uint16

+ func (i Int) Uint32() uint32

+ func (i Int) Uint64() uint64

+ func (i Int) Uint8() uint8

type Map

+ func MapFromMapOrd[K comparable, V any](mo MapOrd[K, V]) Map[K, V]

+ func MapFromMapSafe[K comparable, V any](ms *MapSafe[K, V]) Map[K, V]

type MapOrd

+ func MapOrdFromMapSafe[K comparable, V any](ms *MapSafe[K, V]) MapOrd[K, V]

type MapSafe

+ func MapSafeFromMapOrd[K comparable, V any](mo MapOrd[K, V]) *MapSafe[K, V]

+ func MapSafeFromMap[K comparable, V any](m Map[K, V]) *MapSafe[K, V]

type Pair

+ func (p Pair[K, V]) Unpack() (K, V)

type Result

+ func OkOrElse[T any](o Option[T], fn func() error) Result[T]

+ func OkOr[T any](o Option[T], err error) Result[T]

+ type Seq func(yield func(V) bool)

+ func (seq *Seq[V]) Next() Option[V]

+ func (seq Seq[V]) All(fn func(v V) bool) bool

+ func (seq Seq[V]) Any(fn func(V) bool) bool

+ func (seq Seq[V]) Chain(seqs ...Seq[V]) Seq[V]

+ func (seq Seq[V]) Chan(ctxs ...context.Context) chan V

+ func (seq Seq[V]) ChunkBy(fn func(a, b V) bool) SeqSlices[V]

+ func (seq Seq[V]) Chunks(n Int) SeqSlices[V]

+ func (seq Seq[V]) Collect() collector[V]

+ func (seq Seq[V]) Combinations(size Int) SeqSlices[V]

+ func (seq Seq[V]) Context(ctx context.Context) Seq[V]

+ func (seq Seq[V]) Count() Int

+ func (seq Seq[V]) CounterBy[K comparable](fn func(V) K) Seq2[K, Int]

+ func (seq Seq[V]) Cycle() Seq[V]

+ func (seq Seq[V]) Dedup() Seq[V]

+ func (seq Seq[V]) Enumerate() Seq2[Int, V]

+ func (seq Seq[V]) Exclude(fn func(V) bool) Seq[V]

+ func (seq Seq[V]) Filter(fn func(V) bool) Seq[V]

+ func (seq Seq[V]) FilterMap[U any](fn func(V) Option[U]) Seq[U]

+ func (seq Seq[V]) Find(fn func(v V) bool) Option[V]

+ func (seq Seq[V]) FindMap[U any](fn func(V) Option[U]) Option[U]

+ func (seq Seq[V]) First() Option[V]

+ func (seq Seq[V]) FlatMap[U any](fn func(V) Seq[U]) Seq[U]

+ func (seq Seq[V]) Flatten() Seq[V]

+ func (seq Seq[V]) Fold[A any](init A, fn func(acc A, val V) A) A

+ func (seq Seq[V]) ForEach(fn func(v V))

+ func (seq Seq[V]) Inspect(fn func(v V)) Seq[V]

+ func (seq Seq[V]) Intersperse(sep V) Seq[V]

+ func (seq Seq[V]) Last() Option[V]

+ func (seq Seq[V]) Map[U any](transform func(V) U) Seq[U]

+ func (seq Seq[V]) MaxBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (seq Seq[V]) MinBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (seq Seq[V]) Nth(n Int) Option[V]

+ func (seq Seq[V]) Partition(fn func(v V) bool) (Slice[V], Slice[V])

+ func (seq Seq[V]) Permutations() SeqSlices[V]

+ func (seq Seq[V]) ProductBy[S constraints.Number](fn func(V) S) S

+ func (seq Seq[V]) Pull() (func() (V, bool), func())

+ func (seq Seq[V]) Range(fn func(v V) bool)

+ func (seq Seq[V]) Reduce(fn func(a, b V) V) Option[V]

+ func (seq Seq[V]) Scan[A any](init A, fn func(acc A, val V) A) Seq[A]

+ func (seq Seq[V]) Skip(n Int) Seq[V]

+ func (seq Seq[V]) SkipWhile(fn func(V) bool) Seq[V]

+ func (seq Seq[V]) SortBy(fn func(a, b V) cmp.Ordering) Seq[V]

+ func (seq Seq[V]) StepBy(n Int) Seq[V]

+ func (seq Seq[V]) SumBy[S constraints.Number](fn func(V) S) S

+ func (seq Seq[V]) Take(n Int) Seq[V]

+ func (seq Seq[V]) TakeWhile(fn func(V) bool) Seq[V]

+ func (seq Seq[V]) TryMap[U any](fn func(V) Result[U]) SeqResult[U]

+ func (seq Seq[V]) Unique() Seq[V]

+ func (seq Seq[V]) Windows(n Int) SeqSlices[V]

+ func (seq Seq[V]) Zip[U any](two Seq[U]) Seq2[V, U]

+ type Seq2 func(yield func(K, V) bool)

+ func (seq *Seq2[K, V]) Next() Option[Pair[K, V]]

+ func (seq Seq2[K, V]) All(fn func(K, V) bool) bool

+ func (seq Seq2[K, V]) Any(fn func(K, V) bool) bool

+ func (seq Seq2[K, V]) Chain(seqs ...Seq2[K, V]) Seq2[K, V]

+ func (seq Seq2[K, V]) Chan(ctxs ...context.Context) chan Pair[K, V]

+ func (seq Seq2[K, V]) Collect() collector2[K, V]

+ func (seq Seq2[K, V]) Context(ctx context.Context) Seq2[K, V]

+ func (seq Seq2[K, V]) Count() Int

+ func (seq Seq2[K, V]) Dedup() Seq2[K, V]

+ func (seq Seq2[K, V]) Exclude(fn func(K, V) bool) Seq2[K, V]

+ func (seq Seq2[K, V]) Filter(fn func(K, V) bool) Seq2[K, V]

+ func (seq Seq2[K, V]) FilterByKey(fn func(K) bool) Seq2[K, V]

+ func (seq Seq2[K, V]) FilterByValue(fn func(V) bool) Seq2[K, V]

+ func (seq Seq2[K, V]) FilterMap[K2, V2 any](fn func(K, V) Option[Pair[K2, V2]]) Seq2[K2, V2]

+ func (seq Seq2[K, V]) Find(fn func(k K, v V) bool) Option[Pair[K, V]]

+ func (seq Seq2[K, V]) FindMap[U any](fn func(K, V) Option[U]) Option[U]

+ func (seq Seq2[K, V]) First() Option[Pair[K, V]]

+ func (seq Seq2[K, V]) Fold[A any](init A, fn func(acc A, k K, v V) A) A

+ func (seq Seq2[K, V]) ForEach(fn func(k K, v V))

+ func (seq Seq2[K, V]) Inspect(fn func(k K, v V)) Seq2[K, V]

+ func (seq Seq2[K, V]) Intersperse(sep Pair[K, V]) Seq2[K, V]

+ func (seq Seq2[K, V]) Keys() Seq[K]

+ func (seq Seq2[K, V]) Last() Option[Pair[K, V]]

+ func (seq Seq2[K, V]) MapTo[T any](fn func(K, V) T) Seq[T]

+ func (seq Seq2[K, V]) Map[K2, V2 any](transform func(K, V) (K2, V2)) Seq2[K2, V2]

+ func (seq Seq2[K, V]) MaxBy(fn func(a, b Pair[K, V]) cmp.Ordering) Option[Pair[K, V]]

+ func (seq Seq2[K, V]) MinBy(fn func(a, b Pair[K, V]) cmp.Ordering) Option[Pair[K, V]]

+ func (seq Seq2[K, V]) Nth(n Int) Option[Pair[K, V]]

+ func (seq Seq2[K, V]) ProductBy[S constraints.Number](fn func(K, V) S) S

+ func (seq Seq2[K, V]) Pull() (func() (K, V, bool), func())

+ func (seq Seq2[K, V]) Range(fn func(k K, v V) bool)

+ func (seq Seq2[K, V]) Reduce(fn func(a, b Pair[K, V]) Pair[K, V]) Option[Pair[K, V]]

+ func (seq Seq2[K, V]) Scan[A any](init A, fn func(acc A, k K, v V) A) Seq[A]

+ func (seq Seq2[K, V]) Skip(n Int) Seq2[K, V]

+ func (seq Seq2[K, V]) SkipWhile(fn func(K, V) bool) Seq2[K, V]

+ func (seq Seq2[K, V]) SortBy(fn func(a, b Pair[K, V]) cmp.Ordering) Seq2[K, V]

+ func (seq Seq2[K, V]) SortByKey(fn func(a, b K) cmp.Ordering) Seq2[K, V]

+ func (seq Seq2[K, V]) SortByValue(fn func(a, b V) cmp.Ordering) Seq2[K, V]

+ func (seq Seq2[K, V]) StepBy(n Int) Seq2[K, V]

+ func (seq Seq2[K, V]) SumBy[S constraints.Number](fn func(K, V) S) S

+ func (seq Seq2[K, V]) Take(n Int) Seq2[K, V]

+ func (seq Seq2[K, V]) TakeWhile(fn func(K, V) bool) Seq2[K, V]

+ func (seq Seq2[K, V]) TryMap[U any](fn func(K, V) Result[U]) SeqResult[U]

+ func (seq Seq2[K, V]) Unique() Seq2[K, V]

+ func (seq Seq2[K, V]) Unzip() (Slice[K], Slice[V])

+ func (seq Seq2[K, V]) Values() Seq[V]

type String

+ func (s String) IndexByte(b byte) Int

+ func (s String) LastIndexByte(b byte) Int

Jul 14, 2026

Changes in this version

+ var ErrParseBigInt = errors.New("invalid big integer")

+ var ErrParseBool = errors.New("invalid bool")

+ var ErrParseComplex = errors.New("invalid complex number")

+ var ErrParseFloat = errors.New("invalid float")

+ var ErrParseInt = errors.New("invalid integer")

+ var ErrParseUint = errors.New("invalid unsigned integer")

+ func FormatTo[T ~string](builder *Builder, template T, args ...any)

type Bytes

+ func (bs Bytes) Center(length Int, pad Bytes) Bytes

+ func (bs Bytes) Chars() SeqSlice[Bytes]

+ func (bs Bytes) Chunks(size Int) SeqSlice[Bytes]

+ func (bs Bytes) Cut(start, end Bytes, rmtags ...bool) (Bytes, Bytes)

+ func (bs Bytes) IsASCII() bool

+ func (bs Bytes) IsDigit() bool

+ func (bs Bytes) LeftJustify(length Int, pad Bytes) Bytes

+ func (bs Bytes) Remove(patterns ...Bytes) Bytes

+ func (bs Bytes) ReplaceMulti(oldnew ...Bytes) Bytes

+ func (bs Bytes) ReplaceNth(oldB, newB Bytes, n Int) Bytes

+ func (bs Bytes) RightJustify(length Int, pad Bytes) Bytes

+ func (bs Bytes) Similarity(obs Bytes) Float

+ func (bs Bytes) SubBytes(start, end Int, step ...Int) Bytes

+ func (bs Bytes) Truncate(max Int) Bytes

+ func (bs Bytes) TryBigInt() Result[*big.Int]

+ func (bs Bytes) TryBool() Result[bool]

+ func (bs Bytes) TryComplex() Result[complex128]

+ func (bs Bytes) TryFloat() Result[Float]

+ func (bs Bytes) TryInt() Result[Int]

+ func (bs Bytes) TryUint() Result[uint]

type Deque

+ func DequeFromSlice[T any](s Slice[T]) *Deque[T]

+ func (dq *Deque[T]) Extend(values ...T)

type Dir

+ func TempDir() *Dir

+ func (d *Dir) Exists() bool

type File

+ func (f *File) Exists() bool

type Float

+ func (f Float) Acos() Float

+ func (f Float) Acosh() Float

+ func (f Float) Asin() Float

+ func (f Float) Asinh() Float

+ func (f Float) Atan() Float

+ func (f Float) Atan2(b Float) Float

+ func (f Float) Atanh() Float

+ func (f Float) Cbrt() Float

+ func (f Float) Ceil() Float

+ func (f Float) Clamp(min, max Float) Float

+ func (f Float) Copysign(sign Float) Float

+ func (f Float) Cos() Float

+ func (f Float) Cosh() Float

+ func (f Float) Exp() Float

+ func (f Float) Exp2() Float

+ func (f Float) ExpM1() Float

+ func (f Float) Floor() Float

+ func (f Float) Fract() Float

+ func (f Float) Hypot(b Float) Float

+ func (f Float) IsFinite() bool

+ func (f Float) IsInf() bool

+ func (f Float) IsNaN() bool

+ func (f Float) IsNormal() bool

+ func (f Float) IsSignNegative() bool

+ func (f Float) IsSignPositive() bool

+ func (f Float) Ln() Float

+ func (f Float) Ln1p() Float

+ func (f Float) Log10() Float

+ func (f Float) Log2() Float

+ func (f Float) MulAdd(b, c Float) Float

+ func (f Float) Neg() Float

+ func (f Float) Recip() Float

+ func (f Float) Signum() Float

+ func (f Float) Sin() Float

+ func (f Float) Sinh() Float

+ func (f Float) Tan() Float

+ func (f Float) Tanh() Float

+ func (f Float) ToDegrees() Float

+ func (f Float) ToRadians() Float

+ func (f Float) Trunc() Float

+ type Formattable interface

+ FormatValue func(spec String) String

type Heap

+ func HeapFromSlice[T any](compareFn func(T, T) cmp.Ordering, s Slice[T]) *Heap[T]

+ func HeapOf[T any](compareFn func(T, T) cmp.Ordering, values ...T) *Heap[T]

+ func (h *Heap[T]) Eq(other *Heap[T]) bool

+ func (h *Heap[T]) Ne(other *Heap[T]) bool

type Int

+ func (i Int) CheckedAbs() Option[Int]

+ func (i Int) CheckedAdd(b Int) Option[Int]

+ func (i Int) CheckedDiv(b Int) Option[Int]

+ func (i Int) CheckedMul(b Int) Option[Int]

+ func (i Int) CheckedNeg() Option[Int]

+ func (i Int) CheckedPow(exp Int) Option[Int]

+ func (i Int) CheckedRem(b Int) Option[Int]

+ func (i Int) CheckedSub(b Int) Option[Int]

+ func (i Int) Clamp(min, max Int) Int

+ func (i Int) Neg() Int

+ func (i Int) OverflowingAdd(b Int) (Int, bool)

+ func (i Int) OverflowingMul(b Int) (Int, bool)

+ func (i Int) OverflowingSub(b Int) (Int, bool)

+ func (i Int) SaturatingAdd(b Int) Int

+ func (i Int) SaturatingMul(b Int) Int

+ func (i Int) SaturatingSub(b Int) Int

+ func (i Int) Signum() Int

type Map

+ func MapFromPairs[K comparable, V any](pairs Slice[Pair[K, V]]) Map[K, V]

+ func MapOf[K comparable, V any](pairs ...Pair[K, V]) Map[K, V]

type MapOrd

+ func MapOrdFromPairs[K comparable, V any](pairs Slice[Pair[K, V]]) MapOrd[K, V]

+ func MapOrdOf[K comparable, V any](pairs ...Pair[K, V]) MapOrd[K, V]

type MapSafe

+ func MapSafeFromPairs[K comparable, V any](pairs Slice[Pair[K, V]]) *MapSafe[K, V]

+ func MapSafeOf[K comparable, V any](pairs ...Pair[K, V]) *MapSafe[K, V]

type Option

+ func (o *Option[T]) UnmarshalJSONFrom(dec *jsontext.Decoder) error

+ func (o Option[T]) And[U any](other Option[U]) Option[U]

+ func (o Option[T]) IsNoneOr(pred func(T) bool) bool

+ func (o Option[T]) MapOrElse[U any](defFn func() U, fn func(T) U) U

+ func (o Option[T]) MapOr[U any](def U, fn func(T) U) U

+ func (o Option[T]) Map[U any](fn func(T) U) Option[U]

+ func (o Option[T]) MarshalJSONTo(enc *jsontext.Encoder) error

+ func (o Option[T]) ThenOf[U any](fn func(T) (U, bool)) Option[U]

+ func (o Option[T]) Xor(other Option[T]) Option[T]

type Pair

+ func PairOf[K, V any](key K, value V) Pair[K, V]

type Result

+ func CreateTempDir(args ...String) Result[*Dir]

+ func TryFormatTo[T ~string](builder *Builder, template T, args ...any) Result[Unit]

+ func TryFormat[T ~string](template T, args ...any) (result Result[String])

+ func (r *Result[T]) UnmarshalJSON(data []byte) error

+ func (r *Result[T]) UnmarshalJSONFrom(dec *jsontext.Decoder) error

+ func (r Result[T]) And[U any](other Result[U]) Result[U]

+ func (r Result[T]) ErrOption() Option[error]

+ func (r Result[T]) InspectErr(fn func(error)) Result[T]

+ func (r Result[T]) IsErrAnd(pred func(error) bool) bool

+ func (r Result[T]) IsOkAnd(pred func(T) bool) bool

+ func (r Result[T]) MapOrElse[U any](defFn func(error) U, fn func(T) U) U

+ func (r Result[T]) MapOr[U any](def U, fn func(T) U) U

+ func (r Result[T]) Map[U any](fn func(T) U) Result[U]

+ func (r Result[T]) MarshalJSON() ([]byte, error)

+ func (r Result[T]) MarshalJSONTo(enc *jsontext.Encoder) error

+ func (r Result[T]) Or(other Result[T]) Result[T]

+ func (r Result[T]) OrElse(fn func(error) Result[T]) Result[T]

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

type SeqDeque

+ func (seq SeqDeque[V]) ChunkBy(fn func(a, b V) bool) SeqSlices[V]

+ func (seq SeqDeque[V]) CounterBy[K comparable](fn func(V) K) SeqMapOrd[K, Int]

+ func (seq SeqDeque[V]) FindMap[U any](fn func(V) Option[U]) Option[U]

+ func (seq SeqDeque[V]) ProductBy[S constraints.Number](fn func(V) S) S

+ func (seq SeqDeque[V]) SkipWhile(fn func(V) bool) SeqDeque[V]

+ func (seq SeqDeque[V]) SumBy[S constraints.Number](fn func(V) S) S

+ func (seq SeqDeque[V]) TakeWhile(fn func(V) bool) SeqDeque[V]

+ func (seq SeqDeque[V]) TryMap[U any](fn func(V) Result[U]) SeqResult[U]

type SeqHeap

+ func (seq SeqHeap[V]) ChunkBy(fn func(a, b V) bool) SeqSlices[V]

+ func (seq SeqHeap[V]) CounterBy[K comparable](fn func(V) K) SeqMapOrd[K, Int]

+ func (seq SeqHeap[V]) FindMap[U any](fn func(V) Option[U]) Option[U]

+ func (seq SeqHeap[V]) ProductBy[S constraints.Number](fn func(V) S) S

+ func (seq SeqHeap[V]) SkipWhile(fn func(V) bool) SeqHeap[V]

+ func (seq SeqHeap[V]) SumBy[S constraints.Number](fn func(V) S) S

+ func (seq SeqHeap[V]) TakeWhile(fn func(V) bool) SeqHeap[V]

+ func (seq SeqHeap[V]) TryMap[U any](fn func(V) Result[U]) SeqResult[U]

type SeqMap

+ func (seq SeqMap[K, V]) All(fn func(K, V) bool) bool

+ func (seq SeqMap[K, V]) Any(fn func(K, V) bool) bool

+ func (seq SeqMap[K, V]) Chan(ctxs ...context.Context) chan Pair[K, V]

+ func (seq SeqMap[K, V]) FilterByKey(fn func(K) bool) SeqMap[K, V]

+ func (seq SeqMap[K, V]) FilterByValue(fn func(V) bool) SeqMap[K, V]

+ func (seq SeqMap[K, V]) FindMap[U any](fn func(K, V) Option[U]) Option[U]

+ func (seq SeqMap[K, V]) Fold[A any](init A, fn func(acc A, k K, v V) A) A

+ func (seq SeqMap[K, V]) Last() Option[Pair[K, V]]

+ func (seq SeqMap[K, V]) ProductBy[S constraints.Number](fn func(K, V) S) S

+ func (seq SeqMap[K, V]) SkipWhile(fn func(K, V) bool) SeqMap[K, V]

+ func (seq SeqMap[K, V]) SumBy[S constraints.Number](fn func(K, V) S) S

+ func (seq SeqMap[K, V]) TakeWhile(fn func(K, V) bool) SeqMap[K, V]

+ func (seq SeqMap[K, V]) TryMap[U any](fn func(K, V) Result[U]) SeqResult[U]

type SeqMapOrd

+ func (seq SeqMapOrd[K, V]) All(fn func(K, V) bool) bool

+ func (seq SeqMapOrd[K, V]) Any(fn func(K, V) bool) bool

+ func (seq SeqMapOrd[K, V]) FilterByKey(fn func(K) bool) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) FilterByValue(fn func(V) bool) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) FilterMap[K2 comparable, V2 any](fn func(K, V) Option[Pair[K2, V2]]) SeqMapOrd[K2, V2]

+ func (seq SeqMapOrd[K, V]) FindMap[U any](fn func(K, V) Option[U]) Option[U]

+ func (seq SeqMapOrd[K, V]) Fold[A any](init A, fn func(acc A, k K, v V) A) A

+ func (seq SeqMapOrd[K, V]) ProductBy[S constraints.Number](fn func(K, V) S) S

+ func (seq SeqMapOrd[K, V]) SkipWhile(fn func(K, V) bool) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) SumBy[S constraints.Number](fn func(K, V) S) S

+ func (seq SeqMapOrd[K, V]) TakeWhile(fn func(K, V) bool) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) TryMap[U any](fn func(K, V) Result[U]) SeqResult[U]

+ type SeqPairs iter.Seq2[K, V]

+ func (seq SeqPairs[K, V]) All(fn func(K, V) bool) bool

+ func (seq SeqPairs[K, V]) Any(fn func(K, V) bool) bool

+ func (seq SeqPairs[K, V]) Collect() []Pair[K, V]

+ func (seq SeqPairs[K, V]) Count() Int

+ func (seq SeqPairs[K, V]) Exclude(fn func(K, V) bool) SeqPairs[K, V]

+ func (seq SeqPairs[K, V]) Filter(fn func(K, V) bool) SeqPairs[K, V]

+ func (seq SeqPairs[K, V]) FilterByKey(fn func(K) bool) SeqPairs[K, V]

+ func (seq SeqPairs[K, V]) FilterByValue(fn func(V) bool) SeqPairs[K, V]

+ func (seq SeqPairs[K, V]) Find(fn func(K, V) bool) Option[Pair[K, V]]

+ func (seq SeqPairs[K, V]) FindMap[U any](fn func(K, V) Option[U]) Option[U]

+ func (seq SeqPairs[K, V]) Fold[A any](init A, fn func(acc A, k K, v V) A) A

+ func (seq SeqPairs[K, V]) ForEach(fn func(K, V))

+ func (seq SeqPairs[K, V]) Inspect(fn func(K, V)) SeqPairs[K, V]

+ func (seq SeqPairs[K, V]) Keys() SeqSlice[K]

+ func (seq SeqPairs[K, V]) Map[T any](fn func(K, V) T) SeqSlice[T]

+ func (seq SeqPairs[K, V]) ProductBy[S constraints.Number](fn func(K, V) S) S

+ func (seq SeqPairs[K, V]) Skip(n uint) SeqPairs[K, V]

+ func (seq SeqPairs[K, V]) SkipWhile(fn func(K, V) bool) SeqPairs[K, V]

+ func (seq SeqPairs[K, V]) SumBy[S constraints.Number](fn func(K, V) S) S

+ func (seq SeqPairs[K, V]) Take(n uint) SeqPairs[K, V]

+ func (seq SeqPairs[K, V]) TakeWhile(fn func(K, V) bool) SeqPairs[K, V]

+ func (seq SeqPairs[K, V]) TryMap[U any](fn func(K, V) Result[U]) SeqResult[U]

+ func (seq SeqPairs[K, V]) Unzip() (Slice[K], Slice[V])

+ func (seq SeqPairs[K, V]) Values() SeqSlice[V]

type SeqResult

+ func (seq SeqResult[V]) CounterBy[K comparable](fn func(V) K) Result[MapOrd[K, Int]]

+ func (seq SeqResult[V]) FilterMap[U any](fn func(V) Option[U]) SeqResult[U]

+ func (seq SeqResult[V]) FindMap[U any](fn func(V) Option[U]) Result[Option[U]]

+ func (seq SeqResult[V]) FlatMap[U any](fn func(V) SeqSlice[U]) SeqResult[U]

+ func (seq SeqResult[V]) Flatten() SeqResult[V]

+ func (seq SeqResult[V]) Fold[A any](init A, fn func(acc A, val V) A) Result[A]

+ func (seq SeqResult[V]) MaxBy(fn func(V, V) cmp.Ordering) Result[Option[V]]

+ func (seq SeqResult[V]) MinBy(fn func(V, V) cmp.Ordering) Result[Option[V]]

+ func (seq SeqResult[V]) ProductBy[S constraints.Number](fn func(V) S) Result[S]

+ func (seq SeqResult[V]) Reduce(fn func(a, b V) V) Result[Option[V]]

+ func (seq SeqResult[V]) Scan[A any](init A, fn func(acc A, val V) A) SeqResult[A]

+ func (seq SeqResult[V]) SkipWhile(fn func(V) bool) SeqResult[V]

+ func (seq SeqResult[V]) SortBy(fn func(a, b V) cmp.Ordering) SeqResult[V]

+ func (seq SeqResult[V]) SumBy[S constraints.Number](fn func(V) S) Result[S]

+ func (seq SeqResult[V]) TakeWhile(fn func(V) bool) SeqResult[V]

+ func (seq SeqResult[V]) TryCollect() Result[Slice[V]]

type SeqSet

+ func (seq SeqSet[V]) Chan(ctxs ...context.Context) chan V

+ func (seq SeqSet[V]) CounterBy[K comparable](fn func(V) K) SeqMapOrd[K, Int]

+ func (seq SeqSet[V]) Difference(other Set[V]) SeqSet[V]

+ func (seq SeqSet[V]) FindMap[U any](fn func(V) Option[U]) Option[U]

+ func (seq SeqSet[V]) First() Option[V]

+ func (seq SeqSet[V]) Intersection(other Set[V]) SeqSet[V]

+ func (seq SeqSet[V]) Last() Option[V]

+ func (seq SeqSet[V]) MaxBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (seq SeqSet[V]) MinBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (seq SeqSet[V]) Partition(fn func(V) bool) (Set[V], Set[V])

+ func (seq SeqSet[V]) ProductBy[S constraints.Number](fn func(V) S) S

+ func (seq SeqSet[V]) SkipWhile(fn func(V) bool) SeqSet[V]

+ func (seq SeqSet[V]) StepBy(n uint) SeqSet[V]

+ func (seq SeqSet[V]) SumBy[S constraints.Number](fn func(V) S) S

+ func (seq SeqSet[V]) TakeWhile(fn func(V) bool) SeqSet[V]

+ func (seq SeqSet[V]) TryMap[U any](fn func(V) Result[U]) SeqResult[U]

type SeqSlice

+ func (seq SeqSlice[V]) ChunkBy(fn func(a, b V) bool) SeqSlices[V]

+ func (seq SeqSlice[V]) CounterBy[K comparable](fn func(V) K) SeqMapOrd[K, Int]

+ func (seq SeqSlice[V]) FindMap[U any](fn func(V) Option[U]) Option[U]

+ func (seq SeqSlice[V]) ProductBy[S constraints.Number](fn func(V) S) S

+ func (seq SeqSlice[V]) SkipWhile(fn func(V) bool) SeqSlice[V]

+ func (seq SeqSlice[V]) SumBy[S constraints.Number](fn func(V) S) S

+ func (seq SeqSlice[V]) TakeWhile(fn func(V) bool) SeqSlice[V]

+ func (seq SeqSlice[V]) TryMap[U any](fn func(V) Result[U]) SeqResult[U]

type Set

+ func SetFromSlice[T comparable](s Slice[T]) Set[T]

+ func (s Set[T]) Disjoint(other Set[T]) bool

type Slice

+ func (sl *Slice[T]) DedupBy(eq func(a, b T) bool)

+ func (sl *Slice[T]) Retain(fn func(T) bool)

+ func (sl Slice[T]) BinarySearch(value T, fn func(a, b T) cmp.Ordering) Option[Int]

+ func (sl Slice[T]) PartitionPoint(pred func(T) bool) Int

type String

+ func (s String) TryBool() Result[bool]

+ func (s String) TryComplex() Result[complex128]

+ func (s String) TryUint() Result[uint]

Jun 6, 2026

Changes in this version

type Bytes

+ func (bs Bytes) Compress() bcompress

+ func (bs Bytes) Decompress() bdecompress

+ func (bs Bytes) EndsWith(suffix Bytes) bool

+ func (bs Bytes) EndsWithAny(suffixes ...Bytes) bool

+ func (bs Bytes) Gte(obs Bytes) bool

+ func (bs Bytes) Lines() SeqSlice[Bytes]

+ func (bs Bytes) Lte(obs Bytes) bool

+ func (bs Bytes) Max(b ...Bytes) Bytes

+ func (bs Bytes) Min(b ...Bytes) Bytes

+ func (bs Bytes) SplitN(sep Bytes, n Int) Slice[Bytes]

+ func (bs Bytes) StartsWith(prefix Bytes) bool

+ func (bs Bytes) StartsWithAny(prefixes ...Bytes) bool

type Deque

+ func (dq *Deque[T]) ContainsAll(values ...T) bool

+ func (dq *Deque[T]) ContainsAny(values ...T) bool

+ func (dq *Deque[T]) Ne(other *Deque[T]) bool

+ func (dq *Deque[T]) Transform(fn func(*Deque[T]) *Deque[T]) *Deque[T]

type Heap

+ func (h *Heap[T]) Contains(value T) bool

+ func (h *Heap[T]) Fix(i Int)

+ func (h *Heap[T]) Remove(i Int) Option[T]

type Int

+ func (i Int) IsNonNegative() bool

type MapSafe

+ func (ms *MapSafe[K, V]) Map() Map[K, V]

+ func (ms *MapSafe[K, V]) Ordered() MapOrd[K, V]

+ func (ms *MapSafe[K, V]) Transform(fn func(*MapSafe[K, V]) *MapSafe[K, V]) *MapSafe[K, V]

type Option

+ func (o Option[T]) Inspect(fn func(T)) Option[T]

type Result

+ func (r Result[T]) Inspect(fn func(T)) Result[T]

type SeqMap

+ func (seq SeqMap[K, V]) First() Option[Pair[K, V]]

+ func (seq SeqMap[K, V]) Skip(n uint) SeqMap[K, V]

+ func (seq SeqMap[K, V]) StepBy(n uint) SeqMap[K, V]

type SeqResult

+ func MapSeqResult[V, U any](seq SeqResult[V], fn func(V) U) SeqResult[U]

type SeqSet

+ func (seq SeqSet[V]) All(fn func(v V) bool) bool

+ func (seq SeqSet[V]) Any(fn func(V) bool) bool

+ func (seq SeqSet[V]) FilterMap(fn func(V) Option[V]) SeqSet[V]

+ func (seq SeqSet[V]) Fold(init V, fn func(acc, val V) V) V

+ func (seq SeqSet[V]) Reduce(fn func(a, b V) V) Option[V]

+ func (seq SeqSet[V]) Skip(n uint) SeqSet[V]

type SeqSlices

+ func (seqs SeqSlices[V]) Filter(fn func(Slice[V]) bool) SeqSlices[V]

+ func (seqs SeqSlices[V]) Flatten() SeqSlice[V]

+ func (seqs SeqSlices[V]) ForEach(fn func(s Slice[V]))

+ func (seqs SeqSlices[V]) Map(fn func(Slice[V]) Slice[V]) SeqSlices[V]

Mar 28, 2026

Changes in this version

type SeqResult

+ func FlattenResult[T any, E ~[]T](seq SeqResult[E]) SeqResult[T]

type SeqSlice

+ func Flatten[T any, E ~[]T](seq SeqSlice[E]) SeqSlice[T]

Mar 8, 2026

Changes in this version

type SeqResult

+ func ErrSeq[V any](err error) SeqResult[V]

+ func OkSeq[V any](v V) SeqResult[V]

Feb 27, 2026

Changes in this version

type Option

+ func OptionFromPtr[T any](ptr *T) Option[T]

Feb 25, 2026

Changes in this version

type Option

+ func FromPtr[T any](ptr *T) Option[T]

+ func (o *Option[T]) GetOrInsert(value T) *T

+ func (o *Option[T]) GetOrInsertWith(fn func() T) *T

+ func (o *Option[T]) Insert(value T) *T

+ func (o *Option[T]) Replace(value T) Option[T]

+ func (o *Option[T]) Take() Option[T]

+ func (o Option[T]) Filter(pred func(T) bool) Option[T]

+ func (o Option[T]) IsSomeAnd(pred func(T) bool) bool

+ func (o Option[T]) OkOr(err error) Result[T]

+ func (o Option[T]) OkOrElse(fn func() error) Result[T]

+ func (o Option[T]) Or(other Option[T]) Option[T]

+ func (o Option[T]) OrElse(fn func() Option[T]) Option[T]

+ func (o Option[T]) Ptr() *T

Feb 24, 2026

Changes in this version

+ var ErrInvalidBinaryDigit = errors.New("binary string must contain only '0' and '1'")

+ var ErrInvalidBinaryLength = errors.New("binary string length must be multiple of 8")

type Bytes

+ func (bs Bytes) Decode() bdecode

+ func (bs Bytes) Encode() bencode

Feb 24, 2026

Changes in this version

type Bytes

+ func (bs Bytes) Hex() Bytes

Feb 19, 2026

Changes in this version

type Bytes

+ func (bs Bytes) IsTitle() bool

type String

+ func (s String) IsTitle() bool

Feb 17, 2026

Changes in this version

type File

+ func (f *File) Reader() Result[io.ReadCloser]

Feb 7, 2026

Changes in this version

type SeqResult

+ func FromResultChan[V any](ch <-chan Result[V]) SeqResult[V]

Feb 6, 2026

Changes in this version

type Float

+ func (f Float) Gte(b Float) bool

+ func (f Float) Lte(b Float) bool

type Mutex

+ func (m *Mutex[T]) With(fn func(*T))

type RwLock

+ func (r *RwLock[T]) RWith(fn func(T))

+ func (r *RwLock[T]) With(fn func(*T))

Jan 31, 2026

Changes in this version

type Result

+ func (r Result[T]) Wrap(err error) Result[T]

Jan 31, 2026

Changes in this version

type Result

+ func (r Result[T]) ErrAs(target any) bool

+ func (r Result[T]) ErrIs(target error) bool

+ func (r Result[T]) ErrSource() Option[error]

Jan 28, 2026

Changes in this version

type Deque

+ func (dq *Deque[T]) Slice() Slice[T]

type Heap

+ func (h *Heap[T]) Slice() Slice[T]

type Map

+ func (m Map[K, V]) Ordered() MapOrd[K, V]

+ func (m Map[K, V]) Safe() *MapSafe[K, V]

type MapOrd

+ func (mo MapOrd[K, V]) Map() Map[K, V]

+ func (mo MapOrd[K, V]) Safe() *MapSafe[K, V]

type SeqDeque

+ func (seq SeqDeque[V]) Chan(ctxs ...context.Context) chan V

type SeqHeap

+ func (seq SeqHeap[V]) Chan(ctxs ...context.Context) chan V

type SeqMapOrd

+ func (seq SeqMapOrd[K, V]) Chan(ctxs ...context.Context) chan Pair[K, V]

type SeqSlice

+ func (seq SeqSlice[V]) Chan(ctxs ...context.Context) chan V

type Set

+ func (s Set[T]) Slice() Slice[T]

type Slice

+ func (sl Slice[T]) Heap(compareFn func(T, T) cmp.Ordering) *Heap[T]

type String

+ func (s String) TryBigInt() Option[*big.Int]

+ func (s String) TryFloat() Result[Float]

+ func (s String) TryInt() Result[Int]

Jan 23, 2026

Changes in this version

+ const PathSeparator

type Option

+ func (o *Option[T]) UnmarshalJSON(data []byte) error

+ func (o Option[T]) MarshalJSON() ([]byte, error)

Jan 22, 2026

Changes in this version

type Bytes

+ func (bs Bytes) IsEmpty() bool

type Heap

+ func (h *Heap[T]) IsEmpty() bool

type Map

+ func (m Map[K, V]) Insert(key K, value V) Option[V]

+ func (m Map[K, V]) IsEmpty() bool

+ func (m Map[K, V]) Remove(key K) Option[V]

type MapOrd

+ func (mo *MapOrd[K, V]) Insert(key K, value V) Option[V]

+ func (mo *MapOrd[K, V]) Remove(key K) Option[V]

+ func (mo MapOrd[K, V]) IsEmpty() bool

type MapSafe

+ func (ms *MapSafe[K, V]) Insert(key K, value V) Option[V]

+ func (ms *MapSafe[K, V]) IsEmpty() bool

+ func (ms *MapSafe[K, V]) Remove(key K) Option[V]

+ func (ms *MapSafe[K, V]) TryInsert(key K, value V) Option[V]

type Set

+ func (s Set[T]) IsEmpty() bool

type Slice

+ func (sl *Slice[T]) Remove(index Int) Option[T]

+ func (sl Slice[T]) First() Option[T]

+ func (sl Slice[T]) IsEmpty() bool

type String

+ func (s String) IsEmpty() bool

Jan 21, 2026

Changes in this version

+ type Mutex struct

+ func NewMutex[T any](value T) *Mutex[T]

+ func (m *Mutex[T]) Lock() MutexGuard[T]

+ func (m *Mutex[T]) TryLock() Option[MutexGuard[T]]

+ type MutexGuard struct

+ func (g MutexGuard[T]) Deref() *T

+ func (g MutexGuard[T]) Get() T

+ func (g MutexGuard[T]) Set(value T)

+ func (g MutexGuard[T]) Unlock()

+ type RwLock struct

+ func NewRwLock[T any](value T) *RwLock[T]

+ func (r *RwLock[T]) Read() RwLockReadGuard[T]

+ func (r *RwLock[T]) TryRead() Option[RwLockReadGuard[T]]

+ func (r *RwLock[T]) TryWrite() Option[RwLockWriteGuard[T]]

+ func (r *RwLock[T]) Write() RwLockWriteGuard[T]

+ type RwLockReadGuard struct

+ func (g RwLockReadGuard[T]) Deref() *T

+ func (g RwLockReadGuard[T]) Get() T

+ func (g RwLockReadGuard[T]) Unlock()

+ type RwLockWriteGuard struct

+ func (g RwLockWriteGuard[T]) Deref() *T

+ func (g RwLockWriteGuard[T]) Get() T

+ func (g RwLockWriteGuard[T]) Set(value T)

+ func (g RwLockWriteGuard[T]) Unlock()

Jan 17, 2026

Changes in this version

+ type Entry interface

+ AndModify func(fn func(*V)) Entry[K, V]

+ Key func() K

+ OrDefault func() V

+ OrInsert func(value V) V

+ OrInsertWith func(fn func() V) V

+ OrInsertWithKey func(fn func(K) V) V

type MapSafe

+ func (ms *MapSafe[K, V]) TrySet(key K, value V) Option[V]

+ type OccupiedEntry struct

+ func (e OccupiedEntry[K, V]) AndModify(fn func(*V)) Entry[K, V]

+ func (e OccupiedEntry[K, V]) Get() V

+ func (e OccupiedEntry[K, V]) Insert(value V) V

+ func (e OccupiedEntry[K, V]) Key() K

+ func (e OccupiedEntry[K, V]) OrDefault() V

+ func (e OccupiedEntry[K, V]) OrInsert(value V) V

+ func (e OccupiedEntry[K, V]) OrInsertWith(fn func() V) V

+ func (e OccupiedEntry[K, V]) OrInsertWithKey(fn func(K) V) V

+ func (e OccupiedEntry[K, V]) Remove() V

+ type OccupiedOrdEntry struct

+ func (e OccupiedOrdEntry[K, V]) AndModify(fn func(*V)) OrdEntry[K, V]

+ func (e OccupiedOrdEntry[K, V]) Get() V

+ func (e OccupiedOrdEntry[K, V]) Insert(value V) V

+ func (e OccupiedOrdEntry[K, V]) Key() K

+ func (e OccupiedOrdEntry[K, V]) OrDefault() V

+ func (e OccupiedOrdEntry[K, V]) OrInsert(value V) V

+ func (e OccupiedOrdEntry[K, V]) OrInsertWith(fn func() V) V

+ func (e OccupiedOrdEntry[K, V]) OrInsertWithKey(fn func(K) V) V

+ func (e OccupiedOrdEntry[K, V]) Remove() V

+ type OccupiedSafeEntry struct

+ func (e OccupiedSafeEntry[K, V]) AndModify(fn func(*V)) SafeEntry[K, V]

+ func (e OccupiedSafeEntry[K, V]) Get() V

+ func (e OccupiedSafeEntry[K, V]) Insert(value V) V

+ func (e OccupiedSafeEntry[K, V]) Key() K

+ func (e OccupiedSafeEntry[K, V]) OrDefault() V

+ func (e OccupiedSafeEntry[K, V]) OrInsert(value V) V

+ func (e OccupiedSafeEntry[K, V]) OrInsertWith(fn func() V) V

+ func (e OccupiedSafeEntry[K, V]) OrInsertWithKey(fn func(K) V) V

+ func (e OccupiedSafeEntry[K, V]) Remove() V

+ type OrdEntry interface

+ AndModify func(fn func(*V)) OrdEntry[K, V]

+ Key func() K

+ OrDefault func() V

+ OrInsert func(value V) V

+ OrInsertWith func(fn func() V) V

+ OrInsertWithKey func(fn func(K) V) V

+ type SafeEntry interface

+ AndModify func(fn func(*V)) SafeEntry[K, V]

+ Key func() K

+ OrDefault func() V

+ OrInsert func(value V) V

+ OrInsertWith func(fn func() V) V

+ OrInsertWithKey func(fn func(K) V) V

+ type VacantEntry struct

+ func (e VacantEntry[K, V]) AndModify(fn func(*V)) Entry[K, V]

+ func (e VacantEntry[K, V]) Insert(value V) V

+ func (e VacantEntry[K, V]) Key() K

+ func (e VacantEntry[K, V]) OrDefault() V

+ func (e VacantEntry[K, V]) OrInsert(value V) V

+ func (e VacantEntry[K, V]) OrInsertWith(fn func() V) V

+ func (e VacantEntry[K, V]) OrInsertWithKey(fn func(K) V) V

+ type VacantOrdEntry struct

+ func (e VacantOrdEntry[K, V]) AndModify(fn func(*V)) OrdEntry[K, V]

+ func (e VacantOrdEntry[K, V]) Insert(value V) V

+ func (e VacantOrdEntry[K, V]) Key() K

+ func (e VacantOrdEntry[K, V]) OrDefault() V

+ func (e VacantOrdEntry[K, V]) OrInsert(value V) V

+ func (e VacantOrdEntry[K, V]) OrInsertWith(fn func() V) V

+ func (e VacantOrdEntry[K, V]) OrInsertWithKey(fn func(K) V) V

+ type VacantSafeEntry struct

+ func (e VacantSafeEntry[K, V]) AndModify(fn func(*V)) SafeEntry[K, V]

+ func (e VacantSafeEntry[K, V]) Insert(value V) V

+ func (e VacantSafeEntry[K, V]) Key() K

+ func (e VacantSafeEntry[K, V]) OrDefault() V

+ func (e VacantSafeEntry[K, V]) OrInsert(value V) V

+ func (e VacantSafeEntry[K, V]) OrInsertWith(fn func() V) V

+ func (e VacantSafeEntry[K, V]) OrInsertWithKey(fn func(K) V) V

Jan 8, 2026

Changes in this version

type Bytes

+ func (bs *Bytes) Scan(src any) error

+ func (bs Bytes) Value() (driver.Value, error)

type Float

+ func (f *Float) Scan(src any) error

+ func (f Float) Value() (driver.Value, error)

type Int

+ func (i *Int) Scan(src any) error

+ func (i Int) Value() (driver.Value, error)

type String

+ func (s *String) Scan(src any) error

+ func (s String) Value() (driver.Value, error)

Jan 7, 2026

Changes in this version

type Option

+ func (o *Option[T]) Scan(src any) error

+ func (o Option[T]) Value() (driver.Value, error)

Nov 8, 2025

Changes in this version

type Bytes

+ func (bs Bytes) IsLower() bool

+ func (bs Bytes) IsUpper() bool

type String

+ func (s String) IsLower() bool

+ func (s String) IsUpper() bool

Sep 28, 2025

Changes in this version

type Float

+ func (f Float) CeilDecimal(precision Int) Float

+ func (f Float) FloorDecimal(precision Int) Float

+ func (f Float) Mod(b Float) Float

+ func (f Float) Pow(exp Float) Float

+ func (f Float) Sqrt() Float

+ func (f Float) TruncDecimal(precision Int) Float

type MapOrd

+ func (mo MapOrd[K, V]) ToMap() Map[K, V]

+ func (mo MapOrd[K, V]) ToMapSafe() *MapSafe[K, V]

Sep 16, 2025

Changes in this version

type Slice

+ func (sl Slice[T]) IsSortedBy(fn func(a, b T) cmp.Ordering) bool

Sep 16, 2025

Changes in this version

type MapOrd

+ func (mo MapOrd[K, V]) IsSortedBy(fn func(a, b Pair[K, V]) cmp.Ordering) bool

+ func (mo MapOrd[K, V]) IsSortedByKey(fn func(a, b K) cmp.Ordering) bool

+ func (mo MapOrd[K, V]) IsSortedByValue(fn func(a, b V) cmp.Ordering) bool

type Slice

+ func (sl Slice[T]) IsSorted(fn func(a, b T) cmp.Ordering) bool

Sep 13, 2025

Changes in this version

type SeqResult

+ func (seq SeqResult[V]) Err() SeqSlice[error]

+ func (seq SeqResult[V]) FirstErr() Option[error]

+ func (seq SeqResult[V]) Ok() SeqSlice[V]

+ func (seq SeqResult[V]) Partition() (Slice[V], Slice[error])

Sep 12, 2025

Changes in this version

type SeqDeque

+ func (seq SeqDeque[V]) First() Option[V]

+ func (seq SeqDeque[V]) Last() Option[V]

type SeqHeap

+ func (seq SeqHeap[V]) First() Option[V]

+ func (seq SeqHeap[V]) Last() Option[V]

type SeqMapOrd

+ func (seq SeqMapOrd[K, V]) First() Option[Pair[K, V]]

+ func (seq SeqMapOrd[K, V]) Last() Option[Pair[K, V]]

type SeqResult

+ func (seq SeqResult[V]) First() Result[Option[V]]

+ func (seq SeqResult[V]) Last() Result[Option[V]]

type SeqSlice

+ func (seq SeqSlice[V]) First() Option[V]

+ func (seq SeqSlice[V]) Last() Option[V]

Sep 12, 2025

Changes in this version

type SeqDeque

+ func (seq *SeqDeque[V]) Next() Option[V]

type SeqHeap

+ func (seq *SeqHeap[V]) Next() Option[V]

type SeqMap

+ func (seq *SeqMap[K, V]) Next() Option[Pair[K, V]]

type SeqMapOrd

+ func (seq *SeqMapOrd[K, V]) Next() Option[Pair[K, V]]

type SeqResult

+ func (seq *SeqResult[V]) Next() Option[Result[V]]

type SeqSet

+ func (seq *SeqSet[V]) Next() Option[V]

type SeqSlice

+ func (seq *SeqSlice[V]) Next() Option[V]

Aug 21, 2025

Changes in this version

type Option

+ func (o Option[T]) Option() (T, bool)

type SeqDeque

+ func (seq SeqDeque[V]) FilterMap(fn func(V) Option[V]) SeqDeque[V]

+ func (seq SeqDeque[V]) FlatMap(fn func(V) SeqDeque[V]) SeqDeque[V]

+ func (seq SeqDeque[V]) Scan(init V, fn func(acc, val V) V) SeqDeque[V]

type SeqDequePar

+ func (p SeqDequePar[V]) FilterMap(fn func(V) Option[V]) SeqDequePar[V]

+ func (p SeqDequePar[V]) FlatMap(fn func(V) SeqDeque[V]) SeqDequePar[V]

+ func (p SeqDequePar[V]) MaxBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (p SeqDequePar[V]) MinBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (p SeqDequePar[V]) StepBy(n uint) SeqDequePar[V]

type SeqHeap

+ func (seq SeqHeap[V]) FilterMap(fn func(V) Option[V]) SeqHeap[V]

+ func (seq SeqHeap[V]) FlatMap(fn func(V) SeqHeap[V]) SeqHeap[V]

+ func (seq SeqHeap[V]) Scan(init V, fn func(acc, val V) V) SeqHeap[V]

type SeqHeapPar

+ func (p SeqHeapPar[V]) FilterMap(fn func(V) Option[V]) SeqHeapPar[V]

+ func (p SeqHeapPar[V]) FlatMap(fn func(V) SeqHeap[V]) SeqHeapPar[V]

+ func (p SeqHeapPar[V]) MaxBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (p SeqHeapPar[V]) MinBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (p SeqHeapPar[V]) StepBy(n uint) SeqHeapPar[V]

type SeqMap

+ func (seq SeqMap[K, V]) FilterMap(fn func(K, V) Option[Pair[K, V]]) SeqMap[K, V]

type SeqSlice

+ func (seq SeqSlice[V]) FilterMap(fn func(V) Option[V]) SeqSlice[V]

+ func (seq SeqSlice[V]) FlatMap(fn func(V) SeqSlice[V]) SeqSlice[V]

+ func (seq SeqSlice[V]) Scan(init V, fn func(acc, val V) V) SeqSlice[V]

type SeqSlicePar

+ func (p SeqSlicePar[V]) FilterMap(fn func(V) Option[V]) SeqSlicePar[V]

+ func (p SeqSlicePar[V]) FlatMap(fn func(V) SeqSlice[V]) SeqSlicePar[V]

+ func (p SeqSlicePar[V]) MaxBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (p SeqSlicePar[V]) MinBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (p SeqSlicePar[V]) StepBy(n uint) SeqSlicePar[V]

Aug 20, 2025

Changes in this version

type SeqDeque

+ func (seq SeqDeque[V]) Parallel(workers ...Int) SeqDequePar[V]

+ type SeqDequePar struct

+ func (p SeqDequePar[V]) All(fn func(V) bool) bool

+ func (p SeqDequePar[V]) Any(fn func(V) bool) bool

+ func (p SeqDequePar[V]) Chain(others ...SeqDequePar[V]) SeqDequePar[V]

+ func (p SeqDequePar[V]) Collect() *Deque[V]

+ func (p SeqDequePar[V]) Count() Int

+ func (p SeqDequePar[V]) Exclude(fn func(V) bool) SeqDequePar[V]

+ func (p SeqDequePar[V]) Filter(fn func(V) bool) SeqDequePar[V]

+ func (p SeqDequePar[V]) Find(fn func(V) bool) Option[V]

+ func (p SeqDequePar[V]) Flatten() SeqDequePar[V]

+ func (p SeqDequePar[V]) Fold(init V, fn func(acc, v V) V) V

+ func (p SeqDequePar[V]) ForEach(fn func(V))

+ func (p SeqDequePar[V]) Inspect(fn func(V)) SeqDequePar[V]

+ func (p SeqDequePar[V]) Map(fn func(V) V) SeqDequePar[V]

+ func (p SeqDequePar[V]) Partition(fn func(V) bool) (*Deque[V], *Deque[V])

+ func (p SeqDequePar[V]) Range(fn func(V) bool)

+ func (p SeqDequePar[V]) Reduce(fn func(a, b V) V) Option[V]

+ func (p SeqDequePar[V]) Skip(n uint) SeqDequePar[V]

+ func (p SeqDequePar[V]) Take(n uint) SeqDequePar[V]

+ func (p SeqDequePar[V]) Unique() SeqDequePar[V]

type SeqHeap

+ func (seq SeqHeap[V]) Parallel(workers ...Int) SeqHeapPar[V]

+ type SeqHeapPar struct

+ func (p SeqHeapPar[V]) All(fn func(V) bool) bool

+ func (p SeqHeapPar[V]) Any(fn func(V) bool) bool

+ func (p SeqHeapPar[V]) Chain(others ...SeqHeapPar[V]) SeqHeapPar[V]

+ func (p SeqHeapPar[V]) Collect() *Heap[V]

+ func (p SeqHeapPar[V]) CollectWith(compareFn func(V, V) cmp.Ordering) *Heap[V]

+ func (p SeqHeapPar[V]) Count() Int

+ func (p SeqHeapPar[V]) Exclude(fn func(V) bool) SeqHeapPar[V]

+ func (p SeqHeapPar[V]) Filter(fn func(V) bool) SeqHeapPar[V]

+ func (p SeqHeapPar[V]) Find(fn func(V) bool) Option[V]

+ func (p SeqHeapPar[V]) Flatten() SeqHeapPar[V]

+ func (p SeqHeapPar[V]) Fold(init V, fn func(acc, v V) V) V

+ func (p SeqHeapPar[V]) ForEach(fn func(V))

+ func (p SeqHeapPar[V]) Inspect(fn func(V)) SeqHeapPar[V]

+ func (p SeqHeapPar[V]) Map(fn func(V) V) SeqHeapPar[V]

+ func (p SeqHeapPar[V]) Partition(fn func(V) bool) (*Heap[V], *Heap[V])

+ func (p SeqHeapPar[V]) PartitionWith(fn func(V) bool, leftCmp, rightCmp func(V, V) cmp.Ordering) (*Heap[V], *Heap[V])

+ func (p SeqHeapPar[V]) Range(fn func(V) bool)

+ func (p SeqHeapPar[V]) Reduce(fn func(a, b V) V) Option[V]

+ func (p SeqHeapPar[V]) Skip(n uint) SeqHeapPar[V]

+ func (p SeqHeapPar[V]) Take(n uint) SeqHeapPar[V]

+ func (p SeqHeapPar[V]) Unique() SeqHeapPar[V]

Aug 19, 2025

Changes in this version

+ type Deque struct

+ func DequeOf[T any](elements ...T) *Deque[T]

+ func NewDeque[T any](capacity ...Int) *Deque[T]

+ func (dq *Deque[T]) Back() Option[T]

+ func (dq *Deque[T]) BinarySearch(value T, fn func(T, T) cmp.Ordering) (Int, bool)

+ func (dq *Deque[T]) Capacity() Int

+ func (dq *Deque[T]) Clear()

+ func (dq *Deque[T]) Clone() *Deque[T]

+ func (dq *Deque[T]) Contains(value T) bool

+ func (dq *Deque[T]) Eq(other *Deque[T]) bool

+ func (dq *Deque[T]) Front() Option[T]

+ func (dq *Deque[T]) Get(index Int) Option[T]

+ func (dq *Deque[T]) Index(value T) Int

+ func (dq *Deque[T]) Insert(index Int, value T)

+ func (dq *Deque[T]) IsEmpty() bool

+ func (dq *Deque[T]) Iter() SeqDeque[T]

+ func (dq *Deque[T]) IterReverse() SeqDeque[T]

+ func (dq *Deque[T]) Len() Int

+ func (dq *Deque[T]) MakeContiguous() Slice[T]

+ func (dq *Deque[T]) PopBack() Option[T]

+ func (dq *Deque[T]) PopFront() Option[T]

+ func (dq *Deque[T]) Print() *Deque[T]

+ func (dq *Deque[T]) Println() *Deque[T]

+ func (dq *Deque[T]) PushBack(value T)

+ func (dq *Deque[T]) PushFront(value T)

+ func (dq *Deque[T]) Remove(index Int) Option[T]

+ func (dq *Deque[T]) Reserve(additional Int)

+ func (dq *Deque[T]) Retain(predicate func(T) bool)

+ func (dq *Deque[T]) RotateLeft(mid Int)

+ func (dq *Deque[T]) RotateRight(k Int)

+ func (dq *Deque[T]) Set(index Int, value T) bool

+ func (dq *Deque[T]) ShrinkToFit()

+ func (dq *Deque[T]) Swap(i, j Int)

+ func (dq *Deque[T]) ToSlice() Slice[T]

+ func (dq Deque[T]) String() string

+ type Heap struct

+ func NewHeap[T any](compareFn func(T, T) cmp.Ordering) *Heap[T]

+ func (h *Heap[T]) Clear()

+ func (h *Heap[T]) Clone() *Heap[T]

+ func (h *Heap[T]) Empty() bool

+ func (h *Heap[T]) IntoIter() SeqHeap[T]

+ func (h *Heap[T]) Iter() SeqHeap[T]

+ func (h *Heap[T]) Len() Int

+ func (h *Heap[T]) Peek() Option[T]

+ func (h *Heap[T]) Pop() Option[T]

+ func (h *Heap[T]) Print() *Heap[T]

+ func (h *Heap[T]) Println() *Heap[T]

+ func (h *Heap[T]) Push(items ...T)

+ func (h *Heap[T]) ToSlice() Slice[T]

+ func (h *Heap[T]) Transform(fn func(*Heap[T]) *Heap[T]) *Heap[T]

+ func (h Heap[T]) String() string

+ type SeqDeque iter.Seq[V]

+ func (seq SeqDeque[V]) All(fn func(v V) bool) bool

+ func (seq SeqDeque[V]) Any(fn func(V) bool) bool

+ func (seq SeqDeque[V]) Chain(seqs ...SeqDeque[V]) SeqDeque[V]

+ func (seq SeqDeque[V]) Chunks(n Int) SeqSlices[V]

+ func (seq SeqDeque[V]) Collect() *Deque[V]

+ func (seq SeqDeque[V]) Combinations(size Int) SeqSlices[V]

+ func (seq SeqDeque[V]) Context(ctx context.Context) SeqDeque[V]

+ func (seq SeqDeque[V]) Count() Int

+ func (seq SeqDeque[V]) Counter() SeqMapOrd[V, Int]

+ func (seq SeqDeque[V]) Cycle() SeqDeque[V]

+ func (seq SeqDeque[V]) Dedup() SeqDeque[V]

+ func (seq SeqDeque[V]) Enumerate() SeqMapOrd[Int, V]

+ func (seq SeqDeque[V]) Exclude(fn func(V) bool) SeqDeque[V]

+ func (seq SeqDeque[V]) Filter(fn func(V) bool) SeqDeque[V]

+ func (seq SeqDeque[V]) Find(fn func(v V) bool) Option[V]

+ func (seq SeqDeque[V]) Flatten() SeqDeque[V]

+ func (seq SeqDeque[V]) Fold(init V, fn func(acc, val V) V) V

+ func (seq SeqDeque[V]) ForEach(fn func(v V))

+ func (seq SeqDeque[V]) GroupBy(fn func(a, b V) bool) SeqSlices[V]

+ func (seq SeqDeque[V]) Inspect(fn func(v V)) SeqDeque[V]

+ func (seq SeqDeque[V]) Intersperse(sep V) SeqDeque[V]

+ func (seq SeqDeque[V]) Map(transform func(V) V) SeqDeque[V]

+ func (seq SeqDeque[V]) MaxBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (seq SeqDeque[V]) MinBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (seq SeqDeque[V]) Nth(n Int) Option[V]

+ func (seq SeqDeque[V]) Partition(fn func(v V) bool) (*Deque[V], *Deque[V])

+ func (seq SeqDeque[V]) Permutations() SeqSlices[V]

+ func (seq SeqDeque[V]) Pull() (func() (V, bool), func())

+ func (seq SeqDeque[V]) Range(fn func(v V) bool)

+ func (seq SeqDeque[V]) Reduce(fn func(a, b V) V) Option[V]

+ func (seq SeqDeque[V]) Skip(n uint) SeqDeque[V]

+ func (seq SeqDeque[V]) SortBy(fn func(a, b V) cmp.Ordering) SeqDeque[V]

+ func (seq SeqDeque[V]) StepBy(n uint) SeqDeque[V]

+ func (seq SeqDeque[V]) Take(n uint) SeqDeque[V]

+ func (seq SeqDeque[V]) ToChan(ctxs ...context.Context) chan V

+ func (seq SeqDeque[V]) Unique() SeqDeque[V]

+ func (seq SeqDeque[V]) Windows(n Int) SeqSlices[V]

+ func (seq SeqDeque[V]) Zip(two SeqDeque[V]) SeqMapOrd[V, V]

+ type SeqHeap iter.Seq[V]

+ func (seq SeqHeap[T]) Eq(other SeqHeap[T]) bool

+ func (seq SeqHeap[V]) All(fn func(v V) bool) bool

+ func (seq SeqHeap[V]) Any(fn func(V) bool) bool

+ func (seq SeqHeap[V]) Chain(seqs ...SeqHeap[V]) SeqHeap[V]

+ func (seq SeqHeap[V]) Chunks(n Int) SeqSlices[V]

+ func (seq SeqHeap[V]) Collect() *Heap[V]

+ func (seq SeqHeap[V]) CollectWith(compareFn func(V, V) cmp.Ordering) *Heap[V]

+ func (seq SeqHeap[V]) Combinations(size Int) SeqSlices[V]

+ func (seq SeqHeap[V]) Context(ctx context.Context) SeqHeap[V]

+ func (seq SeqHeap[V]) Count() Int

+ func (seq SeqHeap[V]) Counter() SeqMapOrd[V, Int]

+ func (seq SeqHeap[V]) Cycle() SeqHeap[V]

+ func (seq SeqHeap[V]) Dedup() SeqHeap[V]

+ func (seq SeqHeap[V]) Enumerate() SeqMapOrd[Int, V]

+ func (seq SeqHeap[V]) Exclude(fn func(V) bool) SeqHeap[V]

+ func (seq SeqHeap[V]) Filter(fn func(V) bool) SeqHeap[V]

+ func (seq SeqHeap[V]) Find(fn func(v V) bool) Option[V]

+ func (seq SeqHeap[V]) Flatten() SeqHeap[V]

+ func (seq SeqHeap[V]) Fold(init V, fn func(acc, val V) V) V

+ func (seq SeqHeap[V]) ForEach(fn func(v V))

+ func (seq SeqHeap[V]) GroupBy(fn func(a, b V) bool) SeqSlices[V]

+ func (seq SeqHeap[V]) Inspect(fn func(v V)) SeqHeap[V]

+ func (seq SeqHeap[V]) Intersperse(sep V) SeqHeap[V]

+ func (seq SeqHeap[V]) Map(transform func(V) V) SeqHeap[V]

+ func (seq SeqHeap[V]) MaxBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (seq SeqHeap[V]) MinBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (seq SeqHeap[V]) Nth(n Int) Option[V]

+ func (seq SeqHeap[V]) Partition(fn func(v V) bool) (*Heap[V], *Heap[V])

+ func (seq SeqHeap[V]) PartitionWith(fn func(v V) bool, leftCmp, rightCmp func(V, V) cmp.Ordering) (*Heap[V], *Heap[V])

+ func (seq SeqHeap[V]) Permutations() SeqSlices[V]

+ func (seq SeqHeap[V]) Pull() (func() (V, bool), func())

+ func (seq SeqHeap[V]) Range(fn func(v V) bool)

+ func (seq SeqHeap[V]) Reduce(fn func(a, b V) V) Option[V]

+ func (seq SeqHeap[V]) Skip(n uint) SeqHeap[V]

+ func (seq SeqHeap[V]) SortBy(fn func(a, b V) cmp.Ordering) SeqHeap[V]

+ func (seq SeqHeap[V]) StepBy(n uint) SeqHeap[V]

+ func (seq SeqHeap[V]) Take(n uint) SeqHeap[V]

+ func (seq SeqHeap[V]) ToChan(ctxs ...context.Context) chan V

+ func (seq SeqHeap[V]) Unique() SeqHeap[V]

+ func (seq SeqHeap[V]) Windows(n Int) SeqSlices[V]

+ func (seq SeqHeap[V]) Zip(two SeqHeap[V]) SeqMapOrd[V, V]

type SeqMap

+ func (seq SeqMap[K, V]) Context(ctx context.Context) SeqMap[K, V]

+ func (seq SeqMap[K, V]) Nth(n Int) Option[Pair[K, V]]

type SeqMapOrd

+ func (seq SeqMapOrd[K, V]) Context(ctx context.Context) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) Nth(n Int) Option[Pair[K, V]]

type SeqResult

+ func (seq SeqResult[V]) Context(ctx context.Context) SeqResult[V]

+ func (seq SeqResult[V]) Nth(n Int) Result[Option[V]]

type SeqSet

+ func (seq SeqSet[V]) Context(ctx context.Context) SeqSet[V]

+ func (seq SeqSet[V]) Nth(n Int) Option[V]

+ func (seq SeqSet[V]) Take(n uint) SeqSet[V]

type SeqSlice

+ func (seq SeqSlice[V]) Context(ctx context.Context) SeqSlice[V]

+ func (seq SeqSlice[V]) MaxBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (seq SeqSlice[V]) MinBy(fn func(V, V) cmp.Ordering) Option[V]

+ func (seq SeqSlice[V]) Nth(n Int) Option[V]

type Slice

+ func (sl Slice[T]) ToHeap(compareFn func(T, T) cmp.Ordering) *Heap[T]

Aug 16, 2025

Changes in this version

type Bytes

+ func (bs Bytes) FloatBE() Float

+ func (bs Bytes) FloatLE() Float

type Float

+ func (f Float) BytesBE() Bytes

+ func (f Float) BytesLE() Bytes

type Int

+ func (i Int) BytesBE() Bytes

+ func (i Int) BytesLE() Bytes

Aug 15, 2025

Changes in this version

type Bytes

+ func (bs Bytes) IntBE() Int

+ func (bs Bytes) IntLE() Int

type Float

+ func (f Float) Bits() uint64

Aug 14, 2025

Changes in this version

type SeqSlice

+ func (seq SeqSlice[V]) Reduce(fn func(a, b V) V) Option[V]

type SeqSlicePar

+ func (p SeqSlicePar[V]) Reduce(fn func(a, b V) V) Option[V]

Aug 11, 2025

Changes in this version

type SeqSlice

+ func (seq SeqSlice[V]) GroupBy(fn func(a, b V) bool) SeqSlices[V]

Aug 6, 2025

Changes in this version

type SeqSlice

+ func RangeInclusive[T constraints.Integer](start, stop T, step ...T) SeqSlice[T]

Aug 6, 2025

Changes in this version

+ type Unit struct

Jun 19, 2025

Changes in this version

type MapSafe

+ func (ms *MapSafe[K, V]) Entry(key K) MapSafeEntry[K, V]

+ type MapSafeEntry struct

+ func (e MapSafeEntry[K, V]) Delete() Option[V]

+ func (e MapSafeEntry[K, V]) Get() Option[V]

+ func (e MapSafeEntry[K, V]) OrDefault() Option[V]

+ func (e MapSafeEntry[K, V]) OrSet(value V) Option[V]

+ func (e MapSafeEntry[K, V]) OrSetBy(fn func() V) Option[V]

+ func (e MapSafeEntry[K, V]) Set(value V) Option[V]

+ func (e MapSafeEntry[K, V]) Transform(fn func(V) V) Option[V]

Jun 18, 2025

Changes in this version

type Option

+ func (o Option[T]) Result(err error) Result[T]

type Result

+ func (r Result[T]) MapErr(fn func(error) error) Result[T]

Jun 10, 2025

Changes in this version

type Bytes

+ func (bs Bytes) Append(obs Bytes) Bytes

+ func (bs Bytes) Prepend(obs Bytes) Bytes

May 30, 2025

Changes in this version

+ type Box atomic.Pointer[T]

+ func NewBox[T any](ptr *T) *Box[T]

+ func (b *Box[T]) Load() *T

+ func (b *Box[T]) Store(value *T)

+ func (b *Box[T]) Update(apply func(current *T) *T)

May 15, 2025

Changes in this version

type SeqMapPar

+ func (p SeqMapPar[K, V]) ForEach(fn func(K, V))

+ func (p SeqMapPar[K, V]) Inspect(fn func(K, V)) SeqMapPar[K, V]

May 12, 2025

Changes in this version

type SeqSlice

+ func Range[T constraints.Integer](start, stop T, step ...T) SeqSlice[T]

May 11, 2025

Changes in this version

type MapEntry

+ func (e MapEntry[K, V]) Transform(fn func(*V)) MapEntry[K, V]

type MapOrdEntry

+ func (e MapOrdEntry[K, V]) Transform(fn func(*V)) MapOrdEntry[K, V]

May 11, 2025

Changes in this version

type Bytes

+ func (bs Bytes) Int() Int

type Map

+ func (m Map[K, V]) Entry(key K) MapEntry[K, V]

+ type MapEntry struct

+ func (e MapEntry[K, V]) AndModify(fn func(*V)) MapEntry[K, V]

+ func (e MapEntry[K, V]) Delete() MapEntry[K, V]

+ func (e MapEntry[K, V]) Get() Option[V]

+ func (e MapEntry[K, V]) OrDefault() MapEntry[K, V]

+ func (e MapEntry[K, V]) OrSet(value V) MapEntry[K, V]

+ func (e MapEntry[K, V]) OrSetBy(fn func() V) MapEntry[K, V]

+ func (e MapEntry[K, V]) Set(value V) MapEntry[K, V]

type MapOrd

+ func (mo *MapOrd[K, V]) Entry(key K) MapOrdEntry[K, V]

+ type MapOrdEntry struct

+ func (e MapOrdEntry[K, V]) AndModify(fn func(*V)) MapOrdEntry[K, V]

+ func (e MapOrdEntry[K, V]) Delete() MapOrdEntry[K, V]

+ func (e MapOrdEntry[K, V]) Get() Option[V]

+ func (e MapOrdEntry[K, V]) OrDefault() MapOrdEntry[K, V]

+ func (e MapOrdEntry[K, V]) OrSet(value V) MapOrdEntry[K, V]

+ func (e MapOrdEntry[K, V]) OrSetBy(fn func() V) MapOrdEntry[K, V]

+ func (e MapOrdEntry[K, V]) Set(value V) MapOrdEntry[K, V]

type MapSafe

+ func (ms *MapSafe[K, V]) GetAndSet(key K, value V) Option[V]

May 8, 2025

Changes in this version

type MapSafe

+ func (ms *MapSafe[K, V]) GetAndDelete(key K) Option[V]

type SeqMap

+ func (seq SeqMap[K, V]) Parallel(workers Int) SeqMapPar[K, V]

+ type SeqMapPar struct

+ func (p SeqMapPar[K, V]) All(fn func(K, V) bool) bool

+ func (p SeqMapPar[K, V]) Any(fn func(K, V) bool) bool

+ func (p SeqMapPar[K, V]) Chain(others ...SeqMapPar[K, V]) SeqMapPar[K, V]

+ func (p SeqMapPar[K, V]) Collect() Map[K, V]

+ func (p SeqMapPar[K, V]) Count() Int

+ func (p SeqMapPar[K, V]) Exclude(fn func(K, V) bool) SeqMapPar[K, V]

+ func (p SeqMapPar[K, V]) Filter(fn func(K, V) bool) SeqMapPar[K, V]

+ func (p SeqMapPar[K, V]) Find(fn func(K, V) bool) Option[Pair[K, V]]

+ func (p SeqMapPar[K, V]) Map(transform func(K, V) (K, V)) SeqMapPar[K, V]

+ func (p SeqMapPar[K, V]) Range(fn func(K, V) bool)

+ func (p SeqMapPar[K, V]) Skip(n Int) SeqMapPar[K, V]

+ func (p SeqMapPar[K, V]) Take(n Int) SeqMapPar[K, V]

type SeqSlice

+ func (seq SeqSlice[V]) Parallel(workers Int) SeqSlicePar[V]

+ type SeqSlicePar struct

+ func (p SeqSlicePar[V]) All(fn func(V) bool) bool

+ func (p SeqSlicePar[V]) Any(fn func(V) bool) bool

+ func (p SeqSlicePar[V]) Chain(others ...SeqSlicePar[V]) SeqSlicePar[V]

+ func (p SeqSlicePar[V]) Collect() Slice[V]

+ func (p SeqSlicePar[V]) Count() Int

+ func (p SeqSlicePar[V]) Exclude(fn func(V) bool) SeqSlicePar[V]

+ func (p SeqSlicePar[V]) Filter(fn func(V) bool) SeqSlicePar[V]

+ func (p SeqSlicePar[V]) Find(fn func(V) bool) Option[V]

+ func (p SeqSlicePar[V]) Flatten() SeqSlicePar[V]

+ func (p SeqSlicePar[V]) Fold(init V, fn func(acc, v V) V) V

+ func (p SeqSlicePar[V]) ForEach(fn func(V))

+ func (p SeqSlicePar[V]) Inspect(fn func(V)) SeqSlicePar[V]

+ func (p SeqSlicePar[V]) Map(fn func(V) V) SeqSlicePar[V]

+ func (p SeqSlicePar[V]) Partition(fn func(V) bool) (Slice[V], Slice[V])

+ func (p SeqSlicePar[V]) Range(fn func(V) bool)

+ func (p SeqSlicePar[V]) Skip(n Int) SeqSlicePar[V]

+ func (p SeqSlicePar[V]) Take(n Int) SeqSlicePar[V]

+ func (p SeqSlicePar[V]) Unique() SeqSlicePar[V]

May 5, 2025

Changes in this version

type File

+ func (f *File) ChunksRaw(size Int) SeqResult[Bytes]

+ func (f *File) LinesRaw() SeqResult[Bytes]

May 4, 2025

Changes in this version

type Bytes

+ func (bs *Bytes) Reset()

+ func (bs Bytes) StringSafe() String

type String

+ func (s String) BytesSafe() Bytes

+ func (s String) Clone() String

Apr 25, 2025

Changes in this version

type Bytes

+ func (bs Bytes) StringUnsafe() String

type Int

+ func (i Int) StringBuf(buf *Bytes) String

type String

+ func (s String) BytesUnsafe() Bytes

Apr 25, 2025

Changes in this version

+ func Errorf[T ~string](format T, args ...any) error

type Map

+ func (m *Map[K, V]) IntoIter() SeqMap[K, V]

type MapOrd

+ func (mo *MapOrd[K, V]) IntoIter() SeqMapOrd[K, V]

type MapSafe

+ func (ms *MapSafe[K, V]) IntoIter() SeqMap[K, V]

type Result

+ func Eprint[T ~string](format T, args ...any) Result[int]

+ func Eprintln[T ~string](format T, args ...any) Result[int]

+ func Write[T ~string](w io.Writer, format T, args ...any) Result[int]

+ func Writeln[T ~string](w io.Writer, format T, args ...any) Result[int]

type Set

+ func (s *Set[T]) IntoIter() SeqSet[T]

type Slice

+ func (sl *Slice[T]) IntoIter() SeqSlice[T]

Apr 11, 2025

Changes in this version

type Bytes

+ func (bs Bytes) Ptr() *Bytes

type Float

+ func (f Float) Ptr() *Float

type Int

+ func (i Int) Ptr() *Int

type Map

+ func (m Map[K, V]) Ptr() *Map[K, V]

+ func (m Map[K, V]) Ref() *Map[K, V]

type MapOrd

+ func (mo MapOrd[K, V]) Ptr() *MapOrd[K, V]

type Set

+ func (s Set[T]) Ptr() *Set[T]

type Slice

+ func (sl Slice[T]) Ptr() *Slice[T]

type String

+ func (s String) Ptr() *String

Apr 8, 2025

Changes in this version

type Slice

+ func (sl *Slice[T]) PushFront(elems ...T)

+ func (sl *Slice[T]) PushFrontUnique(elems ...T)

+ func (sl *Slice[T]) PushUnique(elems ...T)

+ func (sl Slice[T]) AppendUnique(elems ...T) Slice[T]

+ func (sl Slice[T]) Prepend(elems ...T) Slice[T]

+ func (sl Slice[T]) PrependUnique(elems ...T) Slice[T]

Mar 23, 2025

Changes in this version

type String

+ func (s String) Sprintf(template String) String

Mar 23, 2025

Changes in this version

type Set

+ func (s Set[T]) Insert(values ...T)

type Slice

+ func (sl *Slice[T]) Push(elems ...T)

Jan 22, 2025

Changes in this version

type MapOrd

+ func (mo MapOrd[K, V]) AsAny() MapOrd[any, any]

Jan 19, 2025

Changes in this version

+ type Named Map[String, any]

Jan 18, 2025

Changes in this version

type String

+ func (s String) SubString(start, end Int, step ...Int) String

Jan 18, 2025

Changes in this version

type String

+ func (s String) Truncate(max Int) String

Jan 17, 2025

Changes in this version

type Builder

+ func (b *Builder) WriteString(str string) *Builder

Jan 16, 2025

Changes in this version

type Bytes

+ func (bs Bytes) Regexp() regexpb

type String

+ func (s String) Regexp() regexps

Jan 16, 2025

Changes in this version

+ func Fprint(w io.Writer, a ...any) (int, error)

+ func Fprintf[T ~string](w io.Writer, format T, a ...any) (int, error)

+ func Fprintln(w io.Writer, a ...any) (int, error)

+ func Print(a ...any) (int, error)

+ func Printf[T ~string](format T, a ...any) (int, error)

+ func Println(a ...any) (int, error)

type Bytes

+ func (bs Bytes) Println() Bytes

type Dir

+ func (d *Dir) Println() *Dir

type File

+ func (f *File) Println() *File

type Float

+ func (f Float) Println() Float

type Int

+ func (i Int) Println() Int

type Map

+ func (m Map[K, V]) Println() Map[K, V]

type MapOrd

+ func (mo MapOrd[K, V]) Println() MapOrd[K, V]

type MapSafe

+ func (ms *MapSafe[K, V]) Println() *MapSafe[K, V]

type Set

+ func (s Set[T]) Println() Set[T]

type Slice

+ func (sl Slice[T]) Println() Slice[T]

type String

+ func Sprintln(a ...any) String

+ func (s String) Println() String

Jan 14, 2025

Changes in this version

type Bytes

+ func (bs Bytes) RxMatch(pattern *regexp.Regexp) bool

+ func (bs Bytes) RxMatchAll(patterns ...*regexp.Regexp) bool

+ func (bs Bytes) RxMatchAny(patterns ...*regexp.Regexp) bool

Jan 14, 2025

Changes in this version

type String

+ func (s String) ToRegexp() Result[*regexp.Regexp]

Dec 24, 2024

Changes in this version

type SeqResult

+ func (seq SeqResult[V]) Count() Int

+ func (seq SeqResult[V]) Find(fn func(V) bool) Result[Option[V]]

Dec 23, 2024

Changes in this version

+ type SeqResult iter.Seq[Result[V]]

+ func (seq SeqResult[V]) All(fn func(v V) bool) Result[bool]

+ func (seq SeqResult[V]) Any(fn func(v V) bool) Result[bool]

+ func (seq SeqResult[V]) Chain(seqs ...SeqResult[V]) SeqResult[V]

+ func (seq SeqResult[V]) Collect() Result[Slice[V]]

+ func (seq SeqResult[V]) Dedup() SeqResult[V]

+ func (seq SeqResult[V]) Exclude(fn func(V) bool) SeqResult[V]

+ func (seq SeqResult[V]) Filter(fn func(V) bool) SeqResult[V]

+ func (seq SeqResult[V]) ForEach(fn func(v Result[V]))

+ func (seq SeqResult[V]) Inspect(fn func(v V)) SeqResult[V]

+ func (seq SeqResult[V]) Intersperse(sep V) SeqResult[V]

+ func (seq SeqResult[V]) Map(transform func(V) V) SeqResult[V]

+ func (seq SeqResult[V]) Pull() (func() (Result[V], bool), func())

+ func (seq SeqResult[V]) Range(fn func(v Result[V]) bool)

+ func (seq SeqResult[V]) Skip(n uint) SeqResult[V]

+ func (seq SeqResult[V]) StepBy(n uint) SeqResult[V]

+ func (seq SeqResult[V]) Take(n uint) SeqResult[V]

+ func (seq SeqResult[V]) Unique() SeqResult[V]

Dec 22, 2024

Changes in this version

type Map

+ func (m Map[K, V]) ToMapOrd() MapOrd[K, V]

+ func (m Map[K, V]) ToMapSafe() *MapSafe[K, V]

type SeqSet

+ func (seq SeqSet[V]) Find(fn func(v V) bool) Option[V]

Dec 20, 2024

Changes in this version

type Map

+ func (m Map[K, V]) MapSafe() *MapSafe[K, V]

+ type MapSafe struct

+ func NewMapSafe[K comparable, V any](size ...Int) *MapSafe[K, V]

+ func (ms *MapSafe[K, V]) Clear() *MapSafe[K, V]

+ func (ms *MapSafe[K, V]) Clone() *MapSafe[K, V]

+ func (ms *MapSafe[K, V]) Contains(key K) bool

+ func (ms *MapSafe[K, V]) Copy(src *MapSafe[K, V]) *MapSafe[K, V]

+ func (ms *MapSafe[K, V]) Delete(keys ...K) *MapSafe[K, V]

+ func (ms *MapSafe[K, V]) Empty() bool

+ func (ms *MapSafe[K, V]) Eq(other *MapSafe[K, V]) bool

+ func (ms *MapSafe[K, V]) Get(key K) Option[V]

+ func (ms *MapSafe[K, V]) GetOrSet(key K, defaultValue V) V

+ func (ms *MapSafe[K, V]) Invert() *MapSafe[any, K]

+ func (ms *MapSafe[K, V]) Iter() SeqMap[K, V]

+ func (ms *MapSafe[K, V]) Keys() Slice[K]

+ func (ms *MapSafe[K, V]) Len() Int

+ func (ms *MapSafe[K, V]) LockedIter() SeqMap[K, V]

+ func (ms *MapSafe[K, V]) Ne(other *MapSafe[K, V]) bool

+ func (ms *MapSafe[K, V]) NotEmpty() bool

+ func (ms *MapSafe[K, V]) Print() *MapSafe[K, V]

+ func (ms *MapSafe[K, V]) Set(key K, value V) *MapSafe[K, V]

+ func (ms *MapSafe[K, V]) String() string

+ func (ms *MapSafe[K, V]) Values() Slice[V]

Dec 18, 2024

Changes in this version

type Pool

+ func (p *Pool[T]) GetContext() context.Context

Dec 16, 2024

Changes in this version

type Pool

+ func (p *Pool[T]) CancelOnError() *Pool[T]

+ func (p *Pool[T]) Cause() error

Dec 15, 2024

Changes in this version

+ type ErrorContext struct

+ Err error

+ Index int32

+ func (e *ErrorContext) Error() string

Dec 13, 2024

Changes in this version

+ type Pool struct

+ func NewPool[T any]() *Pool[T]

+ func (p *Pool[T]) ActiveTasks() int

+ func (p *Pool[T]) Cancel()

+ func (p *Pool[T]) ClearMetrics()

+ func (p *Pool[T]) ClearResults()

+ func (p *Pool[T]) Context(ctx context.Context)

+ func (p *Pool[T]) FailedTasks() int

+ func (p *Pool[T]) Go(fn func() Result[T])

+ func (p *Pool[T]) Limit(n int)

+ func (p *Pool[T]) Reset()

+ func (p *Pool[T]) TotalTasks() int

+ func (p *Pool[T]) Wait() Slice[Result[T]]

type Set

+ func (s Set[T]) NotEmpty() bool

Dec 6, 2024

Changes in this version

type Option

+ func OptionOf[T any](value T, ok bool) Option[T]

Dec 4, 2024

Changes in this version

type MapOrd

+ func (mo MapOrd[K, V]) IterReverse() SeqMapOrd[K, V]

type Slice

+ func (sl Slice[T]) IterReverse() SeqSlice[T]

Nov 30, 2024

Changes in this version

type Bytes

+ func (bs Bytes) RxFind(pattern *regexp.Regexp) Option[Bytes]

+ func (bs Bytes) RxFindAll(pattern *regexp.Regexp) Option[Slice[Bytes]]

+ func (bs Bytes) RxFindAllN(pattern *regexp.Regexp, n Int) Option[Slice[Bytes]]

+ func (bs Bytes) RxFindAllSubmatch(pattern *regexp.Regexp) Option[Slice[Slice[Bytes]]]

+ func (bs Bytes) RxFindAllSubmatchN(pattern *regexp.Regexp, n Int) Option[Slice[Slice[Bytes]]]

+ func (bs Bytes) RxFindSubmatch(pattern *regexp.Regexp) Option[Slice[Bytes]]

+ func (bs Bytes) RxIndex(pattern *regexp.Regexp) Option[Slice[Int]]

+ func (bs Bytes) RxReplace(pattern *regexp.Regexp, newB Bytes) Bytes

type Option

+ func TransformOption[T, U any](o Option[T], fn func(T) Option[U]) Option[U]

type Result

+ func TransformResultOf[T, U any](r Result[T], fn func(T) (U, error)) Result[U]

+ func TransformResult[T, U any](r Result[T], fn func(T) Result[U]) Result[U]

type String

+ func (s String) RxFind(pattern *regexp.Regexp) Option[String]

+ func (s String) RxFindAll(pattern *regexp.Regexp) Option[Slice[String]]

+ func (s String) RxFindAllN(pattern *regexp.Regexp, n Int) Option[Slice[String]]

+ func (s String) RxFindAllSubmatch(pattern *regexp.Regexp) Option[Slice[Slice[String]]]

+ func (s String) RxFindAllSubmatchN(pattern *regexp.Regexp, n Int) Option[Slice[Slice[String]]]

+ func (s String) RxFindSubmatch(pattern *regexp.Regexp) Option[Slice[String]]

+ func (s String) RxIndex(pattern *regexp.Regexp) Option[Slice[Int]]

+ func (s String) RxMatch(pattern *regexp.Regexp) bool

+ func (s String) RxMatchAll(patterns ...*regexp.Regexp) bool

+ func (s String) RxMatchAny(patterns ...*regexp.Regexp) bool

+ func (s String) RxReplace(pattern *regexp.Regexp, newS String) String

+ func (s String) RxSplit(pattern *regexp.Regexp) Slice[String]

+ func (s String) RxSplitN(pattern *regexp.Regexp, n Int) Option[Slice[String]]

Nov 30, 2024

Changes in this version

type Map

+ func (m Map[K, V]) MapOrd() MapOrd[K, V]

Nov 29, 2024

Changes in this version

type String

+ func (s String) EndsWithAny(suffixes ...String) bool

+ func (s String) StartsWithAny(prefixes ...String) bool

Nov 27, 2024

Changes in this version

type Bytes

+ func (bs Bytes) Transform(fn func(Bytes) Bytes) Bytes

type Float

+ func (f Float) Transform(fn func(Float) Float) Float

type Int

+ func (i Int) Transform(fn func(Int) Int) Int

type Map

+ func (m Map[K, V]) Transform(fn func(Map[K, V]) Map[K, V]) Map[K, V]

type MapOrd

+ func (mo MapOrd[K, V]) Transform(fn func(MapOrd[K, V]) MapOrd[K, V]) MapOrd[K, V]

type Set

+ func TransformSet[T, U comparable](s Set[T], fn func(T) U) Set[U]

+ func (s Set[T]) Transform(fn func(Set[T]) Set[T]) Set[T]

type Slice

+ func TransformSlice[T, U any](sl Slice[T], fn func(T) U) Slice[U]

+ func (sl Slice[T]) Transform(fn func(Slice[T]) Slice[T]) Slice[T]

type String

+ func (s String) Transform(fn func(String) String) String

Nov 3, 2024

Changes in this version

type MapOrd

+ func (mo MapOrd[K, V]) Shuffle()

Jul 22, 2024

Changes in this version

type Dir

+ func (d *Dir) String() String

Jul 11, 2024

Changes in this version

type File

+ func (f *File) Decode() fdecode

+ func (f *File) Encode() fencode

type String

+ func (s String) Compress() compress

+ func (s String) Decode() decode

+ func (s String) Decompress() decompress

+ func (s String) Encode() encode

Jul 9, 2024

Changes in this version

type String

+ func (s String) ToBigInt() Option[*big.Int]

Jun 14, 2024

Changes in this version

type Bytes

+ func (bs Bytes) TrimEndSet(cutset String) Bytes

+ func (bs Bytes) TrimSet(cutset String) Bytes

+ func (bs Bytes) TrimStartSet(cutset String) Bytes

type String

+ func (s String) TrimEndSet(cutset String) String

+ func (s String) TrimSet(cutset String) String

+ func (s String) TrimStartSet(cutset String) String

May 31, 2024

Changes in this version

type Bytes

+ func (bs Bytes) Runes() []rune

+ func (bs Bytes) String() String

+ func (bs Bytes) StripPrefix(cutset Bytes) Bytes

+ func (bs Bytes) StripSuffix(cutset Bytes) Bytes

+ func (bs Bytes) TrimEnd(cutset ...String) Bytes

+ func (bs Bytes) TrimStart(cutset ...String) Bytes

type Float

+ func (f Float) BigFloat() *big.Float

+ func (f Float) Float32() float32

+ func (f Float) Int() Int

+ func (f Float) String() String

+ func (f Float) UInt64() uint64

type Int

+ func (i Int) BigInt() *big.Int

+ func (i Int) Binary() String

+ func (i Int) Float() Float

+ func (i Int) Hex() String

+ func (i Int) Int16() int16

+ func (i Int) Int32() int32

+ func (i Int) Int64() int64

+ func (i Int) Int8() int8

+ func (i Int) Octal() String

+ func (i Int) String() String

+ func (i Int) UInt() uint

+ func (i Int) UInt16() uint16

+ func (i Int) UInt32() uint32

+ func (i Int) UInt64() uint64

+ func (i Int) UInt8() uint8

type String

+ func (s String) Bytes() Bytes

+ func (s String) Runes() Slice[rune]

+ func (s String) StripPrefix(prefix String) String

+ func (s String) StripSuffix(suffix String) String

+ func (s String) TrimEnd(cutset ...String) String

+ func (s String) TrimStart(cutset ...String) String

May 18, 2024

Changes in this version

type SeqSlice

+ func (seq SeqSlice[V]) Intersperse(sep V) SeqSlice[V]

May 15, 2024

Changes in this version

type String

+ func (s String) Remove(matches ...String) String

Apr 29, 2024

Changes in this version

type Bytes

+ func (bs Bytes) Fields() SeqSlice[Bytes]

+ func (bs Bytes) FieldsBy(fn func(r rune) bool) SeqSlice[Bytes]

+ func (bs Bytes) SplitAfter(sep Bytes) SeqSlice[Bytes]

Apr 29, 2024

Changes in this version

type String

+ func (s String) FieldsBy(fn func(r rune) bool) SeqSlice[String]

+ func (s String) Gte(str String) bool

+ func (s String) Lines() SeqSlice[String]

+ func (s String) Lte(str String) bool

+ func (s String) SplitAfter(sep String) SeqSlice[String]

Apr 21, 2024

Changes in this version

type Slice

+ func (sl Slice[T]) MaxBy(fn func(a, b T) cmp.Ordering) T

+ func (sl Slice[T]) MinBy(fn func(a, b T) cmp.Ordering) T

Apr 17, 2024

Changes in this version

type MapOrd

+ func (mo MapOrd[K, V]) SortByKey(fn func(a, b K) cmp.Ordering) MapOrd[K, V]

+ func (mo MapOrd[K, V]) SortByValue(fn func(a, b V) cmp.Ordering) MapOrd[K, V]

type SeqMapOrd

+ func (seq SeqMapOrd[K, V]) SortByKey(fn func(a, b K) cmp.Ordering) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) SortByValue(fn func(a, b V) cmp.Ordering) SeqMapOrd[K, V]

Apr 14, 2024

Changes in this version

type Bytes

+ func (bs Bytes) Cmp(obs Bytes) cmp.Ordered

type Float

+ func (f Float) Cmp(b Float) cmp.Ordered

type Int

+ func (i Int) Cmp(b Int) cmp.Ordered

type String

+ func (s String) Cmp(str String) cmp.Ordered

Apr 13, 2024

Changes in this version

type SeqMapOrd

+ func (seq SeqMapOrd[K, V]) ToChan(ctxs ...context.Context) chan Pair[K, V]

type SeqSlice

+ func FromChan[V any](ch <-chan V) SeqSlice[V]

+ func (seq SeqSlice[V]) ToChan(ctxs ...context.Context) chan V

Apr 12, 2024

Changes in this version

type Slice

+ func (sl Slice[T]) NeBy(other Slice[T], fn func(x, y T) bool) bool

Apr 12, 2024

Changes in this version

type SeqSlice

+ func (seq SeqSlice[V]) Counter() SeqMapOrd[V, uint]

Apr 11, 2024

Changes in this version

type Slice

+ func (sl Slice[T]) ContainsBy(val T, fn func(x, y T) bool) bool

+ func (sl Slice[T]) EqBy(other Slice[T], fn func(x, y T) bool) bool

+ func (sl Slice[T]) IndexBy(val T, fn func(x, y T) bool) int

Apr 10, 2024

Changes in this version

+ type SeqMap iter.Seq2[K, V]

+ func ToSeqMap[K comparable, V any](hashmap map[K]V) SeqMap[K, V]

+ func (seq SeqMap[K, V]) Chain(seqs ...SeqMap[K, V]) SeqMap[K, V]

+ func (seq SeqMap[K, V]) Collect() Map[K, V]

+ func (seq SeqMap[K, V]) Count() int

+ func (seq SeqMap[K, V]) Exclude(fn func(K, V) bool) SeqMap[K, V]

+ func (seq SeqMap[K, V]) Filter(fn func(K, V) bool) SeqMap[K, V]

+ func (seq SeqMap[K, V]) Find(fn func(k K, v V) bool) Option[Pair[K, V]]

+ func (seq SeqMap[K, V]) ForEach(fn func(k K, v V))

+ func (seq SeqMap[K, V]) Inspect(fn func(k K, v V)) SeqMap[K, V]

+ func (seq SeqMap[K, V]) Keys() SeqSlice[K]

+ func (seq SeqMap[K, V]) Map(transform func(K, V) (K, V)) SeqMap[K, V]

+ func (seq SeqMap[K, V]) Pull() (func() (K, V, bool), func())

+ func (seq SeqMap[K, V]) Range(fn func(k K, v V) bool)

+ func (seq SeqMap[K, V]) Take(n uint) SeqMap[K, V]

+ func (seq SeqMap[K, V]) Values() SeqSlice[V]

+ type SeqMapOrd iter.Seq2[K, V]

+ func ToSeqMapOrd[K, V any](mo MapOrd[K, V]) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) Chain(seqs ...SeqMapOrd[K, V]) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) Collect() MapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) Count() int

+ func (seq SeqMapOrd[K, V]) Exclude(fn func(K, V) bool) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) Filter(fn func(K, V) bool) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) Find(fn func(k K, v V) bool) Option[Pair[K, V]]

+ func (seq SeqMapOrd[K, V]) ForEach(fn func(k K, v V))

+ func (seq SeqMapOrd[K, V]) Inspect(fn func(k K, v V)) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) Keys() SeqSlice[K]

+ func (seq SeqMapOrd[K, V]) Map(transform func(K, V) (K, V)) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) Pull() (func() (K, V, bool), func())

+ func (seq SeqMapOrd[K, V]) Range(fn func(k K, v V) bool)

+ func (seq SeqMapOrd[K, V]) Skip(n uint) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) SortBy(fn func(a, b Pair[K, V]) bool) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) StepBy(n uint) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) Take(limit uint) SeqMapOrd[K, V]

+ func (seq SeqMapOrd[K, V]) ToChannel(ctxs ...context.Context) chan Pair[K, V]

+ func (seq SeqMapOrd[K, V]) Unzip() (SeqSlice[K], SeqSlice[V])

+ func (seq SeqMapOrd[K, V]) Values() SeqSlice[V]

+ type SeqSet iter.Seq[V]

+ func ToSeqSet[V comparable](slice Set[V]) SeqSet[V]

+ func (seq SeqSet[V]) Chain(seqs ...SeqSet[V]) SeqSet[V]

+ func (seq SeqSet[V]) Collect() Set[V]

+ func (seq SeqSet[V]) Count() int

+ func (seq SeqSet[V]) Exclude(fn func(V) bool) SeqSet[V]

+ func (seq SeqSet[V]) Filter(fn func(V) bool) SeqSet[V]

+ func (seq SeqSet[V]) ForEach(fn func(v V))

+ func (seq SeqSet[V]) Inspect(fn func(v V)) SeqSet[V]

+ func (seq SeqSet[V]) Map(transform func(V) V) SeqSet[V]

+ func (seq SeqSet[V]) Pull() (func() (V, bool), func())

+ func (seq SeqSet[V]) Range(fn func(v V) bool)

+ type SeqSlice iter.Seq[V]

+ func ToSeqSlice[V any](slice []V) SeqSlice[V]

+ func (seq SeqSlice[V]) All(fn func(v V) bool) bool

+ func (seq SeqSlice[V]) Any(fn func(V) bool) bool

+ func (seq SeqSlice[V]) Chain(seqs ...SeqSlice[V]) SeqSlice[V]

+ func (seq SeqSlice[V]) Chunks(n int) SeqSlices[V]

+ func (seq SeqSlice[V]) Collect() Slice[V]

+ func (seq SeqSlice[V]) Combinations(n int) SeqSlices[V]

+ func (seq SeqSlice[V]) Count() int

+ func (seq SeqSlice[V]) Cycle() SeqSlice[V]

+ func (seq SeqSlice[V]) Dedup() SeqSlice[V]

+ func (seq SeqSlice[V]) Enumerate() SeqMapOrd[int, V]

+ func (seq SeqSlice[V]) Exclude(fn func(V) bool) SeqSlice[V]

+ func (seq SeqSlice[V]) Filter(fn func(V) bool) SeqSlice[V]

+ func (seq SeqSlice[V]) Find(fn func(v V) bool) Option[V]

+ func (seq SeqSlice[V]) Flatten() SeqSlice[V]

+ func (seq SeqSlice[V]) Fold(init V, fn func(acc, val V) V) V

+ func (seq SeqSlice[V]) ForEach(fn func(v V))

+ func (seq SeqSlice[V]) Inspect(fn func(v V)) SeqSlice[V]

+ func (seq SeqSlice[V]) Map(transform func(V) V) SeqSlice[V]

+ func (seq SeqSlice[V]) Partition(fn func(v V) bool) (Slice[V], Slice[V])

+ func (seq SeqSlice[V]) Permutations() SeqSlices[V]

+ func (seq SeqSlice[V]) Pull() (func() (V, bool), func())

+ func (seq SeqSlice[V]) Range(fn func(v V) bool)

+ func (seq SeqSlice[V]) Skip(n uint) SeqSlice[V]

+ func (seq SeqSlice[V]) Sort() SeqSlice[V]

+ func (seq SeqSlice[V]) SortBy(fn func(a, b V) bool) SeqSlice[V]

+ func (seq SeqSlice[V]) StepBy(n uint) SeqSlice[V]

+ func (seq SeqSlice[V]) Take(n uint) SeqSlice[V]

+ func (seq SeqSlice[V]) ToChannel(ctxs ...context.Context) chan V

+ func (seq SeqSlice[V]) Unique() SeqSlice[V]

+ func (seq SeqSlice[V]) Windows(n int) SeqSlices[V]

+ func (seq SeqSlice[V]) Zip(two SeqSlice[V]) SeqMapOrd[V, V]

+ type SeqSlices iter.Seq[[]V]

+ func (seqs SeqSlices[V]) Collect() []Slice[V]

Apr 7, 2024

Changes in this version

+ type Builder struct

+ func NewBuilder() *Builder

+ func (b *Builder) Cap() int

+ func (b *Builder) Grow(n int)

+ func (b *Builder) Len() int

+ func (b *Builder) Reset()

+ func (b *Builder) String() String

+ func (b *Builder) Write(str String) *Builder

+ func (b *Builder) WriteByte(c byte) *Builder

+ func (b *Builder) WriteBytes(bs Bytes) *Builder

+ func (b *Builder) WriteRune(r rune) *Builder

type String

+ func (s String) Append(str String) String

+ func (s String) Builder() *Builder

+ func (s String) Prepend(str String) String

Apr 3, 2024

Changes in this version

type Option

+ func (o Option[T]) String() string

type Result

+ func (r Result[T]) String() string

Mar 28, 2024

Changes in this version

+ func FromChannel[V any](ch <-chan V) seqSlice[V]

Mar 24, 2024

Changes in this version

type File

+ func (f *File) Chunks(size int) Result[seqSlice[String]]

Mar 20, 2024

Changes in this version

type Option

+ func OptionMap[T, U any](o Option[T], fn func(T) Option[U]) Option[U]

Mar 18, 2024

Changes in this version

type Option

+ func MapOption[T, U any](o Option[T], fn func(T) Option[U]) Option[U]

type Result

+ func ResultMap[T, U any](r Result[T], fn func(T) Result[U]) Result[U]

+ func ResultOfMap[T, U any](r Result[T], fn func(T) (U, error)) Result[U]

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

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

+ func (r Result[T]) ThenOf(fn func(T) (T, error)) Result[T]

type Set

+ func SetMap[T, U comparable](s Set[T], fn func(T) U) Set[U]

type Slice

+ func SliceMap[T, U any](sl Slice[T], fn func(T) U) Slice[U]

Mar 17, 2024

Changes in this version

type Option

+ func ToOption[T any](value T, ok bool) Option[T]

+ func (o Option[T]) ThenOption(fn func(T) (T, bool)) Option[T]

type Result

+ func (r Result[T]) ThenResult(fn func(T) (T, error)) Result[T]

Mar 17, 2024

Changes in this version

+ const ASCII_LETTERS

+ const ASCII_LOWERCASE

+ const ASCII_UPPERCASE

+ const DIGITS

+ const DirDefault

+ const FileCreate

+ const FileDefault

+ const FullAccess

+ const HEXDIGITS

+ const OCTDIGITS

+ const PUNCTUATION

+ const PathSeperator

+ var SkipWalk = errors.New("skip")

+ var StopWalk = errors.New("stop")

+ type Bytes []byte

+ func NewBytes[T ~string | ~[]byte](bs T) Bytes

+ func (bs Bytes) Add(obs Bytes) Bytes

+ func (bs Bytes) AddPrefix(obs Bytes) Bytes

+ func (bs Bytes) Clone() Bytes

+ func (bs Bytes) Compare(obs Bytes) Int

+ func (bs Bytes) Contains(obs Bytes) bool

+ func (bs Bytes) ContainsAll(obss ...Bytes) bool

+ func (bs Bytes) ContainsAny(obss ...Bytes) bool

+ func (bs Bytes) ContainsAnyChars(chars String) bool

+ func (bs Bytes) ContainsRune(r rune) bool

+ func (bs Bytes) Count(obs Bytes) int

+ func (bs Bytes) Empty() bool

+ func (bs Bytes) Eq(obs Bytes) bool

+ func (bs Bytes) EqFold(obs Bytes) bool

+ func (bs Bytes) FindAllRegexp(pattern *regexp.Regexp) Option[Slice[Bytes]]

+ func (bs Bytes) FindAllRegexpN(pattern *regexp.Regexp, n Int) Option[Slice[Bytes]]

+ func (bs Bytes) FindAllSubmatchRegexp(pattern *regexp.Regexp) Option[Slice[Slice[Bytes]]]

+ func (bs Bytes) FindAllSubmatchRegexpN(pattern *regexp.Regexp, n Int) Option[Slice[Slice[Bytes]]]

+ func (bs Bytes) FindRegexp(pattern *regexp.Regexp) Option[Bytes]

+ func (bs Bytes) FindSubmatchRegexp(pattern *regexp.Regexp) Option[Slice[Bytes]]

+ func (bs Bytes) Gt(obs Bytes) bool

+ func (bs Bytes) Hash() bhash

+ func (bs Bytes) Index(obs Bytes) int

+ func (bs Bytes) IndexByte(b byte) int

+ func (bs Bytes) IndexRegexp(pattern *regexp.Regexp) Option[Slice[Int]]

+ func (bs Bytes) IndexRune(r rune) int

+ func (bs Bytes) LastIndex(obs Bytes) int

+ func (bs Bytes) LastIndexByte(b byte) int

+ func (bs Bytes) Len() int

+ func (bs Bytes) LenRunes() int

+ func (bs Bytes) Lower() Bytes

+ func (bs Bytes) Lt(obs Bytes) bool

+ func (bs Bytes) Map(fn func(rune) rune) Bytes

+ func (bs Bytes) Ne(obs Bytes) bool

+ func (bs Bytes) NormalizeNFC() Bytes

+ func (bs Bytes) NotEmpty() bool

+ func (bs Bytes) Print() Bytes

+ func (bs Bytes) Reader() *bytes.Reader

+ func (bs Bytes) Repeat(count int) Bytes

+ func (bs Bytes) Replace(oldB, newB Bytes, n int) Bytes

+ func (bs Bytes) ReplaceAll(oldB, newB Bytes) Bytes

+ func (bs Bytes) ReplaceRegexp(pattern *regexp.Regexp, newB Bytes) Bytes

+ func (bs Bytes) Reverse() Bytes

+ func (bs Bytes) Split(sep ...Bytes) Slice[Bytes]

+ func (bs Bytes) Std() []byte

+ func (bs Bytes) Title() Bytes

+ func (bs Bytes) ToRunes() []rune

+ func (bs Bytes) ToString() String

+ func (bs Bytes) Trim(cutset String) Bytes

+ func (bs Bytes) TrimLeft(cutset String) Bytes

+ func (bs Bytes) TrimPrefix(cutset Bytes) Bytes

+ func (bs Bytes) TrimRight(cutset String) Bytes

+ func (bs Bytes) TrimSpace() Bytes

+ func (bs Bytes) TrimSuffix(cutset Bytes) Bytes

+ func (bs Bytes) Upper() Bytes

+ type Dir struct

+ func NewDir(path String) *Dir

+ func (*Dir) CreateTemp(args ...String) Result[*Dir]

+ func (*Dir) Temp() *Dir

+ func (d *Dir) Chown(uid, gid int) Result[*Dir]

+ func (d *Dir) Copy(dest String, followLinks ...bool) Result[*Dir]

+ func (d *Dir) Create(mode ...os.FileMode) Result[*Dir]

+ func (d *Dir) CreateAll(mode ...os.FileMode) Result[*Dir]

+ func (d *Dir) Exist() bool

+ func (d *Dir) Glob() Result[Slice[*File]]

+ func (d *Dir) IsLink() bool

+ func (d *Dir) Join(elem ...String) Result[String]

+ func (d *Dir) Lstat() Result[fs.FileInfo]

+ func (d *Dir) Move(newpath String) Result[*Dir]

+ func (d *Dir) Path() Result[String]

+ func (d *Dir) Print() *Dir

+ func (d *Dir) Read() Result[Slice[*File]]

+ func (d *Dir) Remove() Result[*Dir]

+ func (d *Dir) Rename(newpath String) Result[*Dir]

+ func (d *Dir) SetPath(path String) *Dir

+ func (d *Dir) Stat() Result[fs.FileInfo]

+ func (d *Dir) ToString() String

+ func (d *Dir) Walk(walker func(f *File) error) error

+ type ErrFileClosed struct

+ Msg string

+ func (e *ErrFileClosed) Error() string

+ type ErrFileNotExist struct

+ Msg string

+ func (e *ErrFileNotExist) Error() string

+ type File struct

+ func NewFile(name String) *File

+ func (*File) CreateTemp(args ...String) Result[*File]

+ func (f *File) Append(content String, mode ...os.FileMode) Result[*File]

+ func (f *File) Chmod(mode os.FileMode) Result[*File]

+ func (f *File) Chown(uid, gid int) Result[*File]

+ func (f *File) Close() error

+ func (f *File) Copy(dest String, mode ...os.FileMode) Result[*File]

+ func (f *File) Create() Result[*File]

+ func (f *File) Dec() fdec

+ func (f *File) Dir() Result[*Dir]

+ func (f *File) Enc() fenc

+ func (f *File) Exist() bool

+ func (f *File) Ext() String

+ func (f *File) Guard() *File

+ func (f *File) IsDir() bool

+ func (f *File) IsLink() bool

+ func (f *File) Lines() Result[seqSlice[String]]

+ func (f *File) Lstat() Result[fs.FileInfo]

+ func (f *File) MimeType() Result[String]

+ func (f *File) Move(newpath String) Result[*File]

+ func (f *File) Name() String

+ func (f *File) Open() Result[*File]

+ func (f *File) OpenFile(flag int, perm fs.FileMode) Result[*File]

+ func (f *File) Path() Result[String]

+ func (f *File) Print() *File

+ func (f *File) Read() Result[String]

+ func (f *File) Remove() Result[*File]

+ func (f *File) Rename(newpath String) Result[*File]

+ func (f *File) Seek(offset int64, whence int) Result[*File]

+ func (f *File) Split() (*Dir, *File)

+ func (f *File) Stat() Result[fs.FileInfo]

+ func (f *File) Std() *os.File

+ func (f *File) Write(content String, mode ...os.FileMode) Result[*File]

+ func (f *File) WriteFromReader(scr io.Reader, mode ...os.FileMode) Result[*File]

+ type Float float64

+ func NewFloat[T float64 | float32 | ~int](float T) Float

+ func (f Float) Abs() Float

+ func (f Float) Add(b Float) Float

+ func (f Float) AsFloat32() float32

+ func (f Float) Bytes() Bytes

+ func (f Float) Compare(b Float) Int

+ func (f Float) Div(b Float) Float

+ func (f Float) Eq(b Float) bool

+ func (f Float) Gt(b Float) bool

+ func (f Float) Hash() fhash

+ func (f Float) IsZero() bool

+ func (f Float) Lt(b Float) bool

+ func (f Float) Max(b ...Float) Float

+ func (f Float) Min(b ...Float) Float

+ func (f Float) Mul(b Float) Float

+ func (f Float) Ne(b Float) bool

+ func (f Float) Print() Float

+ func (f Float) Round() Int

+ func (f Float) RoundDecimal(precision int) Float

+ func (f Float) Std() float64

+ func (f Float) Sub(b Float) Float

+ func (f Float) ToBigFloat() *big.Float

+ func (f Float) ToInt() Int

+ func (f Float) ToString() String

+ func (f Float) ToUInt64() uint64

+ type Int int

+ func NewInt[T ~int | rune | byte](i T) Int

+ func (i Int) Abs() Int

+ func (i Int) Add(b Int) Int

+ func (i Int) AsInt16() int16

+ func (i Int) AsInt32() int32

+ func (i Int) AsInt64() int64

+ func (i Int) AsInt8() int8

+ func (i Int) AsUInt() uint

+ func (i Int) AsUInt16() uint16

+ func (i Int) AsUInt32() uint32

+ func (i Int) AsUInt64() uint64

+ func (i Int) AsUInt8() uint8

+ func (i Int) Bytes() Bytes

+ func (i Int) Div(b Int) Int

+ func (i Int) Eq(b Int) bool

+ func (i Int) Gt(b Int) bool

+ func (i Int) Gte(b Int) bool

+ func (i Int) Hash() ihash

+ func (i Int) IsNegative() bool

+ func (i Int) IsPositive() bool

+ func (i Int) IsZero() bool

+ func (i Int) Lt(b Int) bool

+ func (i Int) Lte(b Int) bool

+ func (i Int) Max(b ...Int) Int

+ func (i Int) Min(b ...Int) Int

+ func (i Int) Mul(b Int) Int

+ func (i Int) Ne(b Int) bool

+ func (i Int) Print() Int

+ func (i Int) Random() Int

+ func (i Int) RandomRange(to Int) Int

+ func (i Int) Rem(b Int) Int

+ func (i Int) Std() int

+ func (i Int) Sub(b Int) Int

+ func (i Int) ToBigInt() *big.Int

+ func (i Int) ToBinary() String

+ func (i Int) ToFloat() Float

+ func (i Int) ToHex() String

+ func (i Int) ToOctal() String

+ func (i Int) ToString() String

+ type Map map[K]V

+ func MapFromStd[K comparable, V any](stdmap map[K]V) Map[K, V]

+ func NewMap[K comparable, V any](size ...int) Map[K, V]

+ func (m Map[K, V]) Clear() Map[K, V]

+ func (m Map[K, V]) Clone() Map[K, V]

+ func (m Map[K, V]) Contains(key K) bool

+ func (m Map[K, V]) Copy(src Map[K, V]) Map[K, V]

+ func (m Map[K, V]) Delete(keys ...K) Map[K, V]

+ func (m Map[K, V]) Empty() bool

+ func (m Map[K, V]) Eq(other Map[K, V]) bool

+ func (m Map[K, V]) Get(k K) Option[V]

+ func (m Map[K, V]) GetOrSet(key K, defaultValue V) V

+ func (m Map[K, V]) Invert() Map[any, K]

+ func (m Map[K, V]) Iter() seqMap[K, V]

+ func (m Map[K, V]) Keys() Slice[K]

+ func (m Map[K, V]) Len() int

+ func (m Map[K, V]) Ne(other Map[K, V]) bool

+ func (m Map[K, V]) NotEmpty() bool

+ func (m Map[K, V]) Print() Map[K, V]

+ func (m Map[K, V]) Set(k K, v V) Map[K, V]

+ func (m Map[K, V]) Std() map[K]V

+ func (m Map[K, V]) String() string

+ func (m Map[K, V]) Values() Slice[V]

+ type MapOrd []Pair[K, V]

+ func MapOrdFromMap[K comparable, V any](m Map[K, V]) MapOrd[K, V]

+ func MapOrdFromStd[K comparable, V any](m map[K]V) MapOrd[K, V]

+ func NewMapOrd[K, V any](size ...int) MapOrd[K, V]

+ func (mo *MapOrd[K, V]) Clear() MapOrd[K, V]

+ func (mo *MapOrd[K, V]) Copy(src MapOrd[K, V]) MapOrd[K, V]

+ func (mo *MapOrd[K, V]) Delete(keys ...K) MapOrd[K, V]

+ func (mo *MapOrd[K, V]) GetOrSet(key K, defaultValue V) V

+ func (mo *MapOrd[K, V]) Set(key K, value V) *MapOrd[K, V]

+ func (mo MapOrd[K, V]) Clone() MapOrd[K, V]

+ func (mo MapOrd[K, V]) Contains(key K) bool

+ func (mo MapOrd[K, V]) Empty() bool

+ func (mo MapOrd[K, V]) Eq(other MapOrd[K, V]) bool

+ func (mo MapOrd[K, V]) Get(key K) Option[V]

+ func (mo MapOrd[K, V]) Invert() MapOrd[V, K]

+ func (mo MapOrd[K, V]) Iter() seqMapOrd[K, V]

+ func (mo MapOrd[K, V]) Keys() Slice[K]

+ func (mo MapOrd[K, V]) Len() int

+ func (mo MapOrd[K, V]) Ne(other MapOrd[K, V]) bool

+ func (mo MapOrd[K, V]) NotEmpty() bool

+ func (mo MapOrd[K, V]) Print() MapOrd[K, V]

+ func (mo MapOrd[K, V]) SortBy(fn func(a, b Pair[K, V]) bool) MapOrd[K, V]

+ func (mo MapOrd[K, V]) String() string

+ func (mo MapOrd[K, V]) Values() Slice[V]

+ type Option struct

+ func None[T any]() Option[T]

+ func Some[T any](value T) Option[T]

+ func (o Option[T]) Expect(msg string) T

+ func (o Option[T]) IsNone() bool

+ func (o Option[T]) IsSome() bool

+ func (o Option[T]) Some() T

+ func (o Option[T]) Then(fn func(T) Option[T]) Option[T]

+ func (o Option[T]) Unwrap() T

+ func (o Option[T]) UnwrapOr(value T) T

+ func (o Option[T]) UnwrapOrDefault() T

+ type Pair struct

+ Key K

+ Value V

+ type Result struct

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

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

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

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

+ func (r Result[T]) Expect(msg string) T

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

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

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

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

+ func (r Result[T]) Then(fn func(T) Result[T]) Result[T]

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

+ func (r Result[T]) UnwrapOr(value T) T

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

+ type Set map[T]struct

+ func MapSet[T, U comparable](s Set[T], fn func(T) U) Set[U]

+ func NewSet[T comparable](size ...int) Set[T]

+ func SetOf[T comparable](values ...T) Set[T]

+ func (s Set[T]) Add(values ...T) Set[T]

+ func (s Set[T]) Clear() Set[T]

+ func (s Set[T]) Clone() Set[T]

+ func (s Set[T]) Contains(v T) bool

+ func (s Set[T]) ContainsAll(other Set[T]) bool

+ func (s Set[T]) ContainsAny(other Set[T]) bool

+ func (s Set[T]) Difference(other Set[T]) seqSet[T]

+ func (s Set[T]) Empty() bool

+ func (s Set[T]) Eq(other Set[T]) bool

+ func (s Set[T]) Intersection(other Set[T]) seqSet[T]

+ func (s Set[T]) Iter() seqSet[T]

+ func (s Set[T]) Len() int

+ func (s Set[T]) Ne(other Set[T]) bool

+ func (s Set[T]) Print() Set[T]

+ func (s Set[T]) Remove(values ...T) Set[T]

+ func (s Set[T]) String() string

+ func (s Set[T]) Subset(other Set[T]) bool

+ func (s Set[T]) Superset(other Set[T]) bool

+ func (s Set[T]) SymmetricDifference(other Set[T]) seqSet[T]

+ func (s Set[T]) ToSlice() Slice[T]

+ func (s Set[T]) Union(other Set[T]) seqSet[T]

+ type Slice []T

+ func MapSlice[T, U any](sl Slice[T], fn func(T) U) Slice[U]

+ func NewSlice[T any](size ...int) Slice[T]

+ func SliceOf[T any](slice ...T) Slice[T]

+ func (sl *Slice[T]) AddUniqueInPlace(elems ...T)

+ func (sl *Slice[T]) AppendInPlace(elems ...T)

+ func (sl *Slice[T]) CutInPlace(start, end int)

+ func (sl *Slice[T]) DeleteInPlace(i int)

+ func (sl *Slice[T]) InsertInPlace(i int, values ...T)

+ func (sl *Slice[T]) ReplaceInPlace(i, j int, values ...T)

+ func (sl Slice[T]) AddUnique(elems ...T) Slice[T]

+ func (sl Slice[T]) Append(elems ...T) Slice[T]

+ func (sl Slice[T]) AsAny() Slice[any]

+ func (sl Slice[T]) Cap() int

+ func (sl Slice[T]) Clear() Slice[T]

+ func (sl Slice[T]) Clip() Slice[T]

+ func (sl Slice[T]) Clone() Slice[T]

+ func (sl Slice[T]) Contains(val T) bool

+ func (sl Slice[T]) ContainsAll(values ...T) bool

+ func (sl Slice[T]) ContainsAny(values ...T) bool

+ func (sl Slice[T]) Count(elem T) int

+ func (sl Slice[T]) Counter() MapOrd[T, uint]

+ func (sl Slice[T]) Cut(start, end int) Slice[T]

+ func (sl Slice[T]) Delete(i int) Slice[T]

+ func (sl Slice[T]) Empty() bool

+ func (sl Slice[T]) Eq(other Slice[T]) bool

+ func (sl Slice[T]) Fill(val T)

+ func (sl Slice[T]) Get(index int) T

+ func (sl Slice[T]) Grow(n int) Slice[T]

+ func (sl Slice[T]) Index(val T) int

+ func (sl Slice[T]) Insert(i int, values ...T) Slice[T]

+ func (sl Slice[T]) Iter() seqSlice[T]

+ func (sl Slice[T]) Join(sep ...T) String

+ func (sl Slice[T]) Last() T

+ func (sl Slice[T]) LastIndex() int

+ func (sl Slice[T]) Len() int

+ func (sl Slice[T]) Less(i, j int) bool

+ func (sl Slice[T]) Max() T

+ func (sl Slice[T]) Min() T

+ func (sl Slice[T]) Ne(other Slice[T]) bool

+ func (sl Slice[T]) NotEmpty() bool

+ func (sl Slice[T]) Pop() (T, Slice[T])

+ func (sl Slice[T]) Print() Slice[T]

+ func (sl Slice[T]) Random() T

+ func (sl Slice[T]) RandomRange(from, to int) Slice[T]

+ func (sl Slice[T]) RandomSample(sequence int) Slice[T]

+ func (sl Slice[T]) Replace(i, j int, values ...T) Slice[T]

+ func (sl Slice[T]) Reverse()

+ func (sl Slice[T]) Set(index int, val T)

+ func (sl Slice[T]) Shuffle()

+ func (sl Slice[T]) Sort()

+ func (sl Slice[T]) SortBy(fn func(a, b T) bool)

+ func (sl Slice[T]) Std() []T

+ func (sl Slice[T]) String() string

+ func (sl Slice[T]) SubSlice(start, end int, step ...int) Slice[T]

+ func (sl Slice[T]) Swap(i, j int)

+ func (sl Slice[T]) ToMapHashed() Map[String, T]

+ func (sl Slice[T]) ToStringSlice() []string

+ func (sl Slice[T]) Unpack(vars ...*T)

+ type String string

+ func Format[T, U ~string](str T, args Map[U, any]) String

+ func NewString[T ~string | rune | byte | ~[]rune | ~[]byte](str T) String

+ func Sprint(a ...any) String

+ func Sprintf[T ~string](str T, a ...any) String

+ func (String) Random(count int, letters ...String) String

+ func (s String) Add(str String) String

+ func (s String) AddPrefix(str String) String

+ func (s String) Center(length int, pad String) String

+ func (s String) Chars() Slice[String]

+ func (s String) Chunks(size int) Slice[String]

+ func (s String) Comp() comp

+ func (s String) Compare(str String) Int

+ func (s String) Contains(substr String) bool

+ func (s String) ContainsAll(substrs ...String) bool

+ func (s String) ContainsAny(substrs ...String) bool

+ func (s String) ContainsAnyChars(chars String) bool

+ func (s String) ContainsRegexp(pattern String) Result[bool]

+ func (s String) ContainsRegexpAll(patterns ...String) Result[bool]

+ func (s String) ContainsRegexpAny(patterns ...String) Result[bool]

+ func (s String) ContainsRune(r rune) bool

+ func (s String) Count(substr String) int

+ func (s String) Cut(start, end String, rmtags ...bool) (String, String)

+ func (s String) Dec() dec

+ func (s String) Decomp() decomp

+ func (s String) Empty() bool

+ func (s String) Enc() enc

+ func (s String) EndsWith(suffixes ...String) bool

+ func (s String) Eq(str String) bool

+ func (s String) EqFold(str String) bool

+ func (s String) Fields() Slice[String]

+ func (s String) FindAllRegexp(pattern *regexp.Regexp) Option[Slice[String]]

+ func (s String) FindAllRegexpN(pattern *regexp.Regexp, n Int) Option[Slice[String]]

+ func (s String) FindAllSubmatchRegexp(pattern *regexp.Regexp) Option[Slice[Slice[String]]]

+ func (s String) FindAllSubmatchRegexpN(pattern *regexp.Regexp, n Int) Option[Slice[Slice[String]]]

+ func (s String) FindRegexp(pattern *regexp.Regexp) Option[String]

+ func (s String) FindSubmatchRegexp(pattern *regexp.Regexp) Option[Slice[String]]

+ func (s String) Format(format String) String

+ func (s String) Gt(str String) bool

+ func (s String) Hash() shash

+ func (s String) Index(substr String) int

+ func (s String) IndexRegexp(pattern *regexp.Regexp) Option[Slice[Int]]

+ func (s String) IndexRune(r rune) int

+ func (s String) IsASCII() bool

+ func (s String) IsDigit() bool

+ func (s String) LastIndex(substr String) int

+ func (s String) LeftJustify(length int, pad String) String

+ func (s String) Len() int

+ func (s String) LenRunes() int

+ func (s String) Lower() String

+ func (s String) Lt(str String) bool

+ func (s String) Map(fn func(rune) rune) String

+ func (s String) Max(b ...String) String

+ func (s String) Min(b ...String) String

+ func (s String) Ne(str String) bool

+ func (s String) NormalizeNFC() String

+ func (s String) NotEmpty() bool

+ func (s String) Print() String

+ func (s String) Reader() *strings.Reader

+ func (s String) Repeat(count int) String

+ func (s String) Replace(oldS, newS String, n int) String

+ func (s String) ReplaceAll(oldS, newS String) String

+ func (s String) ReplaceMulti(oldnew ...String) String

+ func (s String) ReplaceNth(oldS, newS String, n int) String

+ func (s String) ReplaceRegexp(pattern *regexp.Regexp, newS String) String

+ func (s String) Reverse() String

+ func (s String) RightJustify(length int, pad String) String

+ func (s String) Similarity(str String) Float

+ func (s String) Split(sep ...String) Slice[String]

+ func (s String) SplitLines() Slice[String]

+ func (s String) SplitN(sep String, n Int) Slice[String]

+ func (s String) SplitRegexp(pattern regexp.Regexp) Slice[String]

+ func (s String) SplitRegexpN(pattern regexp.Regexp, n Int) Option[Slice[String]]

+ func (s String) StartsWith(prefixes ...String) bool

+ func (s String) Std() string

+ func (s String) Title() String

+ func (s String) ToBytes() Bytes

+ func (s String) ToFloat() Result[Float]

+ func (s String) ToInt() Result[Int]

+ func (s String) ToRunes() Slice[rune]

+ func (s String) Trim(cutset String) String

+ func (s String) TrimLeft(cutset String) String

+ func (s String) TrimPrefix(prefix String) String

+ func (s String) TrimRight(cutset String) String

+ func (s String) TrimSpace() String

+ func (s String) TrimSuffix(suffix String) String

+ func (s String) Upper() String