gofn

package module

Go to main page

Versions in this module

v1

v1.11.1

Sep 19, 2024

v1.11.0

Sep 10, 2024

Changes in this version

+ func Coalesce[T comparable](args ...T) (result T)

+ func FindDuplicatesBy[T any, U comparable, S ~[]T](s S, keyFunc func(T) U) S

+ func FindDuplicates[T comparable, S ~[]T](s S) S

+ func FindUniquesBy[T any, U comparable, S ~[]T](s S, keyFunc func(T) U) S

+ func FindUniques[T comparable, S ~[]T](s S) S

+ func FirstNonEmpty[T any](args ...T) (val T)

+ func FirstOr[T any, S ~[]T](s S, defaultVal T) T

+ func First[T any, S ~[]T](s S) (T, bool)

+ func LastOr[T any, S ~[]T](s S, defaultVal T) T

+ func Last[T any, S ~[]T](s S) (T, bool)

+ func ReduceReverseEx[T any, U any, S ~[]T](s S, reduceFunc func(accumulator U, currentValue T, currentIndex int) U, ...) U

+ func ReduceReverse[T any, S ~[]T](s S, reduceFunc func(accumulator, currentValue T) T) T

+ func StringLexJoinEx[T any, S ~[]T](s S, sep, lastSep, format string) string

+ func StringLexJoin[T any, S ~[]T](s S, sep, lastSep string) string

+ func ToPtrSlice[T any, S ~[]T](s S) []*T

+ func ToPtr[T any](t T) *T

type Tuple2

+ func (tuple2 *Tuple2[T1, T2]) Unpack() (T1, T2)

type Tuple3

+ func (tuple3 *Tuple3[T1, T2, T3]) Unpack() (T1, T2, T3)

+ type Tuple4 struct

+ Elem1 T1

+ Elem2 T2

+ Elem3 T3

+ Elem4 T4

+ func Zip4[T1, T2, T3, T4 any, S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4](slice1 S1, slice2 S2, slice3 S3, slice4 S4) []*Tuple4[T1, T2, T3, T4]

+ func (tuple4 *Tuple4[T1, T2, T3, T4]) Unpack() (T1, T2, T3, T4)

+ type Tuple5 struct

+ Elem1 T1

+ Elem2 T2

+ Elem3 T3

+ Elem4 T4

+ Elem5 T5

+ func Zip5[T1, T2, T3, T4, T5 any, S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5](slice1 S1, slice2 S2, slice3 S3, slice4 S4, slice5 S5) []*Tuple5[T1, T2, T3, T4, T5]

+ func (tuple5 *Tuple5[T1, T2, T3, T4, T5]) Unpack() (T1, T2, T3, T4, T5)

v1.10.0

Sep 8, 2024

Changes in this version

+ var RuneLength = utf8.RuneCountInString

+ func Clamp[T NumberExt | StringExt](value, min, max T) T

+ func ContainByPtr[T any, S ~[]T](a S, pred func(t *T) bool) bool

+ func ContainBy[T any, S ~[]T](a S, pred func(t T) bool) bool

+ func ContentEqualBy[T any, K comparable, S ~[]T](a, b S, keyFunc func(t T) K) bool

+ func CountValueBy[T any, S ~[]T](a S, pred func(t T) bool) int

+ func DifferenceBy[T any, K comparable, S ~[]T](a, b S, keyFunc func(t T) K) (S, S)

+ func EqualByPtr[T any, S ~[]T](a, b S, equalCmp func(a, b *T) bool) bool

+ func EqualBy[T any, S ~[]T](a, b S, equalCmp func(a, b T) bool) bool

+ func ExecDuration(fn func()) time.Duration

+ func ExecDuration1[T any](fn func() T) (T, time.Duration)

+ func ExecDuration2[T1, T2 any](fn func() (T1, T2)) (T1, T2, time.Duration)

+ func ExecDuration3[T1, T2, T3 any](fn func() (T1, T2, T3)) (T1, T2, T3, time.Duration)

+ func FindLastPtr[T any, S ~[]T](a S, pred func(t *T) bool) (t T, found bool)

+ func FindLast[T any, S ~[]T](a S, pred func(t T) bool) (t T, found bool)

+ func FindPtr[T any, S ~[]T](a S, pred func(t *T) bool) (t T, found bool)

+ func Find[T any, S ~[]T](a S, pred func(t T) bool) (t T, found bool)

+ func ForEachPtrReverse[T any, S ~[]T](s S, pred func(i int, t *T))

+ func IndexOfBy[T any, S ~[]T](a S, pred func(t T) bool) int

+ func IntersectionBy[T any, K comparable, S ~[]T](a, b S, keyFunc func(t T) K) S

+ func IsUniqueBy[T any, U comparable, S ~[]T](s S, keyFunc func(t T) U) bool

+ func IterPtrReverse[T any, S ~[]T](iterFunc func(index int, v *T) bool, slices ...S)

+ func IterPtr[T any, S ~[]T](iterFunc func(index int, v *T) bool, slices ...S)

+ func IterReverse[T any, S ~[]T](iterFunc func(index int, v T) bool, slices ...S)

+ func Iter[T any, S ~[]T](iterFunc func(index int, v T) bool, slices ...S)

+ func LastIndexOfBy[T any, S ~[]T](a S, pred func(t T) bool) int

+ func MapEqualBy[K comparable, V any, M ~map[K]V](m1, m2 M, equalCmp func(v1, v2 V) bool) bool

+ func MaxInBy[T any, S ~[]T](s S, lessFunc func(a, b T) bool) (T, error)

+ func MinInBy[T any, S ~[]T](s S, lessFunc func(a, b T) bool) (T, error)

+ func ReplaceN[T comparable, S ~[]T](s S, value, replacement T, n int) int

+ func StringJoinBy[T any, S ~[]T](s S, sep string, fmtFunc func(v T) string) string

+ func ToIfaceSlice[T any, S ~[]T](s S) []any

+ func ToSetByReverse[T any, K comparable, S ~[]T](s S, keyFunc func(t T) K) S

+ func ToSetBy[T any, K comparable, S ~[]T](s S, keyFunc func(t T) K) S

+ func UnionBy[T any, K comparable, S ~[]T](a, b S, keyFunc func(t T) K) S

+ type Complex interface

+ type ComplexExt interface

+ type ComplexPtr interface

v1.9.0

Aug 13, 2024

Changes in this version

+ func Drop[T comparable, S ~[]T](a S, values ...T) S

+ func ExecTaskFuncEx[T any](ctx context.Context, maxConcurrentTasks uint, stopOnError bool, ...) map[int]error

+ func ExecTaskFunc[T any](ctx context.Context, maxConcurrentTasks uint, ...) error

+ func HeadOf[T any, S ~[]T](s S) (T, bool)

+ func MapOmitCopy[K comparable, V any, M ~map[K]V](m M, keys ...K) M

+ func MapOmit[K comparable, V any, M ~map[K]V](m M, keys ...K)

+ func MapPick[K comparable, V any, M ~map[K]V](m M, keys ...K) M

+ func MapSliceToMapKeys[T comparable, V any, S ~[]T](s S, defaultVal V) map[T]V

+ func PartitionN[T any, S ~[]T](s S, numPartitions uint, partitionFunc func(T, int) int) []S

+ func Partition[T any, S ~[]T](s S, partitionFunc func(T, int) bool) (S, S)

+ func TailOf[T any, S ~[]T](s S) (T, bool)

+ type FloatExt interface

+ type IntExt interface

+ type NumberExt interface

+ type String interface

+ type StringExt interface

+ type UIntExt interface

v1.8.1

Aug 11, 2024

v1.8.0

Jul 10, 2024

Changes in this version

+ func RandChoice[T any](s ...T) (T, bool)

+ func Shuffle[T any](s []T, randFuncs ...func(n int) int) []T

+ type RandChoiceMaker struct

+ func NewRandChoiceMaker[T any](s []T, randFuncs ...func(n int) int) RandChoiceMaker[T]

+ func (m *RandChoiceMaker[T]) HasNext() bool

+ func (m *RandChoiceMaker[T]) Next() (T, bool)

v1.7.0

Jun 19, 2024

Changes in this version

+ func ToSetPredReverse[T any, K comparable](s []T, keyFunc func(t T) K) []T

+ type FloatPtr interface

+ type IntPtr interface

+ type NumberPtr interface

+ type StringPtr interface

+ type UIntPtr interface

v1.6.1

Nov 25, 2023

v1.6.0

Nov 25, 2023

Changes in this version

+ var ErrPanic = errors.New("panic occurred")

+ func ExecTasks(ctx context.Context, maxConcurrentTasks uint, ...) error

+ func ExecTasksEx(ctx context.Context, maxConcurrentTasks uint, stopOnError bool, ...) map[int]error

+ func SliceByRange[T NumberEx](start, end, step T) []T

+ func SubSlice[T any](s []T, start, end int) []T

v1.5.0

Nov 11, 2023

Changes in this version

+ var StructToMapEx = rflutil.StructToMapEx

+ func Bind1Arg0Ret[A1 any](fn func(A1), a1 A1) func()

+ func Bind1Arg1Ret[A1 any, R1 any](fn func(A1) R1, a1 A1) func() R1

+ func Bind1Arg2Ret[A1 any, R1 any, R2 any](fn func(A1) (R1, R2), a1 A1) func() (R1, R2)

+ func Bind1Arg3Ret[A1 any, R1 any, R2 any, R3 any](fn func(A1) (R1, R2, R3), a1 A1) func() (R1, R2, R3)

+ func Bind2Arg0Ret[A1 any, A2 any](fn func(A1, A2), a1 A1, a2 A2) func()

+ func Bind2Arg1Ret[A1 any, A2 any, R1 any](fn func(A1, A2) R1, a1 A1, a2 A2) func() R1

+ func Bind2Arg2Ret[A1 any, A2 any, R1 any, R2 any](fn func(A1, A2) (R1, R2), a1 A1, a2 A2) func() (R1, R2)

+ func Bind2Arg3Ret[A1 any, A2 any, R1 any, R2 any, R3 any](fn func(A1, A2) (R1, R2, R3), a1 A1, a2 A2) func() (R1, R2, R3)

+ func Bind3Arg0Ret[A1 any, A2 any, A3 any](fn func(A1, A2, A3), a1 A1, a2 A2, a3 A3) func()

+ func Bind3Arg1Ret[A1 any, A2 any, A3 any, R1 any](fn func(A1, A2, A3) R1, a1 A1, a2 A2, a3 A3) func() R1

+ func Bind3Arg2Ret[A1 any, A2 any, A3 any, R1 any, R2 any](fn func(A1, A2, A3) (R1, R2), a1 A1, a2 A2, a3 A3) func() (R1, R2)

+ func Bind3Arg3Ret[A1 any, A2 any, A3 any, R1 any, R2 any, R3 any](fn func(A1, A2, A3) (R1, R2, R3), a1 A1, a2 A2, a3 A3) func() (R1, R2, R3)

+ func Bind4Arg0Ret[A1 any, A2 any, A3 any, A4 any](fn func(A1, A2, A3, A4), a1 A1, a2 A2, a3 A3, a4 A4) func()

+ func Bind4Arg1Ret[A1 any, A2 any, A3 any, A4 any, R1 any](fn func(A1, A2, A3, A4) R1, a1 A1, a2 A2, a3 A3, a4 A4) func() R1

+ func Bind4Arg2Ret[A1 any, A2 any, A3 any, A4 any, R1 any, R2 any](fn func(A1, A2, A3, A4) (R1, R2), a1 A1, a2 A2, a3 A3, a4 A4) func() (R1, R2)

+ func Bind4Arg3Ret[A1 any, A2 any, A3 any, A4 any, R1 any, R2 any, R3 any](fn func(A1, A2, A3, A4) (R1, R2, R3), a1 A1, a2 A2, a3 A3, a4 A4) func() (R1, R2, R3)

+ func Bind5Arg0Ret[A1 any, A2 any, A3 any, A4 any, A5 any](fn func(A1, A2, A3, A4, A5), a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) func()

+ func Bind5Arg1Ret[A1 any, A2 any, A3 any, A4 any, A5 any, R1 any](fn func(A1, A2, A3, A4, A5) R1, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) func() R1

+ func Bind5Arg2Ret[A1 any, A2 any, A3 any, A4 any, A5 any, R1 any, R2 any](fn func(A1, A2, A3, A4, A5) (R1, R2), a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) func() (R1, R2)

+ func Bind5Arg3Ret[A1 any, A2 any, A3 any, A4 any, A5 any, R1 any, R2 any, R3 any](fn func(A1, A2, A3, A4, A5) (R1, R2, R3), a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) func() (R1, R2, R3)

+ func MapCopyExcludeKeys[K comparable, V any](m map[K]V, excludedKeys ...K) map[K]V

+ func MapCopy[K comparable, V any](m map[K]V, onlyKeys ...K) map[K]V

v1.4.0

Sep 28, 2023

v1.3.0

Sep 23, 2023

v1.2.0

Sep 9, 2023

v1.1.0

Jun 24, 2023

v1.0.0

Jun 21, 2023

v0

v0.0.0

Sep 28, 2023

Changes in this version

+ var ErrEmpty = errors.New("container is empty")

+ var ErrIndexOutOfRange = errors.New("index out of range")

+ var ErrSliceEmpty = ErrEmpty

+ var MultilineString = LinesTrimLeftSpace

+ var ParseTag = rflutil.ParseTag

+ var ParseTagOf = rflutil.ParseTagOf

+ var ParseTagsOf = rflutil.ParseTagsOf

+ var StrDefaultChars = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")

+ var StrDigits = []rune("0123456789")

+ var StrLowerAlpha = []rune("abcdefghijklmnopqrstuvwxyz")

+ var StrUpperAlpha = []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

+ var StructToMap = rflutil.StructToMap

+ func Abs(n int64) int64

+ func All(s ...T) bool

+ func Any(s ...T) bool

+ func Chunk(s []T, chunkSize int) [][]T

+ func ChunkByPieces(s []T, chunkCount int) [][]T

+ func Compact(s []T) []T

+ func Concat(slices ...[]T) []T

+ func Contain(a []T, t T) bool

+ func ContainAll(a []T, b ...T) bool

+ func ContainAny(a []T, b ...T) bool

+ func ContainPred(a []T, pred func(t T) bool) bool

+ func ContainPredPtr(a []T, pred func(t *T) bool) bool

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

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

+ func ContentEqualPred(a, b []T, keyFunc func(t T) K) bool

+ func ContentEqualPtr(a, b []*T) bool

+ func CountValue(a []T, val T) int

+ func CountValuePred(a []T, pred func(t T) bool) int

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

+ func DifferencePred(a, b []T, keyFunc func(t T) K) ([]T, []T)

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

+ func EqualPred(a, b []T, equalFunc func(a, b T) bool) bool

+ func EqualPredPtr(a, b []T, equalFunc func(a, b *T) bool) bool

+ func FastRemove(ps *[]T, v T) bool

+ func FastRemoveAt(ps *[]T, i int)

+ func FastRemoveLastOf(ps *[]T, v T) bool

+ func Fill(a []T, val T)

+ func Filter(s []T, filterFunc func(t T) bool) []T

+ func FilterGT(s []T, v T) []T

+ func FilterGTE(s []T, v T) []T

+ func FilterILIKE(s []T, v string) []T

+ func FilterIN(s []T, v ...T) []T

+ func FilterLIKE(s []T, v string) []T

+ func FilterLT(s []T, v T) []T

+ func FilterLTE(s []T, v T) []T

+ func FilterNE(s []T, v T) []T

+ func FilterNIN(s []T, v ...T) []T

+ func FilterPtr(s []T, filterFunc func(t *T) bool) []T

+ func FindLastPred(a []T, pred func(t T) bool) (t T, found bool)

+ func FindLastPredPtr(a []T, pred func(t *T) bool) (t T, found bool)

+ func FindPred(a []T, pred func(t T) bool) (t T, found bool)

+ func FindPredPtr(a []T, pred func(t *T) bool) (t T, found bool)

+ func FirstTrue(a0 T, args ...T) T

+ func Flatten(s ...[]T) []T

+ func Flatten3(s ...[][]T) []T

+ func ForEach(s []T, pred func(i int, t T))

+ func ForEachPtr(s []T, pred func(i int, t *T))

+ func ForEachReverse(s []T, pred func(i int, t T))

+ func ForEachReversePtr(s []T, pred func(i int, t *T))

+ func FormatFloat(v T) string

+ func FormatFloatEx(v T, format string) string

+ func FormatFloatGroup(v T) string

+ func FormatFloatGroupEx(v T, format string) string

+ func FormatInt(v T) string

+ func FormatIntEx(v T, format string) string

+ func FormatIntGroup(v T) string

+ func FormatUint(v T) string

+ func FormatUintEx(v T, format string) string

+ func FormatUintGroup(v T) string

+ func GetFirst(s []T, defaultVal T) T

+ func GetLast(s []T, defaultVal T) T

+ func Head(t T, s ...any) T

+ func If(cond C, v1 T, v2 T) T

+ func IndexOf(a []T, t T) int

+ func IndexOfPred(a []T, pred func(t T) bool) int

+ func IndexOfSlice(a, sub []T) int

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

+ func IntersectionPred(a, b []T, keyFunc func(t T) K) []T

+ func IsSorted(s []T) bool

+ func IsSortedDesc(s []T) bool

+ func IsUnique(s []T) bool

+ func IsUniquePred(s []T, keyFunc func(t T) U) bool

+ func LastIndexOf(a []T, t T) int

+ func LastIndexOfPred(a []T, pred func(t T) bool) int

+ func LastIndexOfSlice(a []T, sub []T) int

+ func LinesTrim(s string, cutset string) string

+ func LinesTrimLeft(s string, cutset string) string

+ func LinesTrimLeftSpace(s string) string

+ func LinesTrimRight(s string, cutset string) string

+ func LinesTrimRightSpace(s string) string

+ func LinesTrimSpace(s string) string

+ func MapContainKeys(m map[K]V, keys ...K) bool

+ func MapContainValues(m map[K]V, values ...V) bool

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

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

+ func MapEqualPred(m1, m2 map[K]V, equalFunc func(v1, v2 V) bool) bool

+ func MapGet(m map[K]V, k K, defaultVal V) V

+ func MapIntersectionKeys(m1 map[K]V, ms ...map[K]V) []K

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

+ func MapPop(m map[K]V, k K, defaultVal V) V

+ func MapSetDefault(m map[K]V, k K, defaultVal V) V

+ func MapSlice(s []T, mapFunc func(b T) U) []U

+ func MapSliceEx(s []T, mapFunc func(b T) (U, error)) ([]U, error)

+ func MapSliceToMap(s []T, mapFunc func(b T) (K, V)) map[K]V

+ func MapSliceToMapEx(s []T, mapFunc func(b T) (K, V, error)) (map[K]V, error)

+ func MapUnionKeys(m1 map[K]V, ms ...map[K]V) []K

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

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

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

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

+ func Max(v1 T, s ...T) T

+ func MaxIn(s []T) (T, error)

+ func MaxInPred(s []T, lessFunc func(a, b T) bool) (T, error)

+ func MaxTime(t1 time.Time, s ...time.Time) time.Time

+ func Min(v1 T, s ...T) T

+ func MinIn(s []T) (T, error)

+ func MinInPred(s []T, lessFunc func(a, b T) bool) (T, error)

+ func MinMax(v1 T, s ...T) (T, T)

+ func MinMaxTime(t1 time.Time, s ...time.Time) (time.Time, time.Time)

+ func MinTime(t1 time.Time, s ...time.Time) time.Time

+ func Must(v T, e error) T

+ func Must1(e error)

+ func Must2(v T, e error) T

+ func Must3(v1 T1, v2 T2, e error) (T1, T2)

+ func Must4(v1 T1, v2 T2, v3 T3, e error) (T1, T2, T3)

+ func Must5(v1 T1, v2 T2, v3 T3, v4 T4, e error) (T1, T2, T3, T4)

+ func Must6(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, e error) (T1, T2, T3, T4, T5)

+ func New(t T) *T

+ func NumberFmtGroup(num string, fractionSep, groupSep byte) string

+ func NumberFmtUngroup(num string, groupSep byte) string

+ func ParseFloat(s string) (T, error)

+ func ParseFloatDef(s string, defaultVal T) T

+ func ParseFloatUngroup(s string) (T, error)

+ func ParseInt(s string) (T, error)

+ func ParseIntDef(s string, defaultVal T) T

+ func ParseIntEx(s string, base int) (T, error)

+ func ParseIntUngroup(s string) (T, error)

+ func ParseUint(s string) (T, error)

+ func ParseUintDef(s string, defaultVal T) T

+ func ParseUintEx(s string, base int) (T, error)

+ func ParseUintUngroup(s string) (T, error)

+ func Product(s ...T) T

+ func ProductAs(s ...T) U

+ func RandString(n int) string

+ func RandStringEx(n int, allowedChars []rune) string

+ func Reduce(s []T, reduceFunc func(accumulator, currentValue T) T) T

+ func ReduceEx(s []T, reduceFunc func(accumulator U, currentValue T, currentIndex int) U, ...) U

+ func Remove(ps *[]T, v T) bool

+ func RemoveAll(ps *[]T, v T) int

+ func RemoveAt(ps *[]T, i int)

+ func RemoveLastOf(ps *[]T, v T) bool

+ func Replace(s []T, value, replacement T) bool

+ func ReplaceAll(s []T, value, replacement T) int

+ func Reverse(s []T) []T

+ func ReverseCopy(s []T) []T

+ func Sort(s []T) []T

+ func SortDesc(s []T) []T

+ func SortEx(s []T, less func(i, j int) bool) []T

+ func SortStable(s []T) []T

+ func SortStableDesc(s []T) []T

+ func SortStableEx(s []T, less func(i, j int) bool) []T

+ func StringJoin(s []T, sep string) string

+ func StringJoinEx(s []T, sep, format string) string

+ func StringJoinPred(s []T, sep string, fmtFunc func(v T) string) string

+ func Sum(s ...T) T

+ func SumAs(s ...T) U

+ func Tail(t any, s ...any) (T, bool)

+ func ToIntfSlice(s []T) []any

+ func ToNumberSlice(slice []T) []U

+ func ToSet(s []T) []T

+ func ToSetPred(s []T, keyFunc func(t T) K) []T

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

+ func ToStringSlice(slice []T) []U

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

+ func UnionPred(a, b []T, keyFunc func(t T) K) []T

+ type Float interface

+ type FloatEx interface

+ type Int interface

+ type IntEx interface

+ type Number interface

+ type NumberEx interface

+ type StringEx interface

+ type Tuple2 struct

+ Elem1 T

+ Elem2 U

+ func MapEntries(m map[K]V) []*Tuple2[K, V]

+ func Zip(slice1 []T, slice2 []U) []*Tuple2[T, U]

+ type Tuple3 struct

+ Elem1 T

+ Elem2 U

+ Elem3 V

+ func Zip3(slice1 []T, slice2 []U, slice3 []V) []*Tuple3[T, U, V]

+ type UInt interface

+ type UIntEx interface

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