ds

Apr 25, 2024

Changes in this version

+ func MapGetDefault[K comparable, V any](m map[K]V, k K, d V) V

+ func MapOPMergeWithFn[K comparable, V any](m1 map[K]V, m2 map[K]V, fn func(k K) V) map[K]V

+ func MapOpSetIfEmpty[K comparable, V any](m map[K]V, k K, v V) (V, bool)

Apr 19, 2024

Changes in this version

+ func BuildOrderTuples[K ttypes.Ordered, V any](m map[K]V) []*ttypes.OrderTuple[K, V]

+ func DListIterAllOk[T any](a DList[T], iterate func(a DList[T], node T) bool) bool

+ func DListIter[T any](a DList[T], iterate func(a DList[T], node T))

+ func DListPartition[T any](a DList[T], iterate func(a DList[T], node T) bool) (DList[T], DList[T])

+ func LowerBoundFunc[T any](a []T, value T, less ttypes.LessFn[T]) int

+ func LowerBound[T ttypes.Ordered](a []T, value T) int

+ func SListIterAllOk[T any](a SList[T], iterate func(a SList[T], node T) bool) bool

+ func SListIter[T any](a SList[T], iterate func(a SList[T], node T))

+ func SListPartition[T any](a SList[T], iterate func(a SList[T], node T) bool) (SList[T], SList[T])

+ func UpperBoundFunc[T any](a []T, value T, less ttypes.LessFn[T]) int

+ func UpperBound[T ttypes.Ordered](a []T, value T) int

type DList

+ func DListIterFilter[T any](a DList[T], iterate func(a DList[T], node T) bool) DList[T]

+ func DListIterMapCopy[T any](a DList[T], iterate func(a DList[T], node T) T) DList[T]

+ func DListIterMapInPlace[T any](a DList[T], iterate func(a DList[T], node T) T) DList[T]

+ func (l *DList[T]) InsertLessBound(v T, fn ttypes.LessEqFn[T])

+ func (l *DList[T]) RemoveValue(v T, fn ttypes.CompareFn[T]) bool

+ type OrderSet struct

+ func NewOrderSet[K ttypes.Ordered]() *OrderSet[K]

+ func OrderSetFromSet[K ttypes.Ordered](set BuiltinSet[K]) *OrderSet[K]

+ func OrderSetFromUnpack[K ttypes.Ordered](ks ...K) *OrderSet[K]

+ func (o *OrderSet[K]) Clear()

+ func (o *OrderSet[K]) Delete(k K)

+ func (o *OrderSet[K]) DeleteN(ks ...K)

+ func (o *OrderSet[K]) Difference(other *OrderSet[K]) *OrderSet[K]

+ func (o *OrderSet[K]) Equal(other *OrderSet[K]) bool

+ func (o *OrderSet[K]) ForEach(cb func(k K))

+ func (o *OrderSet[K]) ForEachIf(cb func(k K) bool)

+ func (o *OrderSet[K]) Has(k K) bool

+ func (o *OrderSet[K]) Insert(k K) bool

+ func (o *OrderSet[K]) InsertN(ks ...K) int

+ func (o *OrderSet[K]) Intersection(other *OrderSet[K]) *OrderSet[K]

+ func (o *OrderSet[K]) IsDisjointOf(other *OrderSet[K]) bool

+ func (o *OrderSet[K]) IsEmpty() bool

+ func (o *OrderSet[K]) IsSubsetOf(other *OrderSet[K]) bool

+ func (o *OrderSet[K]) IsSupersetOf(other *OrderSet[K]) bool

+ func (o *OrderSet[K]) Keys() *SList[K]

+ func (o *OrderSet[K]) Len() int

+ func (o *OrderSet[K]) Remove(k K) bool

+ func (o *OrderSet[K]) RemoveN(ks ...K) int

+ func (o *OrderSet[K]) String() string

+ func (o *OrderSet[K]) Union(other *OrderSet[K]) *OrderSet[K]

+ func (o *OrderSet[K]) Update(other *OrderSet[K])

type SList

+ func SListIterFilter[T any](a SList[T], iterate func(a SList[T], node T) bool) SList[T]

+ func SListIterMapCopy[T any](a SList[T], iterate func(a SList[T], node T) T) SList[T]

+ func SListIterMapInPlace[T any](a SList[T], iterate func(a SList[T], node T) T) SList[T]

+ func (l *SList[T]) InsertLessBound(v T, fn ttypes.LessEqFn[T])

+ func (l *SList[T]) PopTail() T

+ func (l *SList[T]) RemoveValue(v T, fn ttypes.CompareFn[T]) bool

type TupleName

+ func (tn *TupleName) Names() []string

Apr 17, 2024

Changes in this version

+ func SetToMap[K comparable, V any](u BuiltinSet[K], fn func(K) V) map[K]V

type BuiltinSet

+ func SetFromDList[K comparable](list DList[K]) BuiltinSet[K]

+ func SetFromMapKey[K comparable, V any](ks map[K]V) BuiltinSet[K]

+ func SetFromMapValue[K comparable, V comparable](ks map[K]V) BuiltinSet[V]

+ func SetFromSList[K comparable](list SList[K]) BuiltinSet[K]

+ func SetFromUnpack[K comparable](ks ...K) BuiltinSet[K]

+ func (s BuiltinSet[K]) DeleteN(ks ...K)

type DList

+ func DListFromUnpack[T any](vs ...T) DList[T]

+ func NewDList[T any]() DList[T]

+ func SetToDList[K comparable](u BuiltinSet[K]) DList[K]

+ func (l *DList[T]) Values() []T

type SList

+ func NewSList[T any]() SList[T]

+ func SListFromUnpack[T any](values ...T) SList[T]

+ func SetToSList[K comparable](u BuiltinSet[K]) SList[K]

Mar 22, 2024

Changes in this version

+ func SliceIncludeWithFnV2[T comparable](a []T, fn func(int) bool) bool

+ func SliceIterAllOkV2[T any](a []T, iterate func(i int) bool) bool

Mar 22, 2024

Changes in this version

+ func SliceIterFilterV2[T any](a []T, iterate func(i int) bool) []T

Mar 22, 2024

Changes in this version

+ func SliceIterV2[T any](a []T, iterate func(i int))

Mar 22, 2024

Changes in this version

+ func SliceGetOne[T any](data []T) (T, error)

+ func SliceGetOnlyOne[T any](data []T) (T, error)

Mar 13, 2024

Changes in this version

+ func SliceOpJoinToString[T any](data []T, seps ...string) (string, error)

Mar 6, 2024

Changes in this version

+ func PartQuickSort[T ttypes.Ordered](data []T, k int, max bool) []T

+ func SliceGroupToPartitions[T any](data []T, step int) [][]T

+ func SliceGroupToSlice[T any, V any](data []T, handler func(int) (V, bool)) []V

Dec 17, 2023

Changes in this version

+ func SliceOpCopy[T any](first []T, second []*T)

Dec 3, 2023

Changes in this version

+ func SliceSetNthTail[T any](data []T, nth int, d T)

+ func SliceSetTail[T any](data []T, d T)

Nov 7, 2023

Changes in this version

+ func MapOpCopy(m map[K]V) map[K]V

+ func MapOpDeepCopy(m map[K]V) map[K]V

+ func MapOpPop(m map[K]V, k K) (V, bool)

type BuiltinSet

+ func MapConvertValueToSet(a map[T]V) BuiltinSet[V]

+ type Interface interface

+ DeepCopy func() interface{}

Oct 18, 2023

Changes in this version

+ func MapOpRemoveValue(m map[K]V, dv V) map[K]V

+ func MapOpRemoveValueInSlice(m map[K][]V, dv V, del bool) map[K][]V

+ func SliceGroupUniqueByHandler(data []V, getKeyHandler func(int) K) map[K]V

Oct 16, 2023

Changes in this version

+ func SliceGetNthTail(data []T, nth int, d ...T) T

Sep 13, 2023

Changes in this version

+ func StrHasContainInsensitive(str string, subStr string) bool

Aug 28, 2023

Changes in this version

+ func SliceOpJoin(data []T, seps ...string) (string, error)

Aug 12, 2023

Changes in this version

+ func StrReverse(s string) string

+ type NamedTuple2E struct

+ E1 A

+ E2 B

+ func NewNamedTuple2E(na string, a A, nb string, b B) *NamedTuple2E[A, B]

+ func (nt *NamedTuple2E[A, B]) Get(name string) interface{}

+ func (nt *NamedTuple2E[A, B]) Unpack() (A, B)

+ type NamedTuple3E struct

+ E3 C

+ func NewNamedTuple3E(na string, a A, nb string, b B, nc string, c C) *NamedTuple3E[A, B, C]

+ func (nt *NamedTuple3E[A, B, C]) Get(name string) interface{}

+ func (nt *NamedTuple3E[A, B, C]) Unpack() (A, B, C)

+ type NamedTuple4E struct

+ E4 D

+ func NewNamedTuple4E(na string, a A, nb string, b B, nc string, c C, nd string, d D) *NamedTuple4E[A, B, C, D]

+ func (nt *NamedTuple4E[A, B, C, D]) Get(name string) interface{}

+ func (nt *NamedTuple4E[A, B, C, D]) Unpack() (A, B, C, D)

+ type NamedTuple5E struct

+ E5 E

+ func NewNamedTuple5E(na string, a A, nb string, b B, nc string, c C, nd string, d D, ne string, e E) *NamedTuple5E[A, B, C, D, E]

+ func (nt *NamedTuple5E[A, B, C, D, E]) Get(name string) interface{}

+ func (nt *NamedTuple5E[A, B, C, D, E]) Unpack() (A, B, C, D, E)

+ type TupleName struct

+ func (tn *TupleName) Index(name string) int

+ func (tn *TupleName) Name(index int) string

+ func (tn *TupleName) Set(name string, index int)

Aug 3, 2023

Changes in this version

+ func SliceGroupToTwoMap(data []V, groupT func(*V) T, groupK func(*V) K) map[T]map[K][]V

Jul 27, 2023

Changes in this version

+ func MapOpAppendValue(m map[K][]V, k K, v V) map[K][]V

Jul 24, 2023

Changes in this version

+ func SliceIncludeWithFn(a []T, fn func([]T, int) bool) bool

Jul 10, 2023

Changes in this version

+ func SliceGroupByHandlerUnique(data []V, getKeyHandler func(int) K) map[K]V

Jun 26, 2023

Changes in this version

+ func SliceOpMerge(first []T, second []T) []T

type BuiltinSet

+ func MapConvertKeyToSet(a map[T]V) BuiltinSet[T]

+ func (s BuiltinSet[K]) Equal(other BuiltinSet[K]) bool

Jun 9, 2023

Changes in this version

+ func ListIter(a DList[T], iterate func(a DList[T], node T))

+ func ListIterAllOk(a DList[T], iterate func(a DList[T], node T) bool) bool

+ func ListPartition(a DList[T], iterate func(a DList[T], node T) bool) (DList[T], DList[T])

+ func MapConvertKeyToSlice(a map[T]V) []T

+ func MapConvertValueToSlice(a map[T]V) []V

+ func MapConvertZipSliceToMap(a []T, b []V) (map[T]V, error)

+ func MapIter(a map[K]V, iterate func(a map[K]V, k K, v V))

+ func MapIterAllOk(a map[K]V, iterate func(a map[K]V, k K, v V) bool) bool

+ func MapIterFilter(a map[K]V, iterate func(a map[K]V, k K, v V) bool) map[K]V

+ func MapIterMapKVCopy(a map[K]V, iterate func(a map[K]V, k K, v V) (K, V)) map[K]V

+ func MapIterMapKVInPlace(a map[K]V, iterate func(a map[K]V, k K, v V) V) map[K]V

+ func MapIterPartition(a map[K]V, iterate func(a map[K]V, k K, v V) bool) (map[K]V, map[K]V)

+ func MapOpMerge(m1 map[K]V, m2 map[K]V) map[K]V

+ func MapOpRemoveEmptyString(m map[K]string) map[K]string

+ func SetIter(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T))

+ func SetIterAllOk(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T) bool) bool

+ func SetPartition(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T) bool) (BuiltinSet[T], BuiltinSet[T])

+ func SliceCmpAbsEqual(a []T, b []T) bool

+ func SliceCmpAbsSub(a []T, b []T) int

+ func SliceCmpLogicEqual(a []T, b []T) bool

+ func SliceCmpLogicSub(a []T, b []T) bool

+ func SliceCmpTwoDiff(a []T, b []T) ([]T, []T)

+ func SliceGetCopy(data []T, ns ...int) []T

+ func SliceGetFilter(a []T, filter func(i int) bool) []T

+ func SliceGetTail(data []T, d ...T) T

+ func SliceGroupToCounter(data []V) map[V]int

+ func SliceGroupToMap(data []V) map[V][]V

+ func SliceGroupToSlices(data []V) [][]V

+ func SliceIncludeBinarySearch(data []T, value T) int

+ func SliceIncludeIndex(a []T, b T) int

+ func SliceIncludeIndexUnpack(a T, others ...T) int

+ func SliceIncludeUnpack(a T, others ...T) bool

+ func SliceIter(a []T, iterate func(a []T, i int))

+ func SliceIterAllOk(a []T, iterate func(a []T, i int) bool) bool

+ func SliceIterFilter(a []T, iterate func(a []T, i int) bool) []T

+ func SliceIterMapCopy(a []T, iterate func(a []T, i int) T) []T

+ func SliceIterMapInPlace(a []T, iterate func(a []T, i int) T) []T

+ func SliceIterPartition(a []T, iterate func(a []T, i int) bool) ([]T, []T)

+ func SliceMaxUnpack(data ...T) T

+ func SliceMinUnpack(data ...T) T

+ func SliceOpInsert(data *[]T, i int, x ...T)

+ func SliceOpPopBack(data *[]T) (T, bool)

+ func SliceOpRemove(data *[]T, b T)

+ func SliceOpRemoveIndex(data *[]T, i int)

+ func SliceOpRemoveMany(data *[]T, values []T)

+ func SliceOpRemoveRange(data *[]T, i int, j int)

+ func SliceOpReplace(data []T, a T, b T)

+ func SliceOpReverse(data []T)

+ func SliceOpReverseCopy(data []T) []T

+ func SliceOpShuffle(data []T)

+ func SliceOpUnique(data []T) []T

type BuiltinSet

+ func SetIterFilter(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T) bool) BuiltinSet[T]

+ func SetIterMapCopy(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T) T) BuiltinSet[T]

+ func SetIterMapInPlace(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T) T) BuiltinSet[T]

+ func SliceGroupToSet(data []V) BuiltinSet[V]

type DList

+ func ListIterFilter(a DList[T], iterate func(a DList[T], node T) bool) DList[T]

+ func ListIterMapCopy(a DList[T], iterate func(a DList[T], node T) T) DList[T]

+ func ListIterMapInPlace(a DList[T], iterate func(a DList[T], node T) T) DList[T]

type MapCompareResult

+ func MapCmpFullComplexKey(a map[T]V, b map[T]V) MapCompareResult

+ func MapCmpFullSimpleKey(a map[T]V, b map[T]V) MapCompareResult

+ func MapCmpWithComplexKey(a map[T]V, b map[T]V, key T) MapCompareResult

+ func MapCmpWithSimpleKey(a map[T]V, b map[T]V, key T) MapCompareResult

Apr 27, 2023

Changes in this version

+ func SliceRemoveMany(data *[]T, values []T)

Apr 18, 2023

Changes in this version

+ var ErrorNotFound = errors.New("not found")

+ type Bitmap struct

+ func New(size uint64) *Bitmap

+ func NewFromData(data []byte) *Bitmap

+ func (b *Bitmap) Clear()

+ func (b *Bitmap) Data() []byte

+ func (b *Bitmap) IsSet(pos uint64) bool

+ func (b *Bitmap) Resize(size uint64)

+ func (b *Bitmap) Set(pos uint64) bool

+ func (b *Bitmap) Size() uint64

+ func (b *Bitmap) Unset(pos uint64) bool

+ type DList struct

+ func (l *DList[T]) Back() T

+ func (l *DList[T]) Clear()

+ func (l *DList[T]) ForEach(cb func(val T))

+ func (l *DList[T]) ForEachIf(cb func(val T) bool)

+ func (l *DList[T]) ForEachMutable(cb func(val *T))

+ func (l *DList[T]) ForEachMutableIf(cb func(val *T) bool)

+ func (l *DList[T]) Front() T

+ func (l *DList[T]) IsEmpty() bool

+ func (l *DList[T]) Iterate() MutableIterator[T]

+ func (l *DList[T]) Len() int

+ func (l *DList[T]) PopBack() T

+ func (l *DList[T]) PopFront() T

+ func (l *DList[T]) PushBack(val T)

+ func (l *DList[T]) PushFront(val T)

+ func (l *DList[T]) TryPopBack() (T, bool)

+ func (l *DList[T]) TryPopFront() (T, bool)

+ type Element struct

+ type Node struct

+ type Option func(option *Options)

+ func WithMaxLevel(maxLevel int) Option

+ type Options struct

+ type SList struct

+ func SListOf(values ...T) SList[T]

+ func (l *SList[T]) Back() T

+ func (l *SList[T]) Clear()

+ func (l *SList[T]) ForEach(cb func(T))

+ func (l *SList[T]) ForEachIf(cb func(T) bool)

+ func (l *SList[T]) ForEachMutable(cb func(*T))

+ func (l *SList[T]) ForEachMutableIf(cb func(*T) bool)

+ func (l *SList[T]) Front() T

+ func (l *SList[T]) IsEmpty() bool

+ func (l *SList[T]) Iterate() MutableIterator[T]

+ func (l *SList[T]) Len() int

+ func (l *SList[T]) PopFront() T

+ func (l *SList[T]) PushBack(v T)

+ func (l *SList[T]) PushFront(v T)

+ func (l *SList[T]) Reverse()

+ func (l *SList[T]) Values() []T

+ type Skiplist struct

+ func NewSkipList(cmp ttypes.CompareFn[K], opts ...Option) *Skiplist[K, V]

+ func (sl *Skiplist[K, V]) Get(key K) (V, error)

+ func (sl *Skiplist[K, V]) Insert(key K, value V)

+ func (sl *Skiplist[K, V]) Keys() []K

+ func (sl *Skiplist[K, V]) Len() int

+ func (sl *Skiplist[K, V]) Remove(key K) bool

+ func (sl *Skiplist[K, V]) Traversal(visitor func(k K, v V) bool)

Mar 23, 2023

Changes in this version

+ func MapRemoveEmptyString(m map[K]interface{}) map[K]interface

Mar 23, 2023

Changes in this version

+ func MapMerge(m1 map[K]V, m2 map[K]V) map[K]V

Mar 19, 2023

Changes in this version

+ func FpEachMap(a map[K]V, iterate func(a map[K]V, k K, v V) V) map[K]V

+ func FpEachSlice(a []T, iterate func(a []T, i int) T) []T

+ func FpEveryList(a List[T], iterate func(a List[T], node T) bool) bool

+ func FpEveryMap(a map[K]V, iterate func(a map[K]V, k K, v V) bool) bool

+ func FpEverySet(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T) bool) bool

+ func FpEverySlice(a []T, iterate func(a []T, i int) bool) bool

+ func FpFilterMap(a map[K]V, iterate func(a map[K]V, k K, v V) bool) map[K]V

+ func FpFilterSlice(a []T, iterate func(a []T, i int) bool) []T

+ func FpIterList(a List[T], iterate func(a List[T], node T))

+ func FpIterMap(a map[K]V, iterate func(a map[K]V, k K, v V))

+ func FpIterSet(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T))

+ func FpIterSlice(a []T, iterate func(a []T, i int))

+ func FpMapMap(a map[K]V, iterate func(a map[K]V, k K, v V) (K, V)) map[K]V

+ func FpMapSlice(a []T, iterate func(a []T, i int) T) []T

+ func FpPartial(f func(a T1, b T2) R, arg1 T1) func(T2) R

+ func FpPartial1(f func(T1, T2) R, arg1 T1) func(T2) R

+ func FpPartial2(f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R

+ func FpPartial3(f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R

+ func FpPartial4(f func(T1, T2, T3, T4, T5) R, arg1 T1) func(T2, T3, T4, T5) R

+ func FpPartial5(f func(T1, T2, T3, T4, T5, T6) R, arg1 T1) func(T2, T3, T4, T5, T6) R

+ func FpPartitionList(a List[T], iterate func(a List[T], node T) bool) (List[T], List[T])

+ func FpPartitionMap(a map[K]V, iterate func(a map[K]V, k K, v V) bool) (map[K]V, map[K]V)

+ func FpPartitionSet(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T) bool) (BuiltinSet[T], BuiltinSet[T])

+ func FpPartitionSlice(a []T, iterate func(a []T, i int) bool) ([]T, []T)

type BuiltinSet

+ func FpEachSet(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T) T) BuiltinSet[T]

+ func FpFilterSet(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T) bool) BuiltinSet[T]

+ func FpMapSet(a BuiltinSet[T], iterate func(a BuiltinSet[T], node T) T) BuiltinSet[T]

type List

+ func FpEachList(a List[T], iterate func(a List[T], node T) T) List[T]

+ func FpFilterList(a List[T], iterate func(a List[T], node T) bool) List[T]

+ func FpMapList(a List[T], iterate func(a List[T], node T) T) List[T]

+ func NewList() List[T]

Mar 18, 2023

Changes in this version

+ func MapEqualCounter(c map[V]int, other map[V]int) bool

+ func SliceBinarySearch(data []T, value T) int

+ func SliceGroupByCounter(data []V) map[V]int

+ func SliceGroupByHandler(data []V, getKeyHandler func(int) K) map[K][]V

+ func SliceGroupByValue(data []V) map[V][]V

+ func SliceGroupIntoSlice(data []V) [][]V

+ func SliceMaxN(data []T, n int) []T

+ func SliceMaxNWithOrder(data []T, n int) []T

+ func SliceMinN(data []T, n int) []T

+ func SliceMinNWithOrder(data []T, n int) []T

+ func SliceUnpackInclude(a T, others ...T) bool

+ func SliceUnpackMax(data ...T) T

+ func SliceUnpackMin(data ...T) T

+ func StrHasPrefixInsensitive(str string, subStr string) bool

+ func StrHasSuffixInsensitive(str string, subStr string) bool

+ func StrRemoveHead(s string, n int) string

+ func StrRemoveTail(s string, n int) string

+ func StrSplitNth(str string, sep string, total int, nth int) string

type MapLocker

+ func MapNewMapLocker() *MapLocker[K, V]

type MapRWLocker

+ func MapNewMapRWLocker() *MapRWLocker[K, V]

type SortedMap

+ func MapNewSortedMap(data map[K]V, reverseOpts ...bool) SortedMap[K, V]

type Stack

+ func (s *Stack[T]) Reset()

Mar 13, 2023

Changes in this version

+ func SliceTwoDiff(a []T, b []T) ([]T, []T)

Mar 13, 2023

Changes in this version

+ func DiffTwoSlice(a []T, b []T) ([]T, []T)

Mar 11, 2023

Changes in this version

+ func Include(a T, others ...T) bool

+ type WaitFor struct

+ type WaitForPriorityQueue struct

+ func NewWaitForPriorityQueue() *WaitForPriorityQueue[T]

+ func (pq *WaitForPriorityQueue[T]) Len() int

+ func (pq *WaitForPriorityQueue[T]) Peek() *WaitFor[T]

+ func (pq *WaitForPriorityQueue[T]) Pop() *WaitFor[T]

+ func (pq *WaitForPriorityQueue[T]) Push(entry *WaitFor[T], ignore bool)

Mar 9, 2023

Changes in this version

+ func SliceIndexOrder(a []T, b T) int

+ func SliceInsert(data *[]T, i int, x ...T)

+ func SlicePopBack(data *[]T) (T, bool)

+ func SliceRemoveIndex(data *[]T, i int)

+ func SliceRemoveRange(data *[]T, i int, j int)

+ func SliceTail(data []T, d ...T) T

Mar 8, 2023

Changes in this version

+ func MapKeyToSlice(a map[T]V) []T

+ func MapValueToSlice(a map[T]V) []V

+ func MapZipSliceToMap(a []T, b []V) (map[T]V, error)

+ func MaxN(data []T, n int) []T

+ func MaxNWithOrder(data []T, n int) []T

+ func MinN(data []T, n int) []T

+ func MinNWithOrder(data []T, n int) []T

+ func SliceConvertToInt(data interface{}) ([]int, error)

+ func SliceConvertToInt64(data interface{}) ([]int64, error)

+ func SliceConvertToString(data interface{}) ([]string, error)

+ func SliceIndex(a []T, b T) int

+ func SliceRemove(data *[]T, b T)

+ func SliceReplace(data []T, a T, b T)

+ func SliceReverseCopy(data []T) []T

+ func SliceShuffle(data []T)

+ type Iterator interface

+ IsNotEnd func() bool

+ MoveToNext func()

+ Value func() T

+ type List struct

+ func ListOf(vs ...T) List[T]

+ func (l *List[T]) Back() T

+ func (l *List[T]) Clear()

+ func (l *List[T]) ForEach(cb func(val T))

+ func (l *List[T]) ForEachIf(cb func(val T) bool)

+ func (l *List[T]) ForEachMutable(cb func(val *T))

+ func (l *List[T]) ForEachMutableIf(cb func(val *T) bool)

+ func (l *List[T]) Front() T

+ func (l *List[T]) IsEmpty() bool

+ func (l *List[T]) Iterate() MutableIterator[T]

+ func (l *List[T]) Len() int

+ func (l *List[T]) PopBack() T

+ func (l *List[T]) PopFront() T

+ func (l *List[T]) PushBack(val T)

+ func (l *List[T]) PushFront(val T)

+ func (l *List[T]) TryPopBack() (T, bool)

+ func (l *List[T]) TryPopFront() (T, bool)

+ type MapCompareResult int

+ const AllKeyMiss

+ const Equal

+ const LeftKeyMiss

+ const LeftLargeThanRight

+ const LeftLessThanRight

+ const NotEqual

+ const RightKeyMiss

+ func MapComplexCompareWithKey(a map[T]V, b map[T]V, key T) MapCompareResult

+ func MapComplexFullCompare(a map[T]V, b map[T]V) MapCompareResult

+ func MapNativeCompareWithKey(a map[T]V, b map[T]V, key T) MapCompareResult

+ func MapNativeFullCompare(a map[T]V, b map[T]V) MapCompareResult

+ type MutableIterator interface

+ Pointer func() *T

+ type Queue struct

+ func NewRing() *Queue[T]

+ func (q *Queue[T]) Add(elem T)

+ func (q *Queue[T]) Get(i int) T

+ func (q *Queue[T]) Length() int

+ func (q *Queue[T]) Peek() T

+ func (q *Queue[T]) Remove() T

+ type Stack struct

+ func NewStack() *Stack[T]

+ func NewStackCap(capicity int) *Stack[T]

+ func (s *Stack[T]) Clear()

+ func (s *Stack[T]) Pop() T

+ func (s *Stack[T]) Push(t T)

+ func (s *Stack[T]) TryPop() (val T, ok bool)

+ func (s Stack[T]) Cap() int

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

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

+ func (s Stack[T]) Top() T

+ type Tuple10E struct

+ E10 J

+ func NewTuple10E(a A, b B, c C, d D, e E, f F, g G, h H, i I, j J) *Tuple10E[A, B, C, D, E, F, G, H, I, J]

+ func (t *Tuple10E[A, B, C, D, E, F, G, H, I, J]) Unpack() (A, B, C, D, E, F, G, H, I, J)

+ type Tuple2E struct

+ E1 A

+ E2 B

+ func NewTuple2E(a A, b B) *Tuple2E[A, B]

+ func (t *Tuple2E[A, B]) Unpack() (A, B)

+ type Tuple3E struct

+ E3 C

+ func NewTuple3E(a A, b B, c C) *Tuple3E[A, B, C]

+ func (t *Tuple3E[A, B, C]) Unpack() (A, B, C)

+ type Tuple4E struct

+ E4 D

+ func NewTuple4E(a A, b B, c C, d D) *Tuple4E[A, B, C, D]

+ func (t *Tuple4E[A, B, C, D]) Unpack() (A, B, C, D)

+ type Tuple5E struct

+ E5 E

+ func NewTuple5E(a A, b B, c C, d D, e E) *Tuple5E[A, B, C, D, E]

+ func (t *Tuple5E[A, B, C, D, E]) Unpack() (A, B, C, D, E)

+ type Tuple6E struct

+ E6 F

+ func NewTuple6E(a A, b B, c C, d D, e E, f F) *Tuple6E[A, B, C, D, E, F]

+ func (t *Tuple6E[A, B, C, D, E, F]) Unpack() (A, B, C, D, E, F)

+ type Tuple7E struct

+ E7 G

+ func NewTuple7E(a A, b B, c C, d D, e E, f F, g G) *Tuple7E[A, B, C, D, E, F, G]

+ func (t *Tuple7E[A, B, C, D, E, F, G]) Unpack() (A, B, C, D, E, F, G)

+ type Tuple8E struct

+ E8 H

+ func NewTuple8E(a A, b B, c C, d D, e E, f F, g G, h H) *Tuple8E[A, B, C, D, E, F, G, H]

+ func (t *Tuple8E[A, B, C, D, E, F, G, H]) Unpack() (A, B, C, D, E, F, G, H)

+ type Tuple9E struct

+ E9 I

+ func NewTuple9E(a A, b B, c C, d D, e E, f F, g G, h H, i I) *Tuple9E[A, B, C, D, E, F, G, H, I]

+ func (t *Tuple9E[A, B, C, D, E, F, G, H, I]) Unpack() (A, B, C, D, E, F, G, H, I)

Dec 16, 2022

Changes in this version

+ func BinarySearch(data []T, value T) int

+ func Max(data ...T) T

+ func Min(data ...T) T

+ func SetToSlice(u BuiltinSet[K]) []K

+ func SliceAbsoluteEqual(a []T, b []T) bool

+ func SliceCopy(data []T) []T

+ func SliceExclude(a []T, b T) bool

+ func SliceFilter(a []T, filter func(v T) bool) []T

+ func SliceInclude(a []T, b T) bool

+ func SliceLogicalEqual(a []T, b []T) bool

+ func SliceMap(a []T, handler func(v *T))

+ func SliceMax(data []T) T

+ func SliceMin(data []T) T

+ func SliceReverse(data []T)

+ func SliceUnique(data []T) []T

+ type BuiltinSet map[K]struct

+ func NewSet() BuiltinSet[K]

+ func SetFromSlice(ks []K) BuiltinSet[K]

+ func SetOf(ks ...K) BuiltinSet[K]

+ func (s BuiltinSet[K]) Clear()

+ func (s BuiltinSet[K]) Delete(k K)

+ func (s BuiltinSet[K]) Difference(other BuiltinSet[K]) BuiltinSet[K]

+ func (s BuiltinSet[K]) ForEach(cb func(k K))

+ func (s BuiltinSet[K]) ForEachIf(cb func(k K) bool)

+ func (s BuiltinSet[K]) Has(k K) bool

+ func (s BuiltinSet[K]) Insert(k K) bool

+ func (s BuiltinSet[K]) InsertN(ks ...K) int

+ func (s BuiltinSet[K]) Intersection(other BuiltinSet[K]) BuiltinSet[K]

+ func (s BuiltinSet[K]) IsDisjointOf(other BuiltinSet[K]) bool

+ func (s BuiltinSet[K]) IsEmpty() bool

+ func (s BuiltinSet[K]) IsSubsetOf(other BuiltinSet[K]) bool

+ func (s BuiltinSet[K]) IsSupersetOf(other BuiltinSet[K]) bool

+ func (s BuiltinSet[K]) Keys() []K

+ func (s BuiltinSet[K]) Len() int

+ func (s BuiltinSet[K]) Remove(k K) bool

+ func (s BuiltinSet[K]) RemoveN(ks ...K) int

+ func (s BuiltinSet[K]) String() string

+ func (s BuiltinSet[K]) Union(other BuiltinSet[K]) BuiltinSet[K]

+ func (s BuiltinSet[K]) Update(other BuiltinSet[K])

+ type CounterMap map[K]int

+ func NewCounterMap(data []K) CounterMap[K]

+ func (c CounterMap[K]) Equal(other CounterMap[K]) bool

+ type GroupMap map[K][]V

+ func NewGroupMap(data []V, getKeyHandler func(V) K) GroupMap[K, V]

+ type ListNode struct

+ Data *T

+ Next *ListNode[T]

+ Pre *ListNode[T]

+ func (list *ListNode[T]) Pop() *ListNode[T]

+ func (list *ListNode[T]) PushBack(data *ListNode[T])

+ func (list *ListNode[T]) PushFront(data *ListNode[T])

+ type MapLocker struct

+ func NewMapLocker() *MapLocker[K, V]

+ func (m *MapLocker[K, V]) Contain(key K) bool

+ func (m *MapLocker[K, V]) Foreach(handler func(key K, value V))

+ func (m *MapLocker[K, V]) Get(key K) (V, bool)

+ func (m *MapLocker[K, V]) Set(key K, value V)

+ type MapRWLocker struct

+ func NewMapRWLocker() *MapRWLocker[K, V]

+ func (m *MapRWLocker[K, V]) Contain(key K) bool

+ func (m *MapRWLocker[K, V]) Foreach(handler func(key K, value V))

+ func (m *MapRWLocker[K, V]) Get(key K) (V, bool)

+ func (m *MapRWLocker[K, V]) Set(key K, value V)

+ type SortedMap struct

+ RawMap map[K]V

+ ReverseOpt bool

+ Tuples []ttypes.Tuple[K, V]

+ func NewSortedMap(data map[K]V, reverseOpts ...bool) SortedMap[K, V]

+ func (s *SortedMap[K, V]) Rebuild()