updated dependencies and go
This commit is contained in:
+18
-41
@@ -5,6 +5,8 @@ import (
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"reflect"
|
||||
"slices"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func BoolCount(arr ...bool) int {
|
||||
@@ -41,22 +43,12 @@ func ReverseArray[T any](v []T) {
|
||||
}
|
||||
|
||||
func InArray[T comparable](needle T, haystack []T) bool {
|
||||
for _, v := range haystack {
|
||||
if v == needle {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
return slices.Contains(haystack, needle)
|
||||
}
|
||||
|
||||
// ArrContains checks if the value is contained in the array (same as InArray, but odther name for better findability)
|
||||
func ArrContains[T comparable](haystack []T, needle T) bool {
|
||||
for _, v := range haystack {
|
||||
if v == needle {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
return slices.Contains(haystack, needle)
|
||||
}
|
||||
|
||||
func ArrUnique[T comparable](array []T) []T {
|
||||
@@ -119,12 +111,7 @@ func ArrAllErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
|
||||
}
|
||||
|
||||
func ArrNone[T any](arr []T, fn func(T) bool) bool {
|
||||
for _, av := range arr {
|
||||
if fn(av) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
return !slices.ContainsFunc(arr, fn)
|
||||
}
|
||||
|
||||
func ArrNoneErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
|
||||
@@ -141,12 +128,7 @@ func ArrNoneErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
|
||||
}
|
||||
|
||||
func ArrAny[T any](arr []T, fn func(T) bool) bool {
|
||||
for _, av := range arr {
|
||||
if fn(av) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
return slices.ContainsFunc(arr, fn)
|
||||
}
|
||||
|
||||
func ArrAnyErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
|
||||
@@ -246,7 +228,7 @@ func ArrFirst[T any](arr []T, comp func(v T) bool) (T, bool) {
|
||||
func ArrFirstOrNil[T any](arr []T, comp func(v T) bool) *T {
|
||||
for _, v := range arr {
|
||||
if comp(v) {
|
||||
return Ptr(v)
|
||||
return new(v)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
@@ -274,7 +256,7 @@ func ArrLastOrNil[T any](arr []T, comp func(v T) bool) *T {
|
||||
}
|
||||
}
|
||||
if found {
|
||||
return Ptr(result)
|
||||
return new(result)
|
||||
} else {
|
||||
return nil
|
||||
}
|
||||
@@ -319,10 +301,8 @@ func ArrLastIndexFunc[T any](arr []T, comp func(v T) bool) int {
|
||||
}
|
||||
|
||||
func AddToSet[T comparable](set []T, add T) []T {
|
||||
for _, v := range set {
|
||||
if v == add {
|
||||
return set
|
||||
}
|
||||
if slices.Contains(set, add) {
|
||||
return set
|
||||
}
|
||||
return append(set, add)
|
||||
}
|
||||
@@ -522,7 +502,7 @@ func ArrAppend[T any](arr []T, add ...T) []T {
|
||||
func ArrPrepend[T any](arr []T, add ...T) []T {
|
||||
out := make([]T, len(arr)+len(add))
|
||||
copy(out[len(add):], arr)
|
||||
for i := 0; i < len(add); i++ {
|
||||
for i := range add {
|
||||
out[len(add)-i-1] = add[i]
|
||||
}
|
||||
return out
|
||||
@@ -558,8 +538,8 @@ func ArrExcept[T comparable](arr []T, needles ...T) []T {
|
||||
return r
|
||||
}
|
||||
|
||||
func ArrayToInterface[T any](t []T) []interface{} {
|
||||
res := make([]interface{}, 0, len(t))
|
||||
func ArrayToInterface[T any](t []T) []any {
|
||||
res := make([]any, 0, len(t))
|
||||
for i, _ := range t {
|
||||
res = append(res, t[i])
|
||||
}
|
||||
@@ -567,15 +547,15 @@ func ArrayToInterface[T any](t []T) []interface{} {
|
||||
}
|
||||
|
||||
func JoinString(arr []string, delimiter string) string {
|
||||
str := ""
|
||||
var str strings.Builder
|
||||
for i, v := range arr {
|
||||
str += v
|
||||
str.WriteString(v)
|
||||
if i < len(arr)-1 {
|
||||
str += delimiter
|
||||
str.WriteString(delimiter)
|
||||
}
|
||||
}
|
||||
|
||||
return str
|
||||
return str.String()
|
||||
}
|
||||
|
||||
// ArrChunk splits the array into buckets of max-size `chunkSize`
|
||||
@@ -595,10 +575,7 @@ func ArrChunk[T any](arr []T, chunkSize int) [][]T {
|
||||
i := 0
|
||||
for i < len(arr) {
|
||||
|
||||
right := i + chunkSize
|
||||
if right >= len(arr) {
|
||||
right = len(arr)
|
||||
}
|
||||
right := min(i+chunkSize, len(arr))
|
||||
|
||||
res = append(res, arr[i:right])
|
||||
|
||||
|
||||
+4
-7
@@ -44,8 +44,8 @@ func newBase58Encoding(alphabet string) *B58Encoding {
|
||||
|
||||
b58 := make([]byte, 0, 256)
|
||||
|
||||
for i := byte(0); i < 32; i++ {
|
||||
for j := byte(0); j < 8; j++ {
|
||||
for i := range byte(32) {
|
||||
for j := range byte(8) {
|
||||
|
||||
b := i*8 + j
|
||||
|
||||
@@ -100,7 +100,7 @@ func (enc *B58Encoding) Encode(src []byte) ([]byte, error) {
|
||||
}
|
||||
} else {
|
||||
m := mod.Int64()
|
||||
for i := 0; i < 10; i++ {
|
||||
for range 10 {
|
||||
answer = append(answer, enc.alphabet[m%58])
|
||||
m /= 58
|
||||
}
|
||||
@@ -137,10 +137,7 @@ func (enc *B58Encoding) Decode(src []byte) ([]byte, error) {
|
||||
scratch := new(big.Int)
|
||||
|
||||
for t := src; len(t) > 0; {
|
||||
n := len(t)
|
||||
if n > 10 {
|
||||
n = 10
|
||||
}
|
||||
n := min(len(t), 10)
|
||||
|
||||
total := uint64(0)
|
||||
for _, v := range t[:n] {
|
||||
|
||||
+4
-4
@@ -18,18 +18,18 @@ func RandBase62(rlen int) string {
|
||||
|
||||
randMax := big.NewInt(math.MaxInt64)
|
||||
|
||||
r := ""
|
||||
var r strings.Builder
|
||||
|
||||
for i := 0; i < rlen; i++ {
|
||||
for range rlen {
|
||||
v, err := rand.Int(rand.Reader, randMax)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
r += string(base62CharacterSet[v.Mod(v, bi52).Int64()])
|
||||
r.WriteString(string(base62CharacterSet[v.Mod(v, bi52).Int64()]))
|
||||
}
|
||||
|
||||
return r
|
||||
return r.String()
|
||||
}
|
||||
|
||||
func EncodeBase62(num uint64) string {
|
||||
|
||||
+8
-7
@@ -5,6 +5,7 @@ import (
|
||||
"errors"
|
||||
"math"
|
||||
"math/big"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type AnyBaseConverter struct {
|
||||
@@ -25,18 +26,18 @@ func (bc AnyBaseConverter) Rand(rlen int) string {
|
||||
|
||||
randMax := big.NewInt(math.MaxInt64)
|
||||
|
||||
r := ""
|
||||
var r strings.Builder
|
||||
|
||||
for i := 0; i < rlen; i++ {
|
||||
for range rlen {
|
||||
v, err := rand.Int(rand.Reader, randMax)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
r += string(bc.charset[v.Mod(v, biBase).Int64()])
|
||||
r.WriteString(string(bc.charset[v.Mod(v, biBase).Int64()]))
|
||||
}
|
||||
|
||||
return r
|
||||
return r.String()
|
||||
}
|
||||
|
||||
func (bc AnyBaseConverter) EncodeUInt64(num uint64) string {
|
||||
@@ -44,7 +45,7 @@ func (bc AnyBaseConverter) EncodeUInt64(num uint64) string {
|
||||
return "0"
|
||||
}
|
||||
|
||||
b := ""
|
||||
var b strings.Builder
|
||||
|
||||
// loop as long the num is bigger than zero
|
||||
for num > 0 {
|
||||
@@ -53,10 +54,10 @@ func (bc AnyBaseConverter) EncodeUInt64(num uint64) string {
|
||||
num -= r
|
||||
num /= base62Base
|
||||
|
||||
b += string(bc.charset[int(r)])
|
||||
b.WriteString(string(bc.charset[int(r)]))
|
||||
}
|
||||
|
||||
return b
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func (bc AnyBaseConverter) DecodeUInt64(str string) (uint64, error) {
|
||||
|
||||
+1
-1
@@ -25,7 +25,7 @@ func BytesXOR(a []byte, b []byte) ([]byte, error) {
|
||||
|
||||
r := make([]byte, len(a))
|
||||
|
||||
for i := 0; i < len(a); i++ {
|
||||
for i := range a {
|
||||
r[i] = a[i] ^ b[i]
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -85,7 +85,7 @@ func MarshalJsonOrNil(v any) *string {
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return Ptr(string(bin))
|
||||
return new(string(bin))
|
||||
}
|
||||
|
||||
func MarshalJsonIndentOrPanic(v any, prefix, indent string) string {
|
||||
@@ -109,5 +109,5 @@ func MarshalJsonIndentOrNil(v any, prefix, indent string) *string {
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return Ptr(string(bin))
|
||||
return new(string(bin))
|
||||
}
|
||||
|
||||
+5
-9
@@ -1,5 +1,7 @@
|
||||
package langext
|
||||
|
||||
import "maps"
|
||||
|
||||
import "encoding/json"
|
||||
|
||||
type MapEntry[T comparable, V any] struct {
|
||||
@@ -60,9 +62,7 @@ func MapToArr[T comparable, V any](v map[T]V) []MapEntry[T, V] {
|
||||
|
||||
func CopyMap[K comparable, V any](a map[K]V) map[K]V {
|
||||
result := make(map[K]V, len(a))
|
||||
for k, v := range a {
|
||||
result[k] = v
|
||||
}
|
||||
maps.Copy(result, a)
|
||||
return result
|
||||
}
|
||||
|
||||
@@ -90,14 +90,10 @@ func ForceJsonMapOrPanic(v any) map[string]any {
|
||||
func MapMerge[K comparable, V any](base map[K]V, arr ...map[K]V) map[K]V {
|
||||
res := make(map[K]V, len(base)*(1+len(arr)))
|
||||
|
||||
for k, v := range base {
|
||||
res[k] = v
|
||||
}
|
||||
maps.Copy(res, base)
|
||||
|
||||
for _, m := range arr {
|
||||
for k, v := range m {
|
||||
res[k] = v
|
||||
}
|
||||
maps.Copy(res, m)
|
||||
}
|
||||
|
||||
return res
|
||||
|
||||
+16
-10
@@ -5,16 +5,17 @@ import (
|
||||
)
|
||||
|
||||
// PTrue := &true
|
||||
var PTrue = Ptr(true)
|
||||
var PTrue = new(true)
|
||||
|
||||
// PFalse := &false
|
||||
var PFalse = Ptr(false)
|
||||
var PFalse = new(false)
|
||||
|
||||
// PNil := &nil
|
||||
var PNil = Ptr[any](nil)
|
||||
|
||||
//go:fix inline
|
||||
func Ptr[T any](v T) *T {
|
||||
return &v
|
||||
return new(v)
|
||||
}
|
||||
|
||||
func DblPtr[T any](v T) **T {
|
||||
@@ -34,32 +35,37 @@ func DblPtrNil[T any]() **T {
|
||||
return &v
|
||||
}
|
||||
|
||||
//go:fix inline
|
||||
func ArrPtr[T any](v ...T) *[]T {
|
||||
return &v
|
||||
return new(v)
|
||||
}
|
||||
|
||||
//go:fix inline
|
||||
func PtrInt32(v int32) *int32 {
|
||||
return &v
|
||||
return new(v)
|
||||
}
|
||||
|
||||
//go:fix inline
|
||||
func PtrInt64(v int64) *int64 {
|
||||
return &v
|
||||
return new(v)
|
||||
}
|
||||
|
||||
//go:fix inline
|
||||
func PtrFloat32(v float32) *float32 {
|
||||
return &v
|
||||
return new(v)
|
||||
}
|
||||
|
||||
//go:fix inline
|
||||
func PtrFloat64(v float64) *float64 {
|
||||
return &v
|
||||
return new(v)
|
||||
}
|
||||
|
||||
func IsNil(i interface{}) bool {
|
||||
func IsNil(i any) bool {
|
||||
if i == nil {
|
||||
return true
|
||||
}
|
||||
switch reflect.TypeOf(i).Kind() {
|
||||
case reflect.Ptr, reflect.Map, reflect.Chan, reflect.Slice, reflect.Func, reflect.UnsafePointer:
|
||||
case reflect.Pointer, reflect.Map, reflect.Chan, reflect.Slice, reflect.Func, reflect.UnsafePointer:
|
||||
return reflect.ValueOf(i).IsNil()
|
||||
}
|
||||
return false
|
||||
|
||||
+4
-6
@@ -1,18 +1,16 @@
|
||||
package langext
|
||||
|
||||
import "slices"
|
||||
|
||||
import "sort"
|
||||
|
||||
func Sort[T OrderedConstraint](arr []T) {
|
||||
sort.Slice(arr, func(i1, i2 int) bool {
|
||||
return arr[i1] < arr[i2]
|
||||
})
|
||||
slices.Sort(arr)
|
||||
}
|
||||
|
||||
func AsSorted[T OrderedConstraint](arr []T) []T {
|
||||
arr = ArrCopy(arr)
|
||||
sort.Slice(arr, func(i1, i2 int) bool {
|
||||
return arr[i1] < arr[i2]
|
||||
})
|
||||
slices.Sort(arr)
|
||||
return arr
|
||||
}
|
||||
|
||||
|
||||
+11
-11
@@ -15,7 +15,7 @@ func StrLimit(val string, maxlen int, suffix string) string {
|
||||
|
||||
func StrSplit(val string, sep string, allowEmpty bool) []string {
|
||||
var arr []string
|
||||
for _, k := range strings.Split(val, sep) {
|
||||
for k := range strings.SplitSeq(val, sep) {
|
||||
if allowEmpty || k != "" {
|
||||
arr = append(arr, k)
|
||||
}
|
||||
@@ -51,7 +51,7 @@ func DeRefStringer(v fmt.Stringer) *string {
|
||||
if v == nil {
|
||||
return nil
|
||||
} else {
|
||||
return Ptr(v.String())
|
||||
return new(v.String())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -93,7 +93,7 @@ func Indent(str string, pad string) string {
|
||||
str = str[0 : len(str)-1]
|
||||
}
|
||||
r := ""
|
||||
for _, v := range strings.Split(str, "\n") {
|
||||
for v := range strings.SplitSeq(str, "\n") {
|
||||
r += pad + v + "\n"
|
||||
}
|
||||
|
||||
@@ -113,29 +113,29 @@ func NumToStringOpt[V IntConstraint](v *V, fallback string) string {
|
||||
}
|
||||
|
||||
func StrRepeat(val string, count int) string {
|
||||
r := ""
|
||||
for i := 0; i < count; i++ {
|
||||
r += val
|
||||
var r strings.Builder
|
||||
for range count {
|
||||
r.WriteString(val)
|
||||
}
|
||||
return r
|
||||
return r.String()
|
||||
}
|
||||
|
||||
func StrWrap(val string, linelen int, seperator string) string {
|
||||
res := ""
|
||||
var res strings.Builder
|
||||
|
||||
for iPos := 0; ; {
|
||||
next := min(iPos+linelen, len(val))
|
||||
res += val[iPos:next]
|
||||
res.WriteString(val[iPos:next])
|
||||
|
||||
iPos = next
|
||||
if iPos >= len(val) {
|
||||
break
|
||||
}
|
||||
|
||||
res += seperator
|
||||
res.WriteString(seperator)
|
||||
}
|
||||
|
||||
return res
|
||||
return res.String()
|
||||
}
|
||||
|
||||
func StrRemoveControlCharacters(str string) string {
|
||||
|
||||
Reference in New Issue
Block a user