hg

Oct 6, 2023

Changes in this version

type HDir

+ func (hd *HDir) Move(newpath HString) HResult[*HDir]

type HFile

+ func (hf *HFile) Move(newpath HString) HResult[*HFile]

type HMap

+ func (hmap HMap[K, V]) GetOrSet(key K, defaultValue V) V

type HMapOrd

+ func (hmapo *HMapOrd[K, V]) GetOrSet(key K, defaultValue V) V

Sep 19, 2023

Changes in this version

type HMap

+ func (hmap HMap[K, V]) MapAny(fn func(K, V) (K, any)) HMap[K, any]

type HMapOrd

+ func (hmapo *HMapOrd[K, V]) MapAny(fn func(K, V) (K, any)) *HMapOrd[K, any]

Aug 15, 2023

Changes in this version

type HOption

+ func (o HOption[T]) Must() T

+ func (o HOption[T]) MustOr(value T) T

+ func (o HOption[T]) MustOrDefault() T

type HResult

+ func (r HResult[T]) Must() T

+ func (r HResult[T]) MustOr(value T) T

+ func (r HResult[T]) MustOrDefault() T

Aug 13, 2023

Changes in this version

type HString

+ func (hs HString) Max(b ...HString) HString

+ func (hs HString) Min(b ...HString) HString

Aug 8, 2023

Changes in this version

type HFloat

+ func (hf HFloat) Max(b HFloat) HFloat

+ func (hf HFloat) Min(b HFloat) HFloat

type HInt

+ func (hi HInt) BigInt() *big.Int

Aug 8, 2023

Changes in this version

type HSet

+ func (s HSet[T]) MapAny(fn func(T) any) HSet[any]

type HSlice

+ func (hsl HSlice[T]) MapAny(fn func(T) any) HSlice[any]

+ func (hsl HSlice[T]) MapAnyParallel(fn func(T) any) HSlice[any]

Aug 3, 2023

Changes in this version

type HInt

+ func (hi HInt) Abs() HInt

Jul 31, 2023

Changes in this version

type HOption

+ func (o HOption[T]) UnwrapOrDefault() T

type HResult

+ func (r HResult[T]) UnwrapOrDefault() T

Jul 31, 2023

Changes in this version

type HBytes

+ func (hbs HBytes) FindAllRegexp(pattern *regexp.Regexp) HOption[HSlice[HBytes]]

+ func (hbs HBytes) FindAllRegexpN(pattern *regexp.Regexp, n HInt) HOption[HSlice[HBytes]]

+ func (hbs HBytes) FindAllSubmatchRegexp(pattern *regexp.Regexp) HOption[HSlice[HSlice[HBytes]]]

+ func (hbs HBytes) FindAllSubmatchRegexpN(pattern *regexp.Regexp, n HInt) HOption[HSlice[HSlice[HBytes]]]

+ func (hbs HBytes) FindRegexp(pattern *regexp.Regexp) HOption[HBytes]

+ func (hbs HBytes) FindSubmatchRegexp(pattern *regexp.Regexp) HOption[HSlice[HBytes]]

+ func (hbs HBytes) IndexRegexp(pattern *regexp.Regexp) HOption[HSlice[HInt]]

type HString

+ func (hs HString) FindAllRegexp(pattern *regexp.Regexp) HOption[HSlice[HString]]

+ func (hs HString) FindAllRegexpN(pattern *regexp.Regexp, n HInt) HOption[HSlice[HString]]

+ func (hs HString) FindAllSubmatchRegexp(pattern *regexp.Regexp) HOption[HSlice[HSlice[HString]]]

+ func (hs HString) FindAllSubmatchRegexpN(pattern *regexp.Regexp, n HInt) HOption[HSlice[HSlice[HString]]]

+ func (hs HString) FindRegexp(pattern *regexp.Regexp) HOption[HString]

+ func (hs HString) FindSubmatchRegexp(pattern *regexp.Regexp) HOption[HSlice[HString]]

+ func (hs HString) IndexRegexp(pattern *regexp.Regexp) HOption[HSlice[HInt]]

+ func (hs HString) SplitN(sep HString, n HInt) HSlice[HString]

+ func (hs HString) SplitRegexp(pattern regexp.Regexp) HSlice[HString]

+ func (hs HString) SplitRegexpN(pattern regexp.Regexp, n HInt) HOption[HSlice[HString]]

Jul 30, 2023

Changes in this version

type HBytes

+ func (hbs HBytes) FingRegexp(pattern *regexp.Regexp) HOption[HBytes]

+ func (hbs HBytes) LastIndex(bs HBytes) int

+ func (hbs HBytes) LastIndexByte(b byte) int

+ func (hbs HBytes) ReplaceRegexp(pattern *regexp.Regexp, newB HBytes) HBytes

+ type HOption struct

+ func None() HOption[T]

+ func Some(value T) HOption[T]

+ func (o HOption[T]) Expect(msg HString) T

+ func (o HOption[T]) IsNone() bool

+ func (o HOption[T]) IsSome() bool

+ func (o HOption[T]) Some() T

+ func (o HOption[T]) Unwrap() T

+ func (o HOption[T]) UnwrapOr(value T) T

type HString

+ func (hs HString) FingRegexp(pattern *regexp.Regexp) HOption[HString]

+ func (hs HString) LastIndex(substr HString) int

+ func (hs HString) ReplaceRegexp(pattern *regexp.Regexp, newS HString) HString

Jul 27, 2023

Changes in this version

type HBytes

+ func (hbs HBytes) Print() HBytes

type HDir

+ func (hd *HDir) Print() *HDir

type HFile

+ func (hf *HFile) Print() *HFile

type HFloat

+ func (hf HFloat) Print() HFloat

type HInt

+ func (hi HInt) Print() HInt

type HMap

+ func (hmap HMap[K, V]) Print() HMap[K, V]

type HMapOrd

+ func (hmapo *HMapOrd[K, V]) Print() *HMapOrd[K, V]

type HSet

+ func (s HSet[T]) Print() HSet[T]

type HSlice

+ func (hsl HSlice[T]) Print() HSlice[T]

type HString

+ func (hs HString) Print() HString

Jul 26, 2023

Changes in this version

type HResult

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

Jul 26, 2023

Changes in this version

type HMap

+ func (hmap HMap[K, V]) GetOr(key K, defaultValue V) V

type HMapOrd

+ func (hmapo *HMapOrd[K, V]) GetOr(key K, defaultValue V) V

Jul 25, 2023

Changes in this version

type HFile

+ func (hf *HFile) Stat() *HResult[fs.FileInfo]

Jul 24, 2023

Changes in this version

+ type HResult struct

+ func Err(err error) *HResult[T]

+ func Ok(value T) *HResult[T]

+ func Result(value T, err error) *HResult[T]

+ func (r *HResult[T]) Err() error

+ func (r *HResult[T]) Expect(msg HString) T

+ func (r *HResult[T]) IsErr() bool

+ func (r *HResult[T]) IsOk() bool

+ func (r *HResult[T]) Ok() T

+ func (r *HResult[T]) Unwrap() T

+ func (r *HResult[T]) UnwrapOr(value T) T

Jul 22, 2023

Changes in this version

type HBytes

+ func (hbs HBytes) ContainsRegexpAll(patterns ...*regexp.Regexp) bool

+ func (hbs HBytes) ContainsRegexpAny(patterns ...*regexp.Regexp) bool

type HSlice

+ func HSliceHFloatFromSlice(fs []float64) HSlice[HFloat]

+ func HSliceHIntFromSlice(is []int) HSlice[HInt]

+ func HSliceHStringFromSlice(ss []string) HSlice[HString]

+ func (hsl HSlice[T]) Clear() HSlice[T]

+ func (hsl HSlice[T]) Grow(n int) HSlice[T]

type HString

+ func (hs HString) ContainsRegexpAll(patterns ...*regexp.Regexp) bool

+ func (hs HString) ContainsRegexpAny(patterns ...*regexp.Regexp) bool

Jun 12, 2023

Changes in this version

type HString

+ func (hs HString) Dec() dec

+ func (hs HString) Enc() enc

Jun 11, 2023

Changes in this version

type HString

+ func (hs HString) Center(length int, pad HString) HString

+ func (hs HString) LeftJustify(length int, pad HString) HString

+ func (hs HString) RightJustify(length int, pad HString) HString

Jun 10, 2023

Changes in this version

type HString

+ func (hs HString) Format(format HString) HString

Jun 9, 2023

Changes in this version

type HFile

+ func (hf *HFile) WriteFromReader(scr io.Reader, mode ...os.FileMode) *HFile

type HString

+ func (hs HString) EndsWith(suffixes ...HString) bool

+ func (hs HString) StartsWith(prefixes ...HString) bool

May 23, 2023

Changes in this version

type HSet

+ func (s HSet[T]) Subset(other HSet[T]) bool

+ func (s HSet[T]) Superset(other HSet[T]) bool

+ func (s HSet[T]) ToSlice() []T

May 23, 2023

Changes in this version

+ type HSet map[T]struct

+ func HSetOf(values ...T) HSet[T]

+ func NewHSet(size ...int) HSet[T]

+ func (s HSet[T]) Add(values ...T) HSet[T]

+ func (s HSet[T]) Clear() HSet[T]

+ func (s HSet[T]) Clone() HSet[T]

+ func (s HSet[T]) Contains(v T) bool

+ func (s HSet[T]) ContainsAll(other HSet[T]) bool

+ func (s HSet[T]) ContainsAny(other HSet[T]) bool

+ func (s HSet[T]) Difference(other HSet[T]) HSet[T]

+ func (s HSet[T]) Empty() bool

+ func (s HSet[T]) Eq(other HSet[T]) bool

+ func (s HSet[T]) Filter(fn func(T) bool) HSet[T]

+ func (s HSet[T]) ForEach(fn func(T))

+ func (s HSet[T]) HSlice() HSlice[T]

+ func (s HSet[T]) Intersection(other HSet[T]) HSet[T]

+ func (s HSet[T]) Len() int

+ func (s HSet[T]) Map(fn func(T) T) HSet[T]

+ func (s HSet[T]) Ne(other HSet[T]) bool

+ func (s HSet[T]) Remove(values ...T) HSet[T]

+ func (s HSet[T]) String() string

+ func (s HSet[T]) SymmetricDifference(other HSet[T]) HSet[T]

+ func (s HSet[T]) Union(other HSet[T]) HSet[T]

type HSlice

+ func (hsl HSlice[T]) Clip() HSlice[T]

May 21, 2023

Changes in this version

type HSlice

+ func (hsl HSlice[T]) ContainsAll(other HSlice[T]) bool

+ func (hsl HSlice[T]) ContainsAny(other HSlice[T]) bool

May 20, 2023

Changes in this version

type HSlice

+ func (hsl *HSlice[T]) ReplaceInPlace(i, j int, values ...T)

+ func (hsl HSlice[T]) Replace(i, j int, values ...T) HSlice[T]

May 15, 2023

Changes in this version

type HBytes

+ func (hbs HBytes) ContainsRegexp(pattern *regexp.Regexp) bool

type HString

+ func (hs HString) ContainsRegexp(pattern *regexp.Regexp) bool

May 13, 2023

Changes in this version

type HBytes

+ func (hbs HBytes) EqFold(bs HBytes) bool

+ func (hbs HBytes) Index(bs HBytes) int

+ func (hbs HBytes) IndexByte(b byte) int

+ func (hbs HBytes) IndexRune(r rune) int

type HSlice

+ func (hsl *HSlice[T]) AddUniqueInPlace(elems ...T) HSlice[T]

+ func (hsl *HSlice[T]) AppendInPlace(elems ...T) HSlice[T]

+ func (hsl *HSlice[T]) DeleteInPlace(i int) HSlice[T]

+ func (hsl *HSlice[T]) FilterInPlace(fn func(T) bool) HSlice[T]

+ func (hsl *HSlice[T]) FilterZeroValuesInPlace() HSlice[T]

+ func (hsl *HSlice[T]) InsertInPlace(index int, values ...T) HSlice[T]

+ func (hsl *HSlice[T]) MapInPlace(fn func(T) T) HSlice[T]

type HString

+ func (hs HString) EqFold(hstr HString) bool

May 11, 2023

Changes in this version

+ type HMapOrd HSlice[hMapPair[K, V]]

+ func (hmapo *HMapOrd[K, V]) Clear() *HMapOrd[K, V]

+ func (hmapo *HMapOrd[K, V]) Clone() *HMapOrd[K, V]

+ func (hmapo *HMapOrd[K, V]) Contains(key K) bool

+ func (hmapo *HMapOrd[K, V]) Copy(src *HMapOrd[K, V]) *HMapOrd[K, V]

+ func (hmapo *HMapOrd[K, V]) Delete(keys ...K) *HMapOrd[K, V]

+ func (hmapo *HMapOrd[K, V]) Empty() bool

+ func (hmapo *HMapOrd[K, V]) Eq(other *HMapOrd[K, V]) bool

+ func (hmapo *HMapOrd[K, V]) Filter(fn func(K, V) bool) *HMapOrd[K, V]

+ func (hmapo *HMapOrd[K, V]) ForEach(fn func(K, V))

+ func (hmapo *HMapOrd[K, V]) Get(key K) (V, bool)

+ func (hmapo *HMapOrd[K, V]) GetOrDefault(key K, defaultValue V) V

+ func (hmapo *HMapOrd[K, V]) Invert() *HMapOrd[any, K]

+ func (hmapo *HMapOrd[K, V]) Keys() HSlice[K]

+ func (hmapo *HMapOrd[K, V]) Len() int

+ func (hmapo *HMapOrd[K, V]) Map(fn func(K, V) (K, V)) *HMapOrd[K, V]

+ func (hmapo *HMapOrd[K, V]) Ne(other *HMapOrd[K, V]) bool

+ func (hmapo *HMapOrd[K, V]) NotEmpty() bool

+ func (hmapo *HMapOrd[K, V]) Set(key K, value V) *HMapOrd[K, V]

+ func (hmapo *HMapOrd[K, V]) SortBy(f func(i, j int) bool) *HMapOrd[K, V]

+ func (hmapo *HMapOrd[K, V]) String() string

+ func (hmapo *HMapOrd[K, V]) ToHMap() HMap[K, V]

+ func (hmapo *HMapOrd[K, V]) Values() HSlice[V]

May 10, 2023

Changes in this version

type HString

+ func (hs HString) IsASCII() bool

May 9, 2023

Changes in this version

type HInt

+ func (hi HInt) Rem(b HInt) HInt

May 7, 2023

Changes in this version

type HBytes

+ func (hbs HBytes) ContainsAll(bss ...HBytes) bool

+ func (hbs HBytes) ContainsAnyChars(chars HString) bool

May 4, 2023

Changes in this version

type HString

+ func (hs HString) ReplaceNth(oldS, newS HString, n int) HString

May 3, 2023

Changes in this version

type HString

+ func (hs HString) ContainsAll(substrs ...HString) bool

+ func (hs HString) ContainsAnyChars(chars HString) bool

Apr 21, 2023

Changes in this version

type HSlice

+ func (hsl HSlice[T]) Cap() int

Apr 21, 2023

Changes in this version

+ const ASCII_LETTERS

+ const ASCII_LOWERCASE

+ const ASCII_UPPERCASE

+ const DIGITS

+ const DirDefault

+ const FileDefault

+ const FullAccess

+ const HEXDIGITS

+ const OCTDIGITS

+ const PUNCTUATION

+ func HMapOrdFromHMap(hmap HMap[K, V]) *hMapOrd[K, V]

+ func HMapOrdFromMap(m map[K]V) *hMapOrd[K, V]

+ func NewHMapOrd(size ...int) *hMapOrd[K, V]

+ type HBytes []byte

+ func NewHBytes(bs ...[]byte) HBytes

+ func (hbs HBytes) Add(bs HBytes) HBytes

+ func (hbs HBytes) AddPrefix(bs HBytes) HBytes

+ func (hbs HBytes) Bytes() []byte

+ func (hbs HBytes) Clone() HBytes

+ func (hbs HBytes) Compare(bs HBytes) HInt

+ func (hbs HBytes) Contains(bs HBytes) bool

+ func (hbs HBytes) ContainsAny(chars HString) bool

+ func (hbs HBytes) ContainsRune(r rune) bool

+ func (hbs HBytes) Count(bs HBytes) int

+ func (hbs HBytes) Empty() bool

+ func (hbs HBytes) Eq(bs HBytes) bool

+ func (hbs HBytes) Gt(bs HBytes) bool

+ func (hbs HBytes) HString() HString

+ func (hbs HBytes) Hash() bhash

+ func (hbs HBytes) Len() int

+ func (hbs HBytes) LenRunes() int

+ func (hbs HBytes) Lt(bs HBytes) bool

+ func (hbs HBytes) Map(fn func(rune) rune) HBytes

+ func (hbs HBytes) Ne(bs HBytes) bool

+ func (hbs HBytes) NormalizeNFC() HBytes

+ func (hbs HBytes) NotEmpty() bool

+ func (hbs HBytes) Reader() *bytes.Reader

+ func (hbs HBytes) Repeat(count int) HBytes

+ func (hbs HBytes) Replace(oldB, newB HBytes, n int) HBytes

+ func (hbs HBytes) ReplaceAll(oldB, newB HBytes) HBytes

+ func (hbs HBytes) Reverse() HBytes

+ func (hbs HBytes) Runes() []rune

+ func (hbs HBytes) Split(sep ...HBytes) HSlice[HBytes]

+ func (hbs HBytes) String() string

+ func (hbs HBytes) ToLower() HBytes

+ func (hbs HBytes) ToTitle() HBytes

+ func (hbs HBytes) ToUpper() HBytes

+ func (hbs HBytes) Trim(cutset HString) HBytes

+ func (hbs HBytes) TrimLeft(cutset HString) HBytes

+ func (hbs HBytes) TrimPrefix(cutset HBytes) HBytes

+ func (hbs HBytes) TrimRight(cutset HString) HBytes

+ func (hbs HBytes) TrimSpace() HBytes

+ func (hbs HBytes) TrimSuffix(cutset HBytes) HBytes

+ type HDir struct

+ func NewHDir(path HString) *HDir

+ func (hd *HDir) CopyDir(dest HString) *HDir

+ func (hd *HDir) Glob() []*HFile

+ func (hd *HDir) Join(elem ...HString) HString

+ func (hd *HDir) Mkdir(mode ...os.FileMode) *HDir

+ func (hd *HDir) MkdirAll(mode ...os.FileMode) *HDir

+ func (hd *HDir) Path() HString

+ func (hd *HDir) ReadDir() []*HFile

+ func (hd *HDir) Rename(newpath HString) *HDir

+ func (hd *HDir) SetPath(path HString) *HDir

+ func (hd HDir) Error() error

+ func (hd HDir) Exist() bool

+ func (hd HDir) HString() HString

+ type HFile struct

+ func NewHFile(name HString) *HFile

+ func (hf *HFile) Append(content HString, mode ...os.FileMode) *HFile

+ func (hf *HFile) Chmod(mode os.FileMode) *HFile

+ func (hf *HFile) Chown(uid, gid int) *HFile

+ func (hf *HFile) Close()

+ func (hf *HFile) Copy(dest HString, mode ...os.FileMode) *HFile

+ func (hf *HFile) Iterator() *hfiter

+ func (hf *HFile) MimeType() HString

+ func (hf *HFile) Read() HString

+ func (hf *HFile) Remove()

+ func (hf *HFile) Rename(newpath HString) *HFile

+ func (hf *HFile) SeekToLine(position int64, linesRead int) (int64, HString)

+ func (hf *HFile) TempFile(args ...HString) *HFile

+ func (hf *HFile) Write(content HString, mode ...os.FileMode) *HFile

+ func (hf HFile) Error() error

+ func (hf HFile) Exist() bool

+ func (hf HFile) Ext() HString

+ func (hf HFile) File() *os.File

+ func (hf HFile) HDir() *HDir

+ func (hf HFile) IsDir() bool

+ func (hf HFile) ModTime() time.Time

+ func (hf HFile) Mode() fs.FileMode

+ func (hf HFile) Name() string

+ func (hf HFile) Path() HString

+ func (hf HFile) ReadLines() HSlice[HString]

+ func (hf HFile) Size() int64

+ func (hf HFile) Split() (*HDir, *HFile)

+ type HFloat float64

+ func NewHFloat(floats ...float64) HFloat

+ func (hf HFloat) Abs() HFloat

+ func (hf HFloat) Add(b HFloat) HFloat

+ func (hf HFloat) BigFloat() *big.Float

+ func (hf HFloat) Bytes() []byte

+ func (hf HFloat) Compare(b HFloat) HInt

+ func (hf HFloat) Div(b HFloat) HFloat

+ func (hf HFloat) Eq(b HFloat) bool

+ func (hf HFloat) Float() float64

+ func (hf HFloat) Gt(b HFloat) bool

+ func (hf HFloat) HInt() HInt

+ func (hf HFloat) HString() HString

+ func (hf HFloat) Hash() fhash

+ func (hf HFloat) Lt(b HFloat) bool

+ func (hf HFloat) Mul(b HFloat) HFloat

+ func (hf HFloat) Ne(b HFloat) bool

+ func (hf HFloat) Round() HInt

+ func (hf HFloat) RoundDecimal(precision int) HFloat

+ func (hf HFloat) Sub(b HFloat) HFloat

+ func (hf HFloat) UInt64() uint64

+ type HInt int

+ func NewHInt(ints ...int) HInt

+ func (HInt) RandomRange(min, max HInt) HInt

+ func (hi HInt) Add(b HInt) HInt

+ func (hi HInt) Bytes() []byte

+ func (hi HInt) Div(b HInt) HInt

+ func (hi HInt) Eq(b HInt) bool

+ func (hi HInt) Gt(b HInt) bool

+ func (hi HInt) Gte(b HInt) bool

+ func (hi HInt) HFloat() HFloat

+ func (hi HInt) HString() HString

+ func (hi HInt) Hash() ihash

+ func (hi HInt) Int() int

+ func (hi HInt) Int16() int16

+ func (hi HInt) Int32() int32

+ func (hi HInt) Int64() int64

+ func (hi HInt) Int8() int8

+ func (hi HInt) IsNegative() bool

+ func (hi HInt) IsPositive() bool

+ func (hi HInt) Lt(b HInt) bool

+ func (hi HInt) Lte(b HInt) bool

+ func (hi HInt) Max(b HInt) HInt

+ func (hi HInt) Min(b HInt) HInt

+ func (hi HInt) Mul(b HInt) HInt

+ func (hi HInt) Ne(b HInt) bool

+ func (hi HInt) Random() HInt

+ func (hi HInt) Sub(b HInt) HInt

+ func (hi HInt) ToBinary() HString

+ func (hi HInt) ToHex() HString

+ func (hi HInt) ToOctal() HString

+ func (hi HInt) UInt() uint

+ func (hi HInt) UInt16() uint16

+ func (hi HInt) UInt32() uint32

+ func (hi HInt) UInt64() uint64

+ func (hi HInt) UInt8() uint8

+ type HMap map[K]V

+ func HMapFromMap(m map[K]V) HMap[K, V]

+ func HMapOf(entries ...any) HMap[K, V]

+ func NewHMap(size ...int) HMap[K, V]

+ func (hmap HMap[K, V]) Clear() HMap[K, V]

+ func (hmap HMap[K, V]) Clone() HMap[K, V]

+ func (hmap HMap[K, V]) Contains(key K) bool

+ func (hmap HMap[K, V]) Copy(src HMap[K, V]) HMap[K, V]

+ func (hmap HMap[K, V]) Delete(keys ...K) HMap[K, V]

+ func (hmap HMap[K, V]) Empty() bool

+ func (hmap HMap[K, V]) Eq(other HMap[K, V]) bool

+ func (hmap HMap[K, V]) Filter(fn func(K, V) bool) HMap[K, V]

+ func (hmap HMap[K, V]) FilterParallel(fn func(K, V) bool) HMap[K, V]

+ func (hmap HMap[K, V]) ForEach(fn func(K, V))

+ func (hmap HMap[K, V]) Get(k K) V

+ func (hmap HMap[K, V]) GetOrDefault(key K, defaultValue V) V

+ func (hmap HMap[K, V]) Invert() HMap[any, K]

+ func (hmap HMap[K, V]) Keys() HSlice[K]

+ func (hmap HMap[K, V]) Len() int

+ func (hmap HMap[K, V]) Map(fn func(K, V) (K, V)) HMap[K, V]

+ func (hmap HMap[K, V]) MapParallel(fn func(K, V) (K, V)) HMap[K, V]

+ func (hmap HMap[K, V]) Ne(other HMap[K, V]) bool

+ func (hmap HMap[K, V]) NotEmpty() bool

+ func (hmap HMap[K, V]) Set(k K, v V) HMap[K, V]

+ func (hmap HMap[K, V]) String() string

+ func (hmap HMap[K, V]) ToMap() map[K]V

+ func (hmap HMap[K, V]) Values() HSlice[V]

+ type HSlice []T

+ func HSliceOf(slice ...T) HSlice[T]

+ func NewHSlice(size ...int) HSlice[T]

+ func (hsl HSlice[T]) AddUnique(elems ...T) HSlice[T]

+ func (hsl HSlice[T]) All(fn func(T) bool) bool

+ func (hsl HSlice[T]) Any(fn func(T) bool) bool

+ func (hsl HSlice[T]) Append(elems ...T) HSlice[T]

+ func (hsl HSlice[T]) Chunks(size int) []HSlice[T]

+ func (hsl HSlice[T]) Clone() HSlice[T]

+ func (hsl HSlice[T]) Contains(val T) bool

+ func (hsl HSlice[T]) Count(elem T) int

+ func (hsl HSlice[T]) Counter() *hMapOrd[any, int]

+ func (hsl HSlice[T]) Cut(start, end int) HSlice[T]

+ func (hsl HSlice[T]) Delete(i int) HSlice[T]

+ func (hsl HSlice[T]) Difference(other HSlice[T]) HSlice[T]

+ func (hsl HSlice[T]) Empty() bool

+ func (hsl HSlice[T]) Enumerate() HMap[int, T]

+ func (hsl HSlice[T]) Eq(other HSlice[T]) bool

+ func (hsl HSlice[T]) Fill(val T) HSlice[T]

+ func (hsl HSlice[T]) Filter(fn func(T) bool) HSlice[T]

+ func (hsl HSlice[T]) FilterParallel(fn func(T) bool) HSlice[T]

+ func (hsl HSlice[T]) FilterZeroValues() HSlice[T]

+ func (hsl HSlice[T]) Flatten() HSlice[any]

+ func (hsl HSlice[T]) ForEach(fn func(T))

+ func (hsl HSlice[T]) Get(index int) T

+ func (hsl HSlice[T]) Index(val T) int

+ func (hsl HSlice[T]) Insert(index int, values ...T) HSlice[T]

+ func (hsl HSlice[T]) Intersection(other HSlice[T]) HSlice[T]

+ func (hsl HSlice[T]) Join(sep ...T) HString

+ func (hsl HSlice[T]) Last() T

+ func (hsl HSlice[T]) LastIndex() int

+ func (hsl HSlice[T]) Len() int

+ func (hsl HSlice[T]) Map(fn func(T) T) HSlice[T]

+ func (hsl HSlice[T]) MapParallel(fn func(T) T) HSlice[T]

+ func (hsl HSlice[T]) Max() T

+ func (hsl HSlice[T]) Min() T

+ func (hsl HSlice[T]) Ne(other HSlice[T]) bool

+ func (hsl HSlice[T]) NotEmpty() bool

+ func (hsl HSlice[T]) Permutations() []HSlice[T]

+ func (hsl HSlice[T]) Pop() (T, HSlice[T])

+ func (hsl HSlice[T]) Random() T

+ func (hsl HSlice[T]) RandomSample(sequence int) HSlice[T]

+ func (hsl HSlice[T]) Range(start, end int) HSlice[T]

+ func (hsl HSlice[T]) Reduce(fn func(acc, val T) T, initial T) T

+ func (hsl HSlice[T]) ReduceParallel(fn func(T, T) T, initial T) T

+ func (hsl HSlice[T]) Reverse() HSlice[T]

+ func (hsl HSlice[T]) Set(i int, val T)

+ func (hsl HSlice[T]) Shuffle() HSlice[T]

+ func (hsl HSlice[T]) SortBy(f func(i, j int) bool) HSlice[T]

+ func (hsl HSlice[T]) String() string

+ func (hsl HSlice[T]) Swap(i, j int) HSlice[T]

+ func (hsl HSlice[T]) SymmetricDifference(other HSlice[T]) HSlice[T]

+ func (hsl HSlice[T]) ToHMapHashed() HMap[HString, T]

+ func (hsl HSlice[T]) ToSlice() []T

+ func (hsl HSlice[T]) ToStringSlice() []string

+ func (hsl HSlice[T]) Union(other HSlice[T]) HSlice[T]

+ func (hsl HSlice[T]) Unique() HSlice[T]

+ func (hsl HSlice[T]) Zip(slices ...HSlice[T]) []HSlice[T]

+ type HString string

+ func NewHString(strs ...string) HString

+ func (HString) Random(count int) HString

+ func (hs HString) Add(hstr HString) HString

+ func (hs HString) AddPrefix(hstr HString) HString

+ func (hs HString) Bytes() []byte

+ func (hs HString) Chunks(size int) HSlice[HString]

+ func (hs HString) Compare(hstr HString) HInt

+ func (hs HString) Contains(substr HString) bool

+ func (hs HString) ContainsAny(chars HString) bool

+ func (hs HString) ContainsRune(r rune) bool

+ func (hs HString) Count(substr HString) int

+ func (hs HString) Cut(start, end HString) HString

+ func (hs HString) Decode() dec

+ func (hs HString) Empty() bool

+ func (hs HString) Encode() enc

+ func (hs HString) Eq(hstr HString) bool

+ func (hs HString) Fields() HSlice[HString]

+ func (hs HString) Gt(hstr HString) bool

+ func (hs HString) HBytes() HBytes

+ func (hs HString) HFloat() HFloat

+ func (hs HString) HInt() HInt

+ func (hs HString) HasPrefix(prefix HString) bool

+ func (hs HString) HasSuffix(suffix HString) bool

+ func (hs HString) Hash() shash

+ func (hs HString) Index(substr HString) int

+ func (hs HString) IndexRune(r rune) int

+ func (hs HString) IsDigit() bool

+ func (hs HString) Len() int

+ func (hs HString) LenRunes() int

+ func (hs HString) Lt(hstr HString) bool

+ func (hs HString) Map(fn func(rune) rune) HString

+ func (hs HString) Ne(hstr HString) bool

+ func (hs HString) NormalizeNFC() HString

+ func (hs HString) NotEmpty() bool

+ func (hs HString) Reader() *strings.Reader

+ func (hs HString) Repeat(count int) HString

+ func (hs HString) Replace(oldS, newS HString, n int) HString

+ func (hs HString) ReplaceAll(oldS, newS HString) HString

+ func (hs HString) Reverse() HString

+ func (hs HString) Runes() []rune

+ func (hs HString) Similarity(hstr HString) HFloat

+ func (hs HString) Split(sep ...HString) HSlice[HString]

+ func (hs HString) String() string

+ func (hs HString) ToLower() HString

+ func (hs HString) ToTitle() HString

+ func (hs HString) ToUpper() HString

+ func (hs HString) Trim(cutset HString) HString

+ func (hs HString) TrimLeft(cutset HString) HString

+ func (hs HString) TrimPrefix(cutset HString) HString

+ func (hs HString) TrimRight(cutset HString) HString

+ func (hs HString) TrimSpace() HString

+ func (hs HString) TrimSuffix(cutset HString) HString