gost

package module

Go to main page

Versions in this module

v0

v0.11.0

Nov 26, 2023

Changes in this version

+ const I16_MAX

+ const I16_MIN

+ const I32_MAX

+ const I32_MIN

+ const I64_MAX

+ const I64_MIN

+ const I8_MAX

+ const I8_MIN

+ const ISize_MAX

+ const ISize_MIN

+ const U16_MAX

+ const U16_MIN

+ const U32_MAX

+ const U32_MIN

+ const U64_MAX

+ const U64_MIN

+ const U8_MAX

+ const U8_MIN

+ const USize_MAX

+ const USize_MIN

+ var I128_MAX = I128

+ var I128_MIN = I128

+ var U128_MAX = U128

+ var U128_MIN = U128

+ func Sleep(dur Duration)

+ type Duration struct

+ func DurationFromMicros(micros U64) Duration

+ func DurationFromMillis(millis U64) Duration

+ func DurationFromNanos(nanos U64) Duration

+ func DurationFromSecs(secs U64) Duration

+ func DurationNew(secs U64, nanos U32) Duration

+ func (self Duration) AsMicros() U128

+ func (self Duration) AsMillis() U128

+ func (self Duration) AsNanos() U128

+ func (self Duration) AsSecs() U64

+ func (self Duration) IsZero() bool

+ func (self Duration) SubsecMicros() U32

+ func (self Duration) SubsecMillis() U32

+ func (self Duration) SubsecNanos() U32

+ type I128 struct

+ func I128_FromI64(low I64) I128

+ func I128_FromU64(low U64) I128

+ func (lhs I128) Div(rhs I128) I128

+ func (lhs I128) Rem(rhs I128) I128

+ func (lhs I128) Shl(rhs I128) I128

+ func (lhs I128) Shr(rhs I128) I128

+ func (self *I128) AddAssign(rhs I128)

+ func (self *I128) DivAssign(rhs I128)

+ func (self *I128) MulAssign(rhs I128)

+ func (self *I128) RemAssign(rhs I128)

+ func (self *I128) SubAssign(rhs I128)

+ func (self I128) Abs() I128

+ func (self I128) Add(rhs I128) I128

+ func (self I128) Cmp(rhs I128) Ordering

+ func (self I128) Debug() String

+ func (self I128) Display() String

+ func (self I128) Eq(rhs I128) Bool

+ func (self I128) IsNegative() Bool

+ func (self I128) IsPositive() Bool

+ func (self I128) Mul(rhs I128) I128

+ func (self I128) Neg() I128

+ func (self I128) Sub(rhs I128) I128

+ func (self I128) ToString() String

type I16

+ func (lhs I16) Shl(rhs I16) I16

+ func (lhs I16) Shr(rhs I16) I16

+ func (self I16) Neg(rhs I16) I16

type I32

+ func (lhs I32) Shl(rhs I32) I32

+ func (lhs I32) Shr(rhs I32) I32

+ func (self I32) Neg(rhs I32) I32

type I64

+ func (lhs I64) Shl(rhs I64) I64

+ func (lhs I64) Shr(rhs I64) I64

+ func (self I64) Neg(rhs I64) I64

type I8

+ func (lhs I8) Shl(rhs I8) I8

+ func (lhs I8) Shr(rhs I8) I8

+ func (self I8) Neg(rhs I8) I8

type ISize

+ func (lhs ISize) Shl(rhs ISize) ISize

+ func (lhs ISize) Shr(rhs ISize) ISize

+ func (self ISize) Neg(rhs ISize) ISize

+ type JoinHandle struct

+ func Spawn(f func()) JoinHandle

+ func (self JoinHandle) IsFinished() bool

+ func (self JoinHandle) Join() Result[Unit]

+ type Neg interface

+ Neg func() T

+ type Shl interface

+ Shl func(rhs T) T

+ type Shr interface

+ Shr func(rhs T) T

+ type U128 struct

+ func U128_FromU64(low U64) U128

+ func (lhs U128) Div(rhs U128) U128

+ func (lhs U128) Rem(rhs U128) U128

+ func (lhs U128) Shl(rhs U128) U128

+ func (lhs U128) Shr(rhs U128) U128

+ func (self *U128) AddAssign(rhs U128)

+ func (self *U128) DivAssign(rhs U128)

+ func (self *U128) MulAssign(rhs U128)

+ func (self *U128) RemAssign(rhs U128)

+ func (self *U128) SubAssign(rhs U128)

+ func (self U128) Add(rhs U128) U128

+ func (self U128) Cmp(rhs U128) Ordering

+ func (self U128) Debug() String

+ func (self U128) Display() String

+ func (self U128) Eq(rhs U128) Bool

+ func (self U128) Mul(rhs U128) U128

+ func (self U128) Sub(rhs U128) U128

+ func (self U128) ToString() String

type U16

+ func (lhs U16) Shl(rhs U16) U16

+ func (lhs U16) Shr(rhs U16) U16

type U32

+ func (lhs U32) Shl(rhs U32) U32

+ func (lhs U32) Shr(rhs U32) U32

type U64

+ func (lhs U64) Shl(rhs U64) U64

+ func (lhs U64) Shr(rhs U64) U64

type U8

+ func (lhs U8) Shl(rhs U8) U8

+ func (lhs U8) Shr(rhs U8) U8

type USize

+ func (lhs USize) Shl(rhs USize) USize

+ func (lhs USize) Shr(rhs USize) USize

v0.10.0

Nov 14, 2023

Changes in this version

type BTreeSet

+ func (self BTreeSet[K]) Intersection(other BTreeSet[K]) BTreeSet[K]

+ func (self BTreeSet[K]) IsDisjoint(other BTreeSet[K]) Bool

+ func (self BTreeSet[K]) IsSubset(other BTreeSet[K]) Bool

+ func (self BTreeSet[K]) IsSuperset(other BTreeSet[K]) Bool

+ func (self BTreeSet[K]) SymmetricDifference(other BTreeSet[K]) BTreeSet[K]

+ func (self BTreeSet[K]) Union(other BTreeSet[K]) BTreeSet[K]

type F32

+ func (self F32) Abs() F32

+ func (self F32) Ceil() F32

+ func (self F32) Exp() F32

+ func (self F32) Exp2() F32

+ func (self F32) Floor() F32

+ func (self F32) Frac() F32

+ func (self F32) Ln() F32

+ func (self F32) Log(base F32) F32

+ func (self F32) Log10() F32

+ func (self F32) Log2() F32

+ func (self F32) Powf(n F32) F32

+ func (self F32) Powi(n int) F32

+ func (self F32) Round() F32

+ func (self F32) Sqrt() F32

+ func (self F32) Trunc() F32

type F64

+ func (self F64) Abs() F64

+ func (self F64) Ceil() F64

+ func (self F64) Exp() F64

+ func (self F64) Exp2() F64

+ func (self F64) Floor() F64

+ func (self F64) Frac() F64

+ func (self F64) Ln() F64

+ func (self F64) Log(base F64) F64

+ func (self F64) Log10() F64

+ func (self F64) Log2() F64

+ func (self F64) Powf(n F64) F64

+ func (self F64) Powi(n int) F64

+ func (self F64) Round() F64

+ func (self F64) Sqrt() F64

+ func (self F64) Trunc() F64

type HashSet

+ func (self HashSet[K]) Intersection(other HashSet[K]) HashSet[K]

+ func (self HashSet[K]) IsDisjoint(other HashSet[K]) Bool

+ func (self HashSet[K]) IsSubset(other HashSet[K]) Bool

+ func (self HashSet[K]) IsSuperset(other HashSet[K]) Bool

+ func (self HashSet[K]) SymmetricDifference(other HashSet[K]) HashSet[K]

+ func (self HashSet[K]) Union(other HashSet[K]) HashSet[K]

type I16

+ func (self I16) Abs() I16

+ func (self I16) AbsDiff(other I16) U16

+ func (self I16) IsNegative() Bool

+ func (self I16) IsPositive() Bool

+ func (self I16) Pow(exp U32) I16

+ func (self I16) SaturatingAdd(rhs I16) I16

+ func (self I16) SaturatingDiv(rhs I16) I16

+ func (self I16) SaturatingMul(rhs I16) I16

type I32

+ func (self I32) Abs() I32

+ func (self I32) AbsDiff(other I32) U32

+ func (self I32) IsNegative() Bool

+ func (self I32) IsPositive() Bool

+ func (self I32) Pow(exp U32) I32

+ func (self I32) SaturatingAdd(rhs I32) I32

+ func (self I32) SaturatingDiv(rhs I32) I32

+ func (self I32) SaturatingMul(rhs I32) I32

type I64

+ func (self I64) Abs() I64

+ func (self I64) AbsDiff(other I64) U64

+ func (self I64) IsNegative() Bool

+ func (self I64) IsPositive() Bool

+ func (self I64) Pow(exp U32) I64

+ func (self I64) SaturatingAdd(rhs I64) I64

+ func (self I64) SaturatingDiv(rhs I64) I64

+ func (self I64) SaturatingMul(rhs I64) I64

type I8

+ func (self I8) Abs() I8

+ func (self I8) AbsDiff(other I8) U8

+ func (self I8) IsNegative() Bool

+ func (self I8) IsPositive() Bool

+ func (self I8) Pow(exp U32) I8

+ func (self I8) SaturatingAdd(rhs I8) I8

+ func (self I8) SaturatingDiv(rhs I8) I8

+ func (self I8) SaturatingMul(rhs I8) I8

type ISize

+ func (self ISize) Abs() ISize

+ func (self ISize) AbsDiff(other ISize) USize

+ func (self ISize) IsNegative() Bool

+ func (self ISize) IsPositive() Bool

+ func (self ISize) Pow(exp U32) ISize

+ func (self ISize) SaturatingAdd(rhs ISize) ISize

+ func (self ISize) SaturatingDiv(rhs ISize) ISize

+ func (self ISize) SaturatingMul(rhs ISize) ISize

type Pair

+ func (p Pair[K, V]) Display() string

type Result

+ func StringFromUTF16(bytes Vec[U16]) Result[String]

type String

+ func StringFromUTF8(bytes Vec[U8]) String

+ func (self *String) Pop() Option[Char]

+ func (self *String) Push(c Char) String

+ func (self String) Chars() Vec[Char]

+ func (self String) Contains(str String) bool

+ func (self String) Find(str String) Option[USize]

+ func (self String) IntoBytes() Vec[U8]

+ func (self String) IsEmpty() bool

+ func (self String) Len() USize

+ func (self String) ParseF64() Result[F64]

+ func (self String) ParseI64() Result[I64]

+ func (self String) ParseU64() Result[U64]

+ func (self String) Repeat(n USize) String

+ func (self String) Replace(old String, new String) String

+ func (self String) Split(str String) Vec[String]

+ func (self String) ToLowercase() String

+ func (self String) ToUppercase() String

+ func (self String) Trim() String

type U16

+ func (self U16) AbsDiff(other U16) U16

+ func (self U16) Pow(exp U32) U16

+ func (self U16) SaturatingAdd(rhs U16) U16

+ func (self U16) SaturatingDiv(rhs U16) U16

+ func (self U16) SaturatingMul(rhs U16) U16

type U32

+ func (self U32) AbsDiff(other U32) U32

+ func (self U32) Pow(exp U32) U32

+ func (self U32) SaturatingAdd(rhs U32) U32

+ func (self U32) SaturatingDiv(rhs U32) U32

+ func (self U32) SaturatingMul(rhs U32) U32

type U64

+ func (self U64) AbsDiff(other U64) U64

+ func (self U64) Pow(exp U32) U64

+ func (self U64) SaturatingAdd(rhs U64) U64

+ func (self U64) SaturatingDiv(rhs U64) U64

+ func (self U64) SaturatingMul(rhs U64) U64

type U8

+ func (self U8) AbsDiff(other U8) U8

+ func (self U8) Pow(exp U32) U8

+ func (self U8) SaturatingAdd(rhs U8) U8

+ func (self U8) SaturatingDiv(rhs U8) U8

+ func (self U8) SaturatingMul(rhs U8) U8

type USize

+ func (self USize) AbsDiff(other USize) USize

+ func (self USize) Pow(exp U32) USize

+ func (self USize) SaturatingAdd(rhs USize) USize

+ func (self USize) SaturatingDiv(rhs USize) USize

+ func (self USize) SaturatingMul(rhs USize) USize

+ type Unit struct

+ type Void struct

v0.9.0

Nov 4, 2023

Changes in this version

+ func If(condition Bool, expression func() T) ifElseContext[T]

+ type BinaryHeap struct

+ func BinaryHeapNew() BinaryHeap[T]

+ func BinaryHeapWithCapacity(capacity USize) BinaryHeap[T]

+ func BinaryHeapWithLen(len USize) BinaryHeap[T]

+ func (self *BinaryHeap[T]) Append(other *BinaryHeap[T])

+ func (self *BinaryHeap[T]) AsSlice() []T

+ func (self *BinaryHeap[T]) Clear()

+ func (self *BinaryHeap[T]) IntoSortedVec() Vec[T]

+ func (self *BinaryHeap[T]) IntoVec() Vec[T]

+ func (self *BinaryHeap[T]) Pop() Option[T]

+ func (self *BinaryHeap[T]) Push(item T)

+ func (self *BinaryHeap[T]) Reserve(capacity USize)

+ func (self BinaryHeap[T]) Capacity() USize

+ func (self BinaryHeap[T]) IsEmpty() Bool

+ func (self BinaryHeap[T]) Len() USize

+ type Future interface

+ Await func() T

+ Poll func() Poll[T]

type I16

+ func (self *I16) RemAssign(rhs I16)

+ func (self I16) CheckedAdd(rhs I16) Option[I16]

+ func (self I16) CheckedDiv(rhs I16) Option[I16]

+ func (self I16) CheckedMul(rhs I16) Option[I16]

+ func (self I16) CheckedRem(rhs I16) Option[I16]

+ func (self I16) CheckedSub(rhs I16) Option[I16]

+ func (self I16) Rem(rhs I16) I16

+ func (self I16) SaturatingSub(rhs I16) I16

+ func (self I16) WrappingDiv(rhs I16) I16

+ func (self I16) WrappingMul(rhs I16) I16

type I32

+ func (self *I32) RemAssign(rhs I32)

+ func (self I32) CheckedAdd(rhs I32) Option[I32]

+ func (self I32) CheckedDiv(rhs I32) Option[I32]

+ func (self I32) CheckedMul(rhs I32) Option[I32]

+ func (self I32) CheckedRem(rhs I32) Option[I32]

+ func (self I32) CheckedSub(rhs I32) Option[I32]

+ func (self I32) Rem(rhs I32) I32

+ func (self I32) SaturatingSub(rhs I32) I32

+ func (self I32) WrappingDiv(rhs I32) I32

+ func (self I32) WrappingMul(rhs I32) I32

type I64

+ func (self *I64) RemAssign(rhs I64)

+ func (self I64) CheckedAdd(rhs I64) Option[I64]

+ func (self I64) CheckedDiv(rhs I64) Option[I64]

+ func (self I64) CheckedMul(rhs I64) Option[I64]

+ func (self I64) CheckedRem(rhs I64) Option[I64]

+ func (self I64) CheckedSub(rhs I64) Option[I64]

+ func (self I64) Rem(rhs I64) I64

+ func (self I64) SaturatingSub(rhs I64) I64

+ func (self I64) WrappingDiv(rhs I64) I64

+ func (self I64) WrappingMul(rhs I64) I64

type I8

+ func (self *I8) RemAssign(rhs I8)

+ func (self I8) CheckedAdd(rhs I8) Option[I8]

+ func (self I8) CheckedDiv(rhs I8) Option[I8]

+ func (self I8) CheckedMul(rhs I8) Option[I8]

+ func (self I8) CheckedRem(rhs I8) Option[I8]

+ func (self I8) CheckedSub(rhs I8) Option[I8]

+ func (self I8) Rem(rhs I8) I8

+ func (self I8) SaturatingSub(rhs I8) I8

+ func (self I8) WrappingDiv(rhs I8) I8

+ func (self I8) WrappingMul(rhs I8) I8

type ISize

+ func (self *ISize) RemAssign(rhs ISize)

+ func (self ISize) CheckedAdd(rhs ISize) Option[ISize]

+ func (self ISize) CheckedDiv(rhs ISize) Option[ISize]

+ func (self ISize) CheckedMul(rhs ISize) Option[ISize]

+ func (self ISize) CheckedRem(rhs ISize) Option[ISize]

+ func (self ISize) CheckedSub(rhs ISize) Option[ISize]

+ func (self ISize) Rem(rhs ISize) ISize

+ func (self ISize) SaturatingSub(rhs ISize) ISize

+ func (self ISize) WrappingDiv(rhs ISize) ISize

+ func (self ISize) WrappingMul(rhs ISize) ISize

+ type Poll struct

+ func (self *Poll[T]) IsPending() Bool

+ func (self *Poll[T]) IsReady() Bool

+ func (self *Poll[T]) Unwrap() T

+ type Rem interface

+ Rem func(rhs T) T

+ type RemAssign interface

+ RemAssign func(rhs T)

type U16

+ func (self *U16) RemAssign(rhs U16)

+ func (self U16) CheckedAdd(rhs U16) Option[U16]

+ func (self U16) CheckedDiv(rhs U16) Option[U16]

+ func (self U16) CheckedMul(rhs U16) Option[U16]

+ func (self U16) CheckedRem(rhs U16) Option[U16]

+ func (self U16) CheckedSub(rhs U16) Option[U16]

+ func (self U16) Rem(rhs U16) U16

+ func (self U16) SaturatingSub(rhs U16) U16

+ func (self U16) WrappingDiv(rhs U16) U16

+ func (self U16) WrappingMul(rhs U16) U16

type U32

+ func (self *U32) RemAssign(rhs U32)

+ func (self U32) CheckedAdd(rhs U32) Option[U32]

+ func (self U32) CheckedDiv(rhs U32) Option[U32]

+ func (self U32) CheckedMul(rhs U32) Option[U32]

+ func (self U32) CheckedRem(rhs U32) Option[U32]

+ func (self U32) CheckedSub(rhs U32) Option[U32]

+ func (self U32) Rem(rhs U32) U32

+ func (self U32) SaturatingSub(rhs U32) U32

+ func (self U32) WrappingDiv(rhs U32) U32

+ func (self U32) WrappingMul(rhs U32) U32

type U64

+ func (self *U64) RemAssign(rhs U64)

+ func (self U64) CheckedAdd(rhs U64) Option[U64]

+ func (self U64) CheckedDiv(rhs U64) Option[U64]

+ func (self U64) CheckedMul(rhs U64) Option[U64]

+ func (self U64) CheckedRem(rhs U64) Option[U64]

+ func (self U64) CheckedSub(rhs U64) Option[U64]

+ func (self U64) Rem(rhs U64) U64

+ func (self U64) SaturatingSub(rhs U64) U64

+ func (self U64) WrappingDiv(rhs U64) U64

+ func (self U64) WrappingMul(rhs U64) U64

type U8

+ func (self *U8) RemAssign(rhs U8)

+ func (self U8) CheckedAdd(rhs U8) Option[U8]

+ func (self U8) CheckedDiv(rhs U8) Option[U8]

+ func (self U8) CheckedMul(rhs U8) Option[U8]

+ func (self U8) CheckedRem(rhs U8) Option[U8]

+ func (self U8) CheckedSub(rhs U8) Option[U8]

+ func (self U8) Rem(rhs U8) U8

+ func (self U8) SaturatingSub(rhs U8) U8

+ func (self U8) WrappingDiv(rhs U8) U8

+ func (self U8) WrappingMul(rhs U8) U8

type USize

+ func (self *USize) RemAssign(rhs USize)

+ func (self USize) CheckedAdd(rhs USize) Option[USize]

+ func (self USize) CheckedDiv(rhs USize) Option[USize]

+ func (self USize) CheckedMul(rhs USize) Option[USize]

+ func (self USize) CheckedRem(rhs USize) Option[USize]

+ func (self USize) CheckedSub(rhs USize) Option[USize]

+ func (self USize) Rem(rhs USize) USize

+ func (self USize) SaturatingSub(rhs USize) USize

+ func (self USize) WrappingDiv(rhs USize) USize

+ func (self USize) WrappingMul(rhs USize) USize

type VecDeque

+ func VecDequeWithLen(len USize) VecDeque[T]

+ func (self *VecDeque[T]) Append(other *VecDeque[T])

+ func (self *VecDeque[T]) Dedup(key func(T) any)

+ func (self *VecDeque[T]) Fill(value T)

+ func (self *VecDeque[T]) FillWith(f func() T)

+ func (self *VecDeque[T]) Retain(f func(T) Bool)

+ func (self *VecDeque[T]) Set(index USize, value T) Option[T]

+ func (self *VecDeque[T]) SetUnchecked(index USize, value T)

+ func (self *VecDeque[T]) Sort()

+ func (self *VecDeque[T]) SortBy(f func(T, T) Ordering)

+ func (self *VecDeque[T]) SortUnstable()

+ func (self *VecDeque[T]) SortUnstableBy(f func(T, T) Ordering)

+ func (self *VecDeque[T]) Swap(a USize, b USize)

+ func (self VecDeque[T]) AsSlice() []T

+ func (self VecDeque[T]) BinarySearch(value T) Option[USize]

+ func (self VecDeque[T]) BinarySearchBy(f func(T) Ordering) Option[USize]

+ func (self VecDeque[T]) GetUnchecked(index USize) T

v0.8.1

Nov 2, 2023

v0.8.0

Nov 2, 2023

Changes in this version

type I16

+ func (self I16) WrappingAdd(rhs I16) I16

+ func (self I16) WrappingSub(rhs I16) I16

type I32

+ func (self I32) WrappingAdd(rhs I32) I32

+ func (self I32) WrappingSub(rhs I32) I32

type I64

+ func (self I64) WrappingAdd(rhs I64) I64

+ func (self I64) WrappingSub(rhs I64) I64

type I8

+ func (self I8) WrappingAdd(rhs I8) I8

+ func (self I8) WrappingSub(rhs I8) I8

type ISize

+ func (self ISize) WrappingAdd(rhs ISize) ISize

+ func (self ISize) WrappingSub(rhs ISize) ISize

type U16

+ func (self U16) WrappingAdd(rhs U16) U16

+ func (self U16) WrappingSub(rhs U16) U16

type U32

+ func (self U32) WrappingAdd(rhs U32) U32

+ func (self U32) WrappingSub(rhs U32) U32

type U64

+ func (self U64) WrappingAdd(rhs U64) U64

+ func (self U64) WrappingSub(rhs U64) U64

type U8

+ func (self U8) WrappingAdd(rhs U8) U8

+ func (self U8) WrappingSub(rhs U8) U8

type USize

+ func (self USize) WrappingAdd(rhs USize) USize

+ func (self USize) WrappingSub(rhs USize) USize

+ type VecDeque struct

+ func VecDequeNew() VecDeque[T]

+ func VecDequeWithCapacity(capacity USize) VecDeque[T]

+ func (self *VecDeque[T]) Clear()

+ func (self *VecDeque[T]) PopBack() Option[T]

+ func (self *VecDeque[T]) PopFront() Option[T]

+ func (self *VecDeque[T]) PushBack(value T)

+ func (self *VecDeque[T]) PushFront(value T)

+ func (self *VecDeque[T]) Reserve(additional USize)

+ func (self VecDeque[T]) AsRef() *VecDeque[T]

+ func (self VecDeque[T]) Back() Option[T]

+ func (self VecDeque[T]) Capacity() USize

+ func (self VecDeque[T]) Clone() *VecDeque[T]

+ func (self VecDeque[T]) Contains(value T) Bool

+ func (self VecDeque[T]) Debug() String

+ func (self VecDeque[T]) Display() String

+ func (self VecDeque[T]) Eq(other VecDeque[T]) Bool

+ func (self VecDeque[T]) Front() Option[T]

+ func (self VecDeque[T]) Get(index USize) Option[T]

+ func (self VecDeque[T]) IntoIter() Iterator[T]

+ func (self VecDeque[T]) IsEmpty() Bool

+ func (self VecDeque[T]) Len() USize

+ type VecDequeIter struct

+ func (self *VecDequeIter[T]) CollectToLinkedList() LinkedList[T]

+ func (self *VecDequeIter[T]) CollectToVec() Vec[T]

+ func (self *VecDequeIter[T]) Filter(f func(T) Bool) Iterator[T]

+ func (self *VecDequeIter[T]) Fold(initial T, f func(T, T) T) T

+ func (self *VecDequeIter[T]) Map(f func(T) T) Iterator[T]

+ func (self *VecDequeIter[T]) Next() Option[T]

+ func (self *VecDequeIter[T]) Rev() Iterator[T]

v0.7.3

Nov 1, 2023

Changes in this version

+ func Assert(condition Bool, message String, args ...any)

+ func AssertEq(lhs T, rhs T, message String, args ...any)

+ func AssertNe(lhs T, rhs T, message String, args ...any)

+ func Panic(message String, args ...any)

+ func Todo(messages ...String)

+ func Unimplemented(messages ...String)

+ func Unreachable(messages ...String)

+ type AsRef interface

+ AsRef func() *T

type BTreeMap

+ func (self BTreeMap[K, V]) AsRef() *BTreeMap[K, V]

+ func (self BTreeMap[K, V]) Eq(other *BTreeMap[K, V]) bool

type BTreeSet

+ func (self BTreeSet[K]) AsRef() *BTreeSet[K]

+ func (self BTreeSet[K]) Clone() BTreeSet[K]

+ func (self BTreeSet[K]) Eq(other BTreeSet[K]) Bool

type Bool

+ func (self Bool) AsRef() *Bool

type Byte

+ func (self Byte) AsRef() *Byte

type Char

+ func (self Char) AsRef() *Char

type Complex128

+ func (self Complex128) AsRef() *Complex128

type Complex64

+ func (self Complex64) AsRef() *Complex64

type F32

+ func (self F32) AsRef() *F32

type F64

+ func (self F64) AsRef() *F64

type HashMap

+ func (self HashMap[K, V]) AsRef() *HashMap[K, V]

+ func (self HashMap[K, V]) Clone() HashMap[K, V]

+ func (self HashMap[K, V]) Eq(rhs HashMap[K, V]) Bool

type HashSet

+ func (self HashSet[K]) AsRef() *HashSet[K]

+ func (self HashSet[K]) Clone() HashSet[K]

+ func (self HashSet[K]) Eq(rhs HashSet[K]) Bool

type I16

+ func (self I16) AsRef() *I16

type I32

+ func (self I32) AsRef() *I32

type I64

+ func (self I64) AsRef() *I64

type I8

+ func (self I8) AsRef() *I8

type ISize

+ func (self ISize) AsRef() *ISize

type LinkedList

+ func (self LinkedList[T]) AsRef() *LinkedList[T]

+ func (self LinkedList[T]) Clone() LinkedList[T]

+ func (self LinkedList[T]) Eq(rhs LinkedList[T]) Bool

+ type Mutex struct

+ func MutexNew(value T) Mutex[T]

+ func (self *Mutex[T]) Lock() *T

+ func (self *Mutex[T]) TryLock() Result[*T]

+ func (self *Mutex[T]) Unlock()

type Option

+ func (self Option[T]) AsRef() *Option[T]

+ func (self Option[T]) Clone() Option[T]

+ func (self Option[T]) Eq(rhs Option[T]) Bool

type Pair

+ func (p Pair[K, V]) AsRef() *Pair[K, V]

type Result

+ func (self Result[T]) AsRef() *Result[T]

+ func (self Result[T]) Clone() Result[T]

+ func (self Result[T]) Eq(rhs Result[T]) Bool

type String

+ func (self String) AsRef() *String

+ type TryLockError struct

+ func (self TryLockError) Error() string

type U16

+ func (self U16) AsRef() *U16

type U32

+ func (self U32) AsRef() *U32

type U64

+ func (self U64) AsRef() *U64

type U8

+ func (self U8) AsRef() *U8

type USize

+ func (self USize) AsRef() *USize

type Vec

+ func (self Vec[T]) AsRef() *Vec[T]

+ func (self Vec[T]) Clone() Vec[T]

+ func (self Vec[T]) Eq(other Vec[T]) Bool

v0.7.2

Oct 22, 2023

v0.7.1

Oct 22, 2023

v0.7.0

Oct 22, 2023

Changes in this version

+ type BTreeMap struct

+ func BTreeMapNew() BTreeMap[K, V]

+ func (self *BTreeMap[K, V]) Clear()

+ func (self *BTreeMap[K, V]) ContainsKey(key K) Bool

+ func (self *BTreeMap[K, V]) Get(key K) Option[V]

+ func (self *BTreeMap[K, V]) Insert(key K, value V) Option[V]

+ func (self *BTreeMap[K, V]) IsEmpty() Bool

+ func (self *BTreeMap[K, V]) Len() USize

+ func (self *BTreeMap[K, V]) Remove(key K) Option[V]

+ func (self BTreeMap[K, V]) Debug() String

+ func (self BTreeMap[K, V]) Display() String

+ func (self BTreeMap[K, V]) IntoIter() Iterator[Pair[K, V]]

+ func (self BTreeMap[K, V]) Keys() Iterator[K]

+ func (self BTreeMap[K, V]) Values() Iterator[V]

+ type BTreeMapIter struct

+ func (self *BTreeMapIter[K, V]) Filter(f func(Pair[K, V]) Bool) Iterator[Pair[K, V]]

+ func (self *BTreeMapIter[K, V]) Fold(init Pair[K, V], f func(Pair[K, V], Pair[K, V]) Pair[K, V]) Pair[K, V]

+ func (self *BTreeMapIter[K, V]) Map(f func(Pair[K, V]) Pair[K, V]) Iterator[Pair[K, V]]

+ func (self *BTreeMapIter[K, V]) Next() Option[Pair[K, V]]

+ func (self BTreeMapIter[K, V]) CollectToLinkedList() LinkedList[Pair[K, V]]

+ func (self BTreeMapIter[K, V]) CollectToVec() Vec[Pair[K, V]]

+ func (self BTreeMapIter[K, V]) Rev() Iterator[Pair[K, V]]

+ type BTreeMapKeys struct

+ func (self *BTreeMapKeys[K]) Filter(f func(K) Bool) Iterator[K]

+ func (self *BTreeMapKeys[K]) Fold(init K, f func(K, K) K) K

+ func (self *BTreeMapKeys[K]) Map(f func(K) K) Iterator[K]

+ func (self *BTreeMapKeys[K]) Next() Option[K]

+ func (self BTreeMapKeys[K]) CollectToLinkedList() LinkedList[K]

+ func (self BTreeMapKeys[K]) CollectToVec() Vec[K]

+ func (self BTreeMapKeys[K]) Rev() Iterator[K]

+ type BTreeMapValues struct

+ func (self *BTreeMapValues[V]) Filter(f func(V) Bool) Iterator[V]

+ func (self *BTreeMapValues[V]) Fold(init V, f func(V, V) V) V

+ func (self *BTreeMapValues[V]) Map(f func(V) V) Iterator[V]

+ func (self *BTreeMapValues[V]) Next() Option[V]

+ func (self BTreeMapValues[V]) CollectToLinkedList() LinkedList[V]

+ func (self BTreeMapValues[V]) CollectToVec() Vec[V]

+ func (self BTreeMapValues[V]) Rev() Iterator[V]

+ type BTreeNode struct

+ type BTreeSet struct

+ func BTreeSetNew() BTreeSet[K]

+ func (self *BTreeSet[K]) Clear()

+ func (self *BTreeSet[K]) Contains(key K) Bool

+ func (self *BTreeSet[K]) Insert(key K) Bool

+ func (self *BTreeSet[K]) IntoIter() Iterator[K]

+ func (self *BTreeSet[K]) IsEmpty() Bool

+ func (self *BTreeSet[K]) Len() USize

+ func (self *BTreeSet[K]) Remove(key K) Bool

+ func (self BTreeSet[K]) Debug() String

+ func (self BTreeSet[K]) Display() String

+ type BTreeSetIter struct

+ func (self *BTreeSetIter[K]) Next() Option[K]

+ func (self BTreeSetIter[K]) CollectToLinkedList() LinkedList[K]

+ func (self BTreeSetIter[K]) CollectToVec() Vec[K]

+ func (self BTreeSetIter[K]) Filter(f func(K) Bool) Iterator[K]

+ func (self BTreeSetIter[K]) Fold(init K, f func(K, K) K) K

+ func (self BTreeSetIter[K]) Map(f func(K) K) Iterator[K]

+ func (self BTreeSetIter[K]) Rev() Iterator[K]

+ type HashSet struct

+ func HashSetFromSlice(slice []K) HashSet[K]

+ func HashSetNew() HashSet[K]

+ func HashSetWithCapacity(capacity USize) HashSet[K]

+ func (self *HashSet[K]) Clear()

+ func (self *HashSet[K]) Insert(value K) Bool

+ func (self *HashSet[K]) Remove(value K) Bool

+ func (self HashSet[K]) AsSlice() []K

+ func (self HashSet[K]) Contains(value K) Bool

+ func (self HashSet[K]) Debug() String

+ func (self HashSet[K]) Display() String

+ func (self HashSet[K]) Get(value K) Option[K]

+ func (self HashSet[K]) IntoIter() Iterator[K]

+ func (self HashSet[K]) IsEmpty() Bool

+ func (self HashSet[K]) Len() USize

+ type HashSetIter struct

+ func (self *HashSetIter[K]) Next() Option[K]

+ func (self HashSetIter[K]) CollectToLinkedList() LinkedList[K]

+ func (self HashSetIter[K]) CollectToVec() Vec[K]

+ func (self HashSetIter[K]) Filter(f func(K) Bool) Iterator[K]

+ func (self HashSetIter[K]) Fold(init K, f func(K, K) K) K

+ func (self HashSetIter[K]) Map(f func(K) K) Iterator[K]

+ func (self HashSetIter[K]) Rev() Iterator[K]

type Pair

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

+ func (p Pair[K, V]) Cmp(other Pair[K, V]) Ordering

+ func (p Pair[K, V]) Debug() string

+ func (p Pair[K, V]) Eq(other Pair[K, V]) Bool

+ func (p Pair[K, V]) String() string

+ func (p Pair[K, V]) ToString() string

type Vec

+ func (self *Vec[T]) Set(index USize, value T) Option[T]

+ func (self *Vec[T]) SetUnchecked(index USize, value T)

v0.6.0

Oct 15, 2023

Changes in this version

type Byte

+ func (self *Byte) AddAssign(rhs Byte)

+ func (self *Byte) DivAssign(rhs Byte)

+ func (self *Byte) MulAssign(rhs Byte)

+ func (self *Byte) SubAssign(rhs Byte)

+ func (self Byte) Add(rhs Byte) Byte

+ func (self Byte) Div(rhs Byte) Byte

+ func (self Byte) Mul(rhs Byte) Byte

+ func (self Byte) Sub(rhs Byte) Byte

+ type Char rune

+ func (self *Char) AddAssign(rhs Char)

+ func (self *Char) DivAssign(rhs Char)

+ func (self *Char) MulAssign(rhs Char)

+ func (self *Char) SubAssign(rhs Char)

+ func (self Char) Add(rhs Char) Char

+ func (self Char) Clone() Char

+ func (self Char) Cmp(rhs Char) Ordering

+ func (self Char) Debug() String

+ func (self Char) Display() String

+ func (self Char) Div(rhs Char) Char

+ func (self Char) Eq(rhs Char) Bool

+ func (self Char) Mul(rhs Char) Char

+ func (self Char) Sub(rhs Char) Char

+ func (self Char) ToString() String

type Complex128

+ func (self *Complex128) AddAssign(rhs Complex128)

+ func (self *Complex128) DivAssign(rhs Complex128)

+ func (self *Complex128) MulAssign(rhs Complex128)

+ func (self *Complex128) SubAssign(rhs Complex128)

+ func (self Complex128) Add(rhs Complex128) Complex128

+ func (self Complex128) Div(rhs Complex128) Complex128

+ func (self Complex128) Mul(rhs Complex128) Complex128

+ func (self Complex128) Sub(rhs Complex128) Complex128

type Complex64

+ func (self *Complex64) AddAssign(rhs Complex64)

+ func (self *Complex64) DivAssign(rhs Complex64)

+ func (self *Complex64) MulAssign(rhs Complex64)

+ func (self *Complex64) SubAssign(rhs Complex64)

+ func (self Complex64) Add(rhs Complex64) Complex64

+ func (self Complex64) Div(rhs Complex64) Complex64

+ func (self Complex64) Mul(rhs Complex64) Complex64

+ func (self Complex64) Sub(rhs Complex64) Complex64

+ type F32 float32

+ func (self *F32) AddAssign(rhs F32)

+ func (self *F32) DivAssign(rhs F32)

+ func (self *F32) MulAssign(rhs F32)

+ func (self *F32) SubAssign(rhs F32)

+ func (self F32) Add(rhs F32) F32

+ func (self F32) Clone() F32

+ func (self F32) Cmp(rhs F32) Ordering

+ func (self F32) Debug() String

+ func (self F32) Display() String

+ func (self F32) Div(rhs F32) F32

+ func (self F32) Eq(rhs F32) Bool

+ func (self F32) Mul(rhs F32) F32

+ func (self F32) Sub(rhs F32) F32

+ func (self F32) ToString() String

+ type F64 float64

+ func (self *F64) AddAssign(rhs F64)

+ func (self *F64) DivAssign(rhs F64)

+ func (self *F64) MulAssign(rhs F64)

+ func (self *F64) SubAssign(rhs F64)

+ func (self F64) Add(rhs F64) F64

+ func (self F64) Clone() F64

+ func (self F64) Cmp(rhs F64) Ordering

+ func (self F64) Debug() String

+ func (self F64) Display() String

+ func (self F64) Div(rhs F64) F64

+ func (self F64) Eq(rhs F64) Bool

+ func (self F64) Mul(rhs F64) F64

+ func (self F64) Sub(rhs F64) F64

+ func (self F64) ToString() String

type HashMapIter

+ func (self HashMapIter[K, V]) CollectToLinkedList() LinkedList[Pair[K, V]]

type HashMapKeys

+ func (self HashMapKeys[K]) CollectToLinkedList() LinkedList[K]

type HashMapValues

+ func (self HashMapValues[V]) CollectToLinkedList() LinkedList[V]

+ type I16 int16

+ func (self *I16) AddAssign(rhs I16)

+ func (self *I16) DivAssign(rhs I16)

+ func (self *I16) MulAssign(rhs I16)

+ func (self *I16) SubAssign(rhs I16)

+ func (self I16) Add(rhs I16) I16

+ func (self I16) Clone() I16

+ func (self I16) Cmp(rhs I16) Ordering

+ func (self I16) Debug() String

+ func (self I16) Display() String

+ func (self I16) Div(rhs I16) I16

+ func (self I16) Eq(rhs I16) Bool

+ func (self I16) Mul(rhs I16) I16

+ func (self I16) Sub(rhs I16) I16

+ func (self I16) ToString() String

+ type I32 int32

+ func (self *I32) AddAssign(rhs I32)

+ func (self *I32) DivAssign(rhs I32)

+ func (self *I32) MulAssign(rhs I32)

+ func (self *I32) SubAssign(rhs I32)

+ func (self I32) Add(rhs I32) I32

+ func (self I32) Clone() I32

+ func (self I32) Cmp(rhs I32) Ordering

+ func (self I32) Debug() String

+ func (self I32) Display() String

+ func (self I32) Div(rhs I32) I32

+ func (self I32) Eq(rhs I32) Bool

+ func (self I32) Mul(rhs I32) I32

+ func (self I32) Sub(rhs I32) I32

+ func (self I32) ToString() String

+ type I64 int64

+ func (self *I64) AddAssign(rhs I64)

+ func (self *I64) DivAssign(rhs I64)

+ func (self *I64) MulAssign(rhs I64)

+ func (self *I64) SubAssign(rhs I64)

+ func (self I64) Add(rhs I64) I64

+ func (self I64) Clone() I64

+ func (self I64) Cmp(rhs I64) Ordering

+ func (self I64) Debug() String

+ func (self I64) Display() String

+ func (self I64) Div(rhs I64) I64

+ func (self I64) Eq(rhs I64) Bool

+ func (self I64) Mul(rhs I64) I64

+ func (self I64) Sub(rhs I64) I64

+ func (self I64) ToString() String

+ type I8 int8

+ func (self *I8) AddAssign(rhs I8)

+ func (self *I8) DivAssign(rhs I8)

+ func (self *I8) MulAssign(rhs I8)

+ func (self *I8) SubAssign(rhs I8)

+ func (self I8) Add(rhs I8) I8

+ func (self I8) Clone() I8

+ func (self I8) Cmp(rhs I8) Ordering

+ func (self I8) Debug() String

+ func (self I8) Display() String

+ func (self I8) Div(rhs I8) I8

+ func (self I8) Eq(rhs I8) Bool

+ func (self I8) Mul(rhs I8) I8

+ func (self I8) Sub(rhs I8) I8

+ func (self I8) ToString() String

+ type ISize int

+ func (self *ISize) AddAssign(rhs ISize)

+ func (self *ISize) DivAssign(rhs ISize)

+ func (self *ISize) MulAssign(rhs ISize)

+ func (self *ISize) SubAssign(rhs ISize)

+ func (self ISize) Add(rhs ISize) ISize

+ func (self ISize) Clone() ISize

+ func (self ISize) Cmp(rhs ISize) Ordering

+ func (self ISize) Debug() String

+ func (self ISize) Display() String

+ func (self ISize) Div(rhs ISize) ISize

+ func (self ISize) Eq(rhs ISize) Bool

+ func (self ISize) Mul(rhs ISize) ISize

+ func (self ISize) Sub(rhs ISize) ISize

+ func (self ISize) ToString() String

type Iterator

+ CollectToLinkedList func() LinkedList[T]

type LinkedListIter

+ func (self LinkedListIter[T]) CollectToLinkedList() LinkedList[T]

type String

+ func (self *String) AddAssign(rhs String)

+ func (self String) Add(rhs String) String

+ type U16 uint16

+ func (self *U16) AddAssign(rhs U16)

+ func (self *U16) DivAssign(rhs U16)

+ func (self *U16) MulAssign(rhs U16)

+ func (self *U16) SubAssign(rhs U16)

+ func (self U16) Add(rhs U16) U16

+ func (self U16) Clone() U16

+ func (self U16) Cmp(rhs U16) Ordering

+ func (self U16) Debug() String

+ func (self U16) Display() String

+ func (self U16) Div(rhs U16) U16

+ func (self U16) Eq(rhs U16) Bool

+ func (self U16) Mul(rhs U16) U16

+ func (self U16) Sub(rhs U16) U16

+ func (self U16) ToString() String

+ type U32 uint32

+ func (self *U32) AddAssign(rhs U32)

+ func (self *U32) DivAssign(rhs U32)

+ func (self *U32) MulAssign(rhs U32)

+ func (self *U32) SubAssign(rhs U32)

+ func (self U32) Add(rhs U32) U32

+ func (self U32) Clone() U32

+ func (self U32) Cmp(rhs U32) Ordering

+ func (self U32) Debug() String

+ func (self U32) Display() String

+ func (self U32) Div(rhs U32) U32

+ func (self U32) Eq(rhs U32) Bool

+ func (self U32) Mul(rhs U32) U32

+ func (self U32) Sub(rhs U32) U32

+ func (self U32) ToString() String

+ type U64 uint64

+ func (self *U64) AddAssign(rhs U64)

+ func (self *U64) DivAssign(rhs U64)

+ func (self *U64) MulAssign(rhs U64)

+ func (self *U64) SubAssign(rhs U64)

+ func (self U64) Add(rhs U64) U64

+ func (self U64) Clone() U64

+ func (self U64) Cmp(rhs U64) Ordering

+ func (self U64) Debug() String

+ func (self U64) Display() String

+ func (self U64) Div(rhs U64) U64

+ func (self U64) Eq(rhs U64) Bool

+ func (self U64) Mul(rhs U64) U64

+ func (self U64) Sub(rhs U64) U64

+ func (self U64) ToString() String

+ type U8 uint8

+ func (self *U8) AddAssign(rhs U8)

+ func (self *U8) DivAssign(rhs U8)

+ func (self *U8) MulAssign(rhs U8)

+ func (self *U8) SubAssign(rhs U8)

+ func (self U8) Add(rhs U8) U8

+ func (self U8) Clone() U8

+ func (self U8) Cmp(rhs U8) Ordering

+ func (self U8) Debug() String

+ func (self U8) Display() String

+ func (self U8) Div(rhs U8) U8

+ func (self U8) Eq(rhs U8) Bool

+ func (self U8) Mul(rhs U8) U8

+ func (self U8) Sub(rhs U8) U8

+ func (self U8) ToString() String

+ type USize uint

+ func (self *USize) AddAssign(rhs USize)

+ func (self *USize) DivAssign(rhs USize)

+ func (self *USize) MulAssign(rhs USize)

+ func (self *USize) SubAssign(rhs USize)

+ func (self USize) Add(rhs USize) USize

+ func (self USize) Clone() USize

+ func (self USize) Cmp(rhs USize) Ordering

+ func (self USize) Debug() String

+ func (self USize) Display() String

+ func (self USize) Div(rhs USize) USize

+ func (self USize) Eq(rhs USize) Bool

+ func (self USize) Mul(rhs USize) USize

+ func (self USize) Sub(rhs USize) USize

+ func (self USize) ToString() String

type VecIter

+ func (self VecIter[T]) CollectToLinkedList() LinkedList[T]

v0.5.0

Oct 3, 2023

Changes in this version

+ type LinkedList struct

+ func LinkedListNew() LinkedList[T]

+ func (list *LinkedList[T]) Append(other *LinkedList[T])

+ func (list *LinkedList[T]) Back() Option[*T]

+ func (list *LinkedList[T]) Clear()

+ func (list *LinkedList[T]) Front() Option[*T]

+ func (list *LinkedList[T]) IntoIter() Iterator[T]

+ func (list *LinkedList[T]) PopBack() Option[T]

+ func (list *LinkedList[T]) PopFront() Option[T]

+ func (list *LinkedList[T]) PushBack(value T)

+ func (list *LinkedList[T]) PushFront(value T)

+ func (list LinkedList[T]) IsEmpty() Bool

+ func (list LinkedList[T]) Len() Int

+ func (self LinkedList[T]) Debug() String

+ func (self LinkedList[T]) Display() String

+ type LinkedListIter struct

+ func (self *LinkedListIter[T]) Next() Option[T]

+ func (self LinkedListIter[T]) CollectToVec() Vec[T]

+ func (self LinkedListIter[T]) Filter(f func(T) Bool) Iterator[T]

+ func (self LinkedListIter[T]) Fold(init T, f func(T, T) T) T

+ func (self LinkedListIter[T]) Map(f func(T) T) Iterator[T]

+ func (self LinkedListIter[T]) Rev() Iterator[T]

+ type LinkedListNode struct

v0.4.0

Sep 19, 2023

Changes in this version

+ func Print(format String, params ...any)

+ func Println(format String, params ...any)

+ type Add interface

+ Add func(rhs T) T

+ type AddAssign interface

+ AddAssign func(rhs T)

+ type Any interface

+ type Bool bool

+ func (self Bool) Clone() Bool

+ func (self Bool) Cmp(rhs Bool) Ordering

+ func (self Bool) Debug() String

+ func (self Bool) Display() String

+ func (self Bool) Eq(rhs Bool) Bool

+ func (self Bool) ToString() String

+ type Byte byte

+ func (self Byte) Clone() Byte

+ func (self Byte) Cmp(rhs Byte) Ordering

+ func (self Byte) Debug() String

+ func (self Byte) Display() String

+ func (self Byte) Eq(rhs Byte) Bool

+ func (self Byte) ToString() String

+ type Clone interface

+ Clone func() T

+ type Complex128 complex128

+ func (self Complex128) Clone() Complex128

+ func (self Complex128) Debug() String

+ func (self Complex128) Display() String

+ func (self Complex128) ToString() String

+ type Complex64 complex64

+ func (self Complex64) Clone() Complex64

+ func (self Complex64) Debug() String

+ func (self Complex64) Display() String

+ func (self Complex64) ToString() String

+ type Debug interface

+ Debug func() string

+ type Default interface

+ Default func() T

+ type DirEntry struct

+ FileName String

+ FileType FileType

+ Path String

+ type Display interface

+ Display func() String

+ type Div interface

+ Div func(rhs T) T

+ type DivAssign interface

+ DivAssign func(rhs T)

+ type Eq interface

+ Eq func(rhs T) Bool

+ type Error error

+ type FileType struct

+ func (self FileType) IsDir() bool

+ func (self FileType) IsFile() bool

+ func (self FileType) IsSymlink() bool

+ type Float32 float32

+ func (self Float32) Clone() Float32

+ func (self Float32) Cmp(rhs Float32) Ordering

+ func (self Float32) Debug() String

+ func (self Float32) Display() String

+ func (self Float32) Eq(rhs Float32) Bool

+ func (self Float32) ToString() String

+ type Float64 float64

+ func (self Float64) Clone() Float64

+ func (self Float64) Cmp(rhs Float64) Ordering

+ func (self Float64) Debug() String

+ func (self Float64) Display() String

+ func (self Float64) Eq(rhs Float64) Bool

+ func (self Float64) ToString() String

+ type HashMap struct

+ func HashMapNew() HashMap[K, V]

+ func HashMapWithCapacity(capacity Int) HashMap[K, V]

+ func (self *HashMap[K, V]) Clear()

+ func (self *HashMap[K, V]) Insert(key K, value V) Option[V]

+ func (self *HashMap[K, V]) Remove(key K) Option[V]

+ func (self HashMap[K, V]) AsMap() map[K]V

+ func (self HashMap[K, V]) ContainsKey(key K) Bool

+ func (self HashMap[K, V]) Debug() String

+ func (self HashMap[K, V]) Display() String

+ func (self HashMap[K, V]) Get(key K) Option[V]

+ func (self HashMap[K, V]) IntoIter() Iterator[Pair[K, V]]

+ func (self HashMap[K, V]) IsEmpty() Bool

+ func (self HashMap[K, V]) Keys() Iterator[K]

+ func (self HashMap[K, V]) Len() Int

+ func (self HashMap[K, V]) Values() Iterator[V]

+ type HashMapIter struct

+ func (self *HashMapIter[K, V]) Next() Option[Pair[K, V]]

+ func (self HashMapIter[K, V]) CollectToVec() Vec[Pair[K, V]]

+ func (self HashMapIter[K, V]) Filter(f func(Pair[K, V]) Bool) Iterator[Pair[K, V]]

+ func (self HashMapIter[K, V]) Fold(init Pair[K, V], f func(Pair[K, V], Pair[K, V]) Pair[K, V]) Pair[K, V]

+ func (self HashMapIter[K, V]) Map(f func(Pair[K, V]) Pair[K, V]) Iterator[Pair[K, V]]

+ func (self HashMapIter[K, V]) Rev() Iterator[Pair[K, V]]

+ type HashMapKeys struct

+ func (self *HashMapKeys[K]) Next() Option[K]

+ func (self HashMapKeys[K]) CollectToVec() Vec[K]

+ func (self HashMapKeys[K]) Filter(f func(K) Bool) Iterator[K]

+ func (self HashMapKeys[K]) Fold(init K, f func(K, K) K) K

+ func (self HashMapKeys[K]) Map(f func(K) K) Iterator[K]

+ func (self HashMapKeys[K]) Rev() Iterator[K]

+ type HashMapValues struct

+ func (self *HashMapValues[V]) Next() Option[V]

+ func (self HashMapValues[V]) CollectToVec() Vec[V]

+ func (self HashMapValues[V]) Filter(f func(V) Bool) Iterator[V]

+ func (self HashMapValues[V]) Fold(init V, f func(V, V) V) V

+ func (self HashMapValues[V]) Map(f func(V) V) Iterator[V]

+ func (self HashMapValues[V]) Rev() Iterator[V]

+ type Int int

+ func (self Int) Clone() Int

+ func (self Int) Cmp(rhs Int) Ordering

+ func (self Int) Debug() String

+ func (self Int) Display() String

+ func (self Int) Eq(rhs Int) Bool

+ func (self Int) ToString() String

+ type Int16 int16

+ func (self Int16) Clone() Int16

+ func (self Int16) Cmp(rhs Int16) Ordering

+ func (self Int16) Debug() String

+ func (self Int16) Display() String

+ func (self Int16) Eq(rhs Int16) Bool

+ func (self Int16) ToString() String

+ type Int32 int32

+ func (self Int32) Clone() Int32

+ func (self Int32) Cmp(rhs Int32) Ordering

+ func (self Int32) Debug() String

+ func (self Int32) Display() String

+ func (self Int32) Eq(rhs Int32) Bool

+ func (self Int32) ToString() String

+ type Int64 int64

+ func (self Int64) Clone() Int64

+ func (self Int64) Cmp(rhs Int64) Ordering

+ func (self Int64) Debug() String

+ func (self Int64) Display() String

+ func (self Int64) Eq(rhs Int64) Bool

+ func (self Int64) ToString() String

+ type Int8 int8

+ func (self Int8) Clone() Int8

+ func (self Int8) Cmp(rhs Int8) Ordering

+ func (self Int8) Debug() String

+ func (self Int8) Display() String

+ func (self Int8) Eq(rhs Int8) Bool

+ func (self Int8) ToString() String

+ type IntoIterator interface

+ IntoIter func() Iterator[T]

+ type Iterator interface

+ CollectToVec func() Vec[T]

+ Filter func(f func(T) Bool) Iterator[T]

+ Fold func(init T, f func(T, T) T) T

+ Map func(f func(T) T) Iterator[T]

+ Next func() Option[T]

+ Rev func() Iterator[T]

+ type Mul interface

+ Mul func(rhs T) T

+ type MulAssign interface

+ MulAssign func(rhs T)

+ type Option struct

+ func None() Option[T]

+ func Some(value T) Option[T]

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

+ func (self *Option[T]) GetOrInsertWith(f func() T) *T

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

+ func (self *Option[T]) IsNone() Bool

+ func (self *Option[T]) IsSome() Bool

+ func (self *Option[T]) IsSomeAnd(f func(T) Bool) Bool

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

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

+ func (self Option[T]) And(optb Option[any]) Option[any]

+ func (self Option[T]) AndThen(f func(T) Option[any]) Option[any]

+ func (self Option[T]) Debug() String

+ func (self Option[T]) Display() String

+ func (self Option[T]) Expect(message string) T

+ func (self Option[T]) Filter(predicate func(T) Bool) Option[T]

+ func (self Option[T]) Map(f func(T) T) Option[T]

+ func (self Option[T]) MapOr(defaultValue T, f func(T) T) T

+ func (self Option[T]) MapOrElse(defaultValue func() T, f func(T) T) T

+ func (self Option[T]) Or(optb Option[T]) Option[T]

+ func (self Option[T]) OrElse(f func() Option[T]) Option[T]

+ func (self Option[T]) Unwrap() T

+ func (self Option[T]) UnwrapOr(value T) T

+ func (self Option[T]) UnwrapOrElse(f func() T) T

+ func (self Option[T]) Xor(optb Option[T]) Option[T]

+ type Ord interface

+ Cmp func(rhs T) Ordering

+ type Ordering int

+ const OrderingEqual

+ const OrderingGreater

+ const OrderingLess

+ type Pair struct

+ Key K

+ Value V

+ type Result struct

+ func Copy(from String, to String) Result[any]

+ func CreateDir(path String) Result[any]

+ func Err(err error) Result[T]

+ func Ok(value T) Result[T]

+ func Read(path String) Result[[]Byte]

+ func ReadDir(path String) Result[Vec[DirEntry]]

+ func ReadToString(path String) Result[String]

+ func RemoveDir(path String) Result[any]

+ func RemoveFile(path String) Result[any]

+ func Rename(from String, to String) Result[any]

+ func Write(path String, data []Byte) Result[any]

+ func (self Result[T]) And(res Result[T]) Result[T]

+ func (self Result[T]) AndThen(op func(T) Result[T]) Result[T]

+ func (self Result[T]) Debug() String

+ func (self Result[T]) Display() String

+ func (self Result[T]) Err() Option[error]

+ func (self Result[T]) Expect(message string) T

+ func (self Result[T]) ExpectErr(message string) error

+ func (self Result[T]) IsErr() Bool

+ func (self Result[T]) IsErrAnd(predicate func(error) Bool) Bool

+ func (self Result[T]) IsOk() Bool

+ func (self Result[T]) IsOkAnd(predicate func(T) Bool) Bool

+ func (self Result[T]) Map(f func(T) T) Result[T]

+ func (self Result[T]) MapErr(f func(error) error) Result[T]

+ func (self Result[T]) MapOr(defaultValue T, f func(T) T) T

+ func (self Result[T]) MapOrElse(defaultValue func() T, f func(T) T) T

+ func (self Result[T]) Ok() Option[T]

+ func (self Result[T]) Or(res Result[T]) Result[T]

+ func (self Result[T]) OrElse(op func(error) Result[T]) Result[T]

+ func (self Result[T]) Unwrap() T

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

+ func (self Result[T]) UnwrapOr(defaultValue T) T

+ func (self Result[T]) UnwrapOrElse(f func() T) T

+ type Rune rune

+ func (self Rune) Clone() Rune

+ func (self Rune) Cmp(rhs Rune) Ordering

+ func (self Rune) Debug() String

+ func (self Rune) Display() String

+ func (self Rune) Eq(rhs Rune) Bool

+ func (self Rune) ToString() String

+ type Stdin struct

+ func (self *Stdin) Lock() *sync.Mutex

+ func (self *Stdin) ReadLine(buffer *String)

+ type String string

+ func Format(format String, params ...any) String

+ func (self String) Clone() String

+ func (self String) Cmp(rhs String) Ordering

+ func (self String) Debug() String

+ func (self String) Display() String

+ func (self String) Eq(rhs String) Bool

+ func (self String) ToString() String

+ type Sub interface

+ Sub func(rhs T) T

+ type SubAssign interface

+ SubAssign func(rhs T)

+ type ToString interface

+ ToString func() String

+ type Uint uint

+ func (self Uint) Clone() Uint

+ func (self Uint) Cmp(rhs Uint) Ordering

+ func (self Uint) Debug() String

+ func (self Uint) Display() String

+ func (self Uint) Eq(rhs Uint) Bool

+ func (self Uint) ToString() String

+ type Uint16 uint16

+ func (self Uint16) Clone() Uint16

+ func (self Uint16) Cmp(rhs Uint16) Ordering

+ func (self Uint16) Debug() String

+ func (self Uint16) Display() String

+ func (self Uint16) Eq(rhs Uint16) Bool

+ func (self Uint16) ToString() String

+ type Uint32 uint32

+ func (self Uint32) Clone() Uint32

+ func (self Uint32) Cmp(rhs Uint32) Ordering

+ func (self Uint32) Debug() String

+ func (self Uint32) Display() String

+ func (self Uint32) Eq(rhs Uint32) Bool

+ func (self Uint32) ToString() String

+ type Uint64 uint64

+ func (self Uint64) Clone() Uint64

+ func (self Uint64) Cmp(rhs Uint64) Ordering

+ func (self Uint64) Debug() String

+ func (self Uint64) Display() String

+ func (self Uint64) Eq(rhs Uint64) Bool

+ func (self Uint64) ToString() String

+ type Uint8 uint8

+ func (self Uint8) Clone() Uint8

+ func (self Uint8) Cmp(rhs Uint8) Ordering

+ func (self Uint8) Debug() String

+ func (self Uint8) Display() String

+ func (self Uint8) Eq(rhs Uint8) Bool

+ func (self Uint8) ToString() String

+ type Vec struct

+ func VecNew() Vec[T]

+ func VecWithCapacity(capacity Int) Vec[T]

+ func VecWithLen(len Int) Vec[T]

+ func (self *Vec[T]) Append(other *Vec[T])

+ func (self *Vec[T]) Clear()

+ func (self *Vec[T]) Dedup()

+ func (self *Vec[T]) DedupByKey(key func(T) any)

+ func (self *Vec[T]) Fill(value T)

+ func (self *Vec[T]) FillWith(f func() T)

+ func (self *Vec[T]) Insert(index Int, value T)

+ func (self *Vec[T]) Pop() Option[T]

+ func (self *Vec[T]) Push(value T)

+ func (self *Vec[T]) Reserve(additional Int)

+ func (self *Vec[T]) Retain(predicate func(T) Bool)

+ func (self *Vec[T]) Reverse()

+ func (self *Vec[T]) Sort()

+ func (self *Vec[T]) SortBy(compare func(T, T) Ordering)

+ func (self *Vec[T]) SortUnstable()

+ func (self *Vec[T]) SortUnstableBy(compare func(T, T) Ordering)

+ func (self *Vec[T]) Swap(a, b Int)

+ func (self Vec[T]) AsSlice() []T

+ func (self Vec[T]) BinarySearch(value T) Option[Int]

+ func (self Vec[T]) BinarySearchBy(f func(T) Ordering) Option[Int]

+ func (self Vec[T]) Capacity() Int

+ func (self Vec[T]) Contains(value T) Bool

+ func (self Vec[T]) Debug() String

+ func (self Vec[T]) Display() String

+ func (self Vec[T]) Get(index Int) Option[T]

+ func (self Vec[T]) GetUnchecked(index Int) T

+ func (self Vec[T]) IntoIter() Iterator[T]

+ func (self Vec[T]) IsEmpty() Bool

+ func (self Vec[T]) Len() Int

+ type VecIter struct

+ func (self *VecIter[T]) Next() Option[T]

+ func (self VecIter[T]) CollectToVec() Vec[T]

+ func (self VecIter[T]) Filter(f func(T) Bool) Iterator[T]

+ func (self VecIter[T]) Fold(init T, f func(T, T) T) T

+ func (self VecIter[T]) Map(f func(T) T) Iterator[T]

+ func (self VecIter[T]) Rev() Iterator[T]

v0.3.0

Sep 18, 2023

v0.2.1

Sep 17, 2023

v0.2.0

Sep 16, 2023

v0.1.0

Sep 15, 2023

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