seq

package

Go to main page

Versions in this module

v1

v1.0.0

Jun 2, 2023

v0

v0.9.9

Jun 2, 2023

Changes in this version

type Map

+ func (a Map[K, V]) Copy() Map[K, V]

type Set

+ func (s Set[K]) Copy() Set[K]

type String

+ func (s String) Contains(sub string) bool

+ func (s String) HasPrefix(pfx string) bool

+ func (s String) HasSuffix(sfx string) bool

type Tuple

+ func (t Tuple[X, Y]) Equals(o Tuple[X, Y]) bool

v0.9.2

Apr 17, 2023

Changes in this version

type Map

+ func (a Map[K, V]) Contains(k K) bool

+ func (a Map[K, V]) Get(k K) opt.Opt[V]

type Seq

+ func SetOfArgs(ks ...K) Seq[K]

type Set

+ func SetAsArgs(ks ...K) Set[K]

+ func (s Set[K]) Contains(k K) bool

+ func (s Set[K]) Intersect(other Set[K]) Seq[K]

+ func (s Set[K]) Union(other Set[K]) Seq[K]

type Slice

+ func MakeSlice(into Slice[T], t T) Slice[T]

v0.9.1

Mar 21, 2023

Changes in this version

type Map

+ func (a Map[K, V]) Keys() Seq[K]

+ func (a Map[K, V]) Values() Seq[V]

type Slice

+ func (a Slice[T]) Copy() Slice[T]

v0.9.0

Mar 17, 2023

Changes in this version

+ func MakeChan(into chan T, t T) chan T

type Seq

+ func ValuesOf(opts Seq[opt.Opt[T]]) Seq[T]

v0.4.0

Feb 17, 2023

Changes in this version

type Chan

+ func (c Chan[T]) Limit(n int) Seq[T]

type Map

+ func (a Map[K, V]) Limit(n int) Seq[Tuple[K, V]]

type Seq

+ func LimitOf(seq Seq[T], limit int) Seq[T]

+ Limit func(n int) Seq[T]

type Set

+ func (s Set[T]) Limit(n int) Seq[T]

type Slice

+ func (a Slice[T]) Limit(n int) Seq[T]

type String

+ func (s String) Limit(n int) Seq[byte]

v0.3.1

Feb 1, 2023

v0.3.0

Feb 1, 2023

Changes in this version

+ const LenInfinite

+ const LenUnknown

+ var ErrNotOne = errors.New("sequence contains more than 1 element")

+ func All(seq Seq[T], pred Predicate[T]) bool

+ func Any(seq Seq[T], pred Predicate[T]) bool

+ func Append(into []T, t T) []T

+ func Count(into int, _ T) int

+ func Error(x any) error

+ func GreaterThanZero(t T) bool

+ func GroupBy(into map[K][]V, tup Tuple[K, V]) map[K][]V

+ func IsEmpty(seq Seq[T]) bool

+ func IsNonZero(t T) bool

+ func IsZero(t T) bool

+ func Last(seq Seq[T]) opt.Opt[T]

+ func LessThanZero(t T) bool

+ func MakeBytes(into *bytes.Buffer, b []byte) *bytes.Buffer

+ func MakeMap(into map[K]V, t Tuple[K, V]) map[K]V

+ func MakeSet(into map[K]struct{}, k K) map[K]struct

+ func MakeString(into *strings.Builder, s string) *strings.Builder

+ func One(seq Seq[T]) opt.Opt[T]

+ func OrderAsc(t1, t2 T) bool

+ func OrderDesc(t1, t2 T) bool

+ func OrderTupleAsc(t1, t2 Tuple[K, V]) bool

+ func OrderTupleDesc(t1, t2 Tuple[K, V]) bool

+ func Reduce(collector FuncCollect[T, E], into T, seq Seq[E]) opt.Opt[T]

+ func TupleKey(t Tuple[X, Y]) X

+ func TupleValue(t Tuple[X, Y]) Y

+ func TupleWithKey(keySelector FuncMap[V, K]) func(V) Tuple[K, V]

+ type Chan <-chan T

+ func (c Chan[T]) First() (opt.Opt[T], Seq[T])

+ func (c Chan[T]) ForEach(f Func1[T]) Seq[T]

+ func (c Chan[T]) ForEachIndex(f Func2[int, T]) Seq[T]

+ func (c Chan[T]) Len() (int, bool)

+ func (c Chan[T]) Map(shaper FuncMap[T, T]) Seq[T]

+ func (c Chan[T]) Seq() Seq[T]

+ func (c Chan[T]) Skip(n int) Seq[T]

+ func (c Chan[T]) Take(n int) (Slice[T], Seq[T])

+ func (c Chan[T]) TakeWhile(pred Predicate[T]) (Slice[T], Seq[T])

+ func (c Chan[T]) ToSlice() Slice[T]

+ func (c Chan[T]) Where(pred Predicate[T]) Seq[T]

+ func (c Chan[T]) While(pred Predicate[T]) Seq[T]

+ type Fallible interface

+ Error func() error

+ type Func0 func()

+ type Func0Err func() error

+ type Func1 func(T)

+ type Func1Err func(T) error

+ type Func2 func(S, T)

+ type Func2Err func(S, T) error

+ type FuncCollect func(T, E) T

+ func UpdateMap(updater FuncUpdate[V]) FuncCollect[map[K]V, Tuple[K, V]]

+ func UpdateSlice(updater FuncUpdate[V]) FuncCollect[[]V, Tuple[I, V]]

+ type FuncLess func(T, T) bool

+ type FuncMap func(S) T

+ type FuncMapErr func(S) (T, error)

+ type FuncSource func() T

+ type FuncSplit func(val T) SplitChoice

+ type FuncUpdate func(old, new_ T) T

+ type Map map[K]V

+ func MapAs(m map[K]V) Map[K, V]

+ func (a Map[K, V]) First() (opt.Opt[Tuple[K, V]], Seq[Tuple[K, V]])

+ func (a Map[K, V]) ForEach(f Func1[Tuple[K, V]]) Seq[Tuple[K, V]]

+ func (a Map[K, V]) ForEachIndex(f Func2[int, Tuple[K, V]]) Seq[Tuple[K, V]]

+ func (a Map[K, V]) Len() (int, bool)

+ func (a Map[K, V]) Map(shaper FuncMap[Tuple[K, V], Tuple[K, V]]) Seq[Tuple[K, V]]

+ func (a Map[K, V]) Seq() Seq[Tuple[K, V]]

+ func (a Map[K, V]) Skip(n int) Seq[Tuple[K, V]]

+ func (a Map[K, V]) Take(n int) (Slice[Tuple[K, V]], Seq[Tuple[K, V]])

+ func (a Map[K, V]) TakeWhile(predicate Predicate[Tuple[K, V]]) (Slice[Tuple[K, V]], Seq[Tuple[K, V]])

+ func (a Map[K, V]) ToSlice() Slice[Tuple[K, V]]

+ func (a Map[K, V]) Where(p Predicate[Tuple[K, V]]) Seq[Tuple[K, V]]

+ func (a Map[K, V]) While(pred Predicate[Tuple[K, V]]) Seq[Tuple[K, V]]

+ type Predicate func(T) bool

+ func GreaterThan(val T) Predicate[T]

+ func Is(val T) Predicate[T]

+ func IsNot(val T) Predicate[T]

+ func LessThan(val T) Predicate[T]

+ func Not(pred Predicate[T]) Predicate[T]

+ type PredicateErr func(T) (bool, error)

+ type Seq interface

+ First func() (opt.Opt[T], Seq[T])

+ ForEach func(f Func1[T]) Seq[T]

+ ForEachIndex func(f Func2[int, T]) Seq[T]

+ Len func() (int, bool)

+ Map func(funcMap FuncMap[T, T]) Seq[T]

+ Skip func(int) Seq[T]

+ Take func(int) (Slice[T], Seq[T])

+ TakeWhile func(predicate Predicate[T]) (Slice[T], Seq[T])

+ ToSlice func() Slice[T]

+ Where func(Predicate[T]) Seq[T]

+ While func(predicate Predicate[T]) Seq[T]

+ func ChanOf(ch <-chan T) Seq[T]

+ func ConcatOf(seqs ...Seq[T]) Seq[T]

+ func Constant(t T) Seq[T]

+ func Do(seq Seq[T]) Seq[T]

+ func Empty() Seq[T]

+ func ErrorOf(err error) Seq[T]

+ func FlattenOf(seqs Seq[Seq[T]]) Seq[T]

+ func Go(seq Seq[S], numJobs int, task FuncMap[S, T]) Seq[T]

+ func MapOf(m map[K]V) Seq[Tuple[K, V]]

+ func MappingOf(seq Seq[S], fm FuncMap[S, T]) Seq[T]

+ func OptOf(op opt.Opt[T]) Seq[T]

+ func PrependOf(t T, tail Seq[T]) Seq[T]

+ func RangeFrom(n N) Seq[N]

+ func RangeOf(from, to N) Seq[N]

+ func RangeStepOf(from, to, step N) Seq[N]

+ func SetOf(s map[K]struct{}) Seq[K]

+ func SingletOf(t T) Seq[T]

+ func SliceOf(tt []T) Seq[T]

+ func SliceOfArgs(tt ...T) Seq[T]

+ func SourceOf(f FuncSource[T]) Seq[T]

+ func SplitOf(seq Seq[T], splitter FuncSplit[T]) Seq[Seq[T]]

+ func StringOf(s string) Seq[byte]

+ func WhereOf(seq Seq[T], pred Predicate[T]) Seq[T]

+ func WhileOf(seq Seq[T], pred Predicate[T]) Seq[T]

+ func ZipOf(sx Seq[X], sy Seq[Y]) Seq[Tuple[X, Y]]

+ type Set map[K]struct

+ func SetAs(s map[K]struct{}) Set[K]

+ func (s Set[K]) First() (opt.Opt[K], Seq[K])

+ func (s Set[K]) ForEach(f Func1[K]) Seq[K]

+ func (s Set[K]) ForEachIndex(f Func2[int, K]) Seq[K]

+ func (s Set[K]) Len() (int, bool)

+ func (s Set[K]) Map(shaper FuncMap[K, K]) Seq[K]

+ func (s Set[K]) Seq() Seq[K]

+ func (s Set[K]) Skip(n int) Seq[K]

+ func (s Set[K]) Take(n int) (Slice[K], Seq[K])

+ func (s Set[K]) TakeWhile(predicate Predicate[K]) (Slice[K], Seq[K])

+ func (s Set[K]) ToSlice() Slice[K]

+ func (s Set[K]) Where(p Predicate[K]) Seq[K]

+ func (s Set[T]) While(pred Predicate[T]) Seq[T]

+ type Slice []T

+ func SliceAs(tt []T) Slice[T]

+ func SliceAsArgs(tt ...T) Slice[T]

+ func (a Slice[T]) AsSlice() []T

+ func (a Slice[T]) Error() error

+ func (a Slice[T]) First() (opt.Opt[T], Seq[T])

+ func (a Slice[T]) ForEach(f Func1[T]) Seq[T]

+ func (a Slice[T]) ForEachIndex(f Func2[int, T]) Seq[T]

+ func (a Slice[T]) Last() opt.Opt[T]

+ func (a Slice[T]) Len() (int, bool)

+ func (a Slice[T]) Map(shaper FuncMap[T, T]) Seq[T]

+ func (a Slice[T]) One() opt.Opt[T]

+ func (a Slice[T]) Reverse() Seq[T]

+ func (a Slice[T]) Seq() Seq[T]

+ func (a Slice[T]) Shuffle() Seq[T]

+ func (a Slice[T]) Skip(n int) Seq[T]

+ func (a Slice[T]) Sort(less FuncLess[T]) Slice[T]

+ func (a Slice[T]) Take(n int) (Slice[T], Seq[T])

+ func (a Slice[T]) TakeWhile(pred Predicate[T]) (Slice[T], Seq[T])

+ func (a Slice[T]) ToSlice() Slice[T]

+ func (a Slice[T]) Where(pred Predicate[T]) Seq[T]

+ func (a Slice[T]) While(pred Predicate[T]) Seq[T]

+ type SplitChoice uint8

+ const SplitKeep

+ const SplitSeparate

+ const SplitSeparateKeep

+ type String string

+ func StringAs(s string) String

+ func (s String) First() (opt.Opt[byte], Seq[byte])

+ func (s String) ForEach(f Func1[byte]) Seq[byte]

+ func (s String) ForEachIndex(f Func2[int, byte]) Seq[byte]

+ func (s String) Len() (int, bool)

+ func (s String) Map(shaper FuncMap[byte, byte]) Seq[byte]

+ func (s String) Skip(n int) Seq[byte]

+ func (s String) Take(n int) (Slice[byte], Seq[byte])

+ func (s String) TakeWhile(pred Predicate[byte]) (Slice[byte], Seq[byte])

+ func (s String) ToSlice() Slice[byte]

+ func (s String) Where(pred Predicate[byte]) Seq[byte]

+ func (s String) While(pred Predicate[byte]) Seq[byte]

+ type Tuple struct

+ func TupleOf(x X, y Y) Tuple[X, Y]

+ func (t Tuple[X, Y]) Key() X

+ func (t Tuple[X, Y]) Value() Y

+ func (t Tuple[X, Y]) X() X

+ func (t Tuple[X, Y]) Y() Y

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL