g

package module

Go to main page

Versions in this module

v1

v1.0.80

May 18, 2024

Changes in this version

type SeqSlice

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

v1.0.79

May 15, 2024

v1.0.78

May 15, 2024

Changes in this version

type String

+ func (s String) Remove(matches ...String) String

v1.0.77

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]

v1.0.76

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]

v1.0.75

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

v1.0.74

Apr 20, 2024

v1.0.73

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]

v1.0.72

Apr 15, 2024

v1.0.71

Apr 15, 2024

v1.0.70

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

v1.0.69

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

v1.0.68

Apr 12, 2024

Changes in this version

type Slice

+ func (sl Slice[T]) NeBy(other Slice[T], fn func(x, y T) bool) bool

v1.0.67

Apr 12, 2024

Changes in this version

type SeqSlice

+ func (seq SeqSlice[V]) Counter() SeqMapOrd[V, uint]

v1.0.66

Apr 11, 2024

v1.0.65

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

v1.0.64

Apr 11, 2024

v1.0.63

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]

v1.0.62

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

v1.0.61

Apr 7, 2024

v1.0.60

Apr 3, 2024

Changes in this version

type Option

+ func (o Option[T]) String() string

type Result

+ func (r Result[T]) String() string

v1.0.59

Mar 29, 2024

v1.0.58

Mar 28, 2024

Changes in this version

+ func FromChannel[V any](ch <-chan V) seqSlice[V]

v1.0.57

Mar 24, 2024

Changes in this version

type File

+ func (f *File) Chunks(size int) Result[seqSlice[String]]

v1.0.56

Mar 20, 2024

Changes in this version

type Option

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

v1.0.55

Mar 19, 2024

v1.0.54

Mar 18, 2024

v1.0.53

Mar 18, 2024

v1.0.52

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]

v1.0.51

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]

v1.0.50

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

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