feat: update go version

Author: devalexandre

README.md

@@ -1,5 +1,5 @@
 # gofn
-![Coverage](https://img.shields.io/badge/Coverage-88.8%25-brightgreen)
+![Coverage](https://img.shields.io/badge/Coverage-87.7%25-brightgreen)
 [![Go](https://github.com/devalexandre/gofn/actions/workflows/go.yml/badge.svg)](https://github.com/devalexandre/gofn/actions/workflows/go.yml)
 
 # library to use golang functional
@@ -284,7 +284,7 @@ Fill the array with a value.
 ```go
 
 a := []int{1, 2, 3, 4, 5}
-b := array.Fill(a, 0)
+b := array.Fill(a, 0, len(a), 0)
 
 fmt.Println(b) // [0 0 0 0 0]
 
@@ -392,9 +392,9 @@ data := array.Array[int]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
     }).
     Map(func(i int) int {
       return i * 2
-    }).
+    })
 
 
     fmt.Println(a) // [4 8 12 16 20]
 
-```
+```

array/array_test.go

@@ -2,9 +2,11 @@ package array_test
 
 import (
 	"fmt"
-	"github.com/devalexandre/gofn/array"
 	"reflect"
+	"slices"
 	"testing"
+
+	"github.com/devalexandre/gofn/array"
 )
 
 func TestArray(t *testing.T) {
@@ -99,8 +101,16 @@ func TestArray(t *testing.T) {
 	t.Run("test Shuffle", func(t *testing.T) {
 		a := array.Array[int]{1, 2, 3, 4, 5}
 		b := a.Shuffle()
-		if reflect.DeepEqual(b, array.Array[int]{1, 2, 3, 4, 5}) {
-			t.Error("Shuffle failed. Got", b, "Expected", array.Array[int]{5, 4, 3, 2, 1})
+		if len(b) != len(a) {
+			t.Error("Shuffle failed. Got length", len(b), "Expected", len(a))
+		}
+		sorted := slices.Clone(b)
+		slices.Sort(sorted)
+		if !reflect.DeepEqual(sorted, a) {
+			t.Error("Shuffle failed. Got", b, "Expected same elements as", a)
+		}
+		if !reflect.DeepEqual(a, array.Array[int]{1, 2, 3, 4, 5}) {
+			t.Error("Shuffle mutated input. Got", a, "Expected", array.Array[int]{1, 2, 3, 4, 5})
 		}
 	})
 
@@ -151,5 +161,13 @@ func TestArray(t *testing.T) {
 		if len(grouped) != 4 {
 			t.Error("GroupBy failed. Got", len(grouped), "Expected", 4)
 		}
+
+		key := "Item 4 - 40"
+		if len(grouped[key]) != 3 {
+			t.Error("GroupBy failed. Got", grouped[key], "Expected 3 items")
+		}
+		if grouped[key][0].Qty != 10 || grouped[key][1].Qty != 15 || grouped[key][2].Qty != 25 {
+			t.Error("GroupBy failed. Got", grouped[key], "Expected items in original order")
+		}
 	})
 }

array/functions.go

@@ -2,26 +2,26 @@ package array
 
 import (
 	"fmt"
-	"math/rand"
+	"math/rand/v2"
+	"slices"
 	"sort"
 	"strings"
-	"time"
 )
 
 type Number interface {
-	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~float32 | ~float64
+	~int | ~int8 | ~int16 | ~int32 | ~int64 |
+		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+		~float32 | ~float64
 }
 
 func Filter[T any](a []T, f func(T) bool) []T {
-	y := make([]T, len(a))
-	i := 0
+	y := make([]T, 0, len(a))
 	for _, x := range a {
 		if f(x) {
-			y[i] = x
-			i++
+			y = append(y, x)
 		}
 	}
-	return y[:i]
+	return y
 }
 
 // with side effects
@@ -54,9 +54,9 @@ func Find[T any](a []T, f func(T) bool) T {
  */
 
 func Map[T, U any](a []T, f func(T) U) []U {
-	var b = make([]U, len(a))
-	for i := 0; i < len(a); i++ {
-		b[i] = f(a[i])
+	b := make([]U, len(a))
+	for i, x := range a {
+		b[i] = f(x)
 	}
 
 	return b
@@ -126,12 +126,7 @@ func Any[T any](input []T, f func(T) bool) bool {
  */
 
 func Some[T any](a []T, f func(T) bool) bool {
-	for _, x := range a {
-		if f(x) {
-			return true
-		}
-	}
-	return false
+	return Any(a, f)
 }
 
 /* Every
@@ -157,7 +152,14 @@ func Every[T any](a []T, f func(T) bool) bool {
  */
 
 func Sum[T Number](a []T) T {
-	return Reduce(a, func(x, y T) T { return x + y })
+	if len(a) == 0 {
+		panic("empty array")
+	}
+	total := a[0]
+	for _, x := range a[1:] {
+		total += x
+	}
+	return total
 }
 
 /* Product array of numbers
@@ -167,7 +169,14 @@ func Sum[T Number](a []T) T {
 *   fmt.Println(b) // 120
  */
 func Product[T Number](a []T) T {
-	return Reduce(a, func(x, y T) T { return x * y })
+	if len(a) == 0 {
+		panic("empty array")
+	}
+	total := a[0]
+	for _, x := range a[1:] {
+		total *= x
+	}
+	return total
 }
 
 /* Min array of numbers
@@ -177,12 +186,17 @@ func Product[T Number](a []T) T {
 *   fmt.Println(b) // 1
  */
 func Min[T Number](a []T) T {
-	return Reduce(a, func(x, y T) T {
-		if x < y {
-			return x
+	if len(a) == 0 {
+		panic("empty array")
+	}
+	minimum := a[0]
+	for _, x := range a[1:] {
+		if minimum < x {
+			continue
 		}
-		return y
-	})
+		minimum = x
+	}
+	return minimum
 }
 
 /* Max array of numbers
@@ -193,12 +207,17 @@ func Min[T Number](a []T) T {
  */
 
 func Max[T Number](a []T) T {
-	return Reduce(a, func(x, y T) T {
-		if x > y {
-			return x
+	if len(a) == 0 {
+		panic("empty array")
+	}
+	maximum := a[0]
+	for _, x := range a[1:] {
+		if maximum > x {
+			continue
 		}
-		return y
-	})
+		maximum = x
+	}
+	return maximum
 }
 
 /* ForEach
@@ -219,12 +238,7 @@ func ForEach[T any](a []T, f func(T)) {
 *   fmt.Println(b) // 2
  */
 func IndexOf[T comparable](a []T, x T) int {
-	for i, y := range a {
-		if x == y {
-			return i
-		}
-	}
-	return -1
+	return slices.Index(a, x)
 }
 
 /* Contains
@@ -234,7 +248,7 @@ func IndexOf[T comparable](a []T, x T) int {
 *   fmt.Println(b) // true
  */
 func Contains[T comparable](a []T, x T) bool {
-	return IndexOf(a, x) != -1
+	return slices.Contains(a, x)
 }
 
 /* Equals
@@ -247,15 +261,7 @@ func Contains[T comparable](a []T, x T) bool {
  */
 
 func Equals[T comparable](a, b []T) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for i, x := range a {
-		if x != b[i] {
-			return false
-		}
-	}
-	return true
+	return slices.Equal(a, b)
 }
 
 /* Reverse
@@ -266,9 +272,8 @@ func Equals[T comparable](a, b []T) bool {
  */
 func Reverse[T any](a []T) []T {
 	b := make([]T, len(a))
-	for i, x := range a {
-		b[len(a)-1-i] = x
-	}
+	copy(b, a)
+	slices.Reverse(b)
 	return b
 }
 
@@ -279,12 +284,11 @@ func Reverse[T any](a []T) []T {
 *   fmt.Println(b) // [2 5 4 3 1]
  */
 func Shuffle[T any](a []T) []T {
-	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	b := make([]T, len(a))
-	perm := r.Perm(len(a))
-	for i, j := range perm {
-		b[i] = a[j]
-	}
+	copy(b, a)
+	rand.Shuffle(len(b), func(i, j int) {
+		b[i], b[j] = b[j], b[i]
+	})
 	return b
 }
 
@@ -297,10 +301,13 @@ func Shuffle[T any](a []T) []T {
 
 func Unique[T comparable](a []T) []T {
 	b := make([]T, 0, len(a))
+	seen := make(map[T]struct{}, len(a))
 	for _, x := range a {
-		if !Contains(b, x) {
-			b = append(b, x)
+		if _, ok := seen[x]; ok {
+			continue
 		}
+		seen[x] = struct{}{}
+		b = append(b, x)
 	}
 	return b
 }
@@ -313,8 +320,15 @@ func Unique[T comparable](a []T) []T {
 *   fmt.Println(c) // [1 2 3 4 5 6 7 8 9 10]
  */
 
-func Union[T comparable](a, b []T) []T {
-	return append(a, b...)
+func Union[T any](a, b []T) []T {
+	if len(a)+len(b) == 0 {
+		return append(a, b...)
+	}
+
+	c := make([]T, 0, len(a)+len(b))
+	c = append(c, a...)
+	c = append(c, b...)
+	return c
 }
 
 /* Fill
@@ -431,9 +445,8 @@ func Unshift[T any](a []T, x ...T) []T {
 func GroupBy[T any, K comparable](w []T, key func(T) K) map[K][]T {
 	m := make(map[K][]T)
 	for _, x := range w {
-		if _, ok := m[key(x)]; !ok {
-			m[key(x)] = make([]T, 0)
-		}
+		k := key(x)
+		m[k] = append(m[k], x)
 	}
 
 	return m

array/functions_test.go

@@ -2,9 +2,11 @@ package array_test
 
 import (
 	"fmt"
-	"github.com/devalexandre/gofn/array"
 	"reflect"
+	"slices"
 	"testing"
+
+	"github.com/devalexandre/gofn/array"
 )
 
 // test array.Filter
@@ -219,6 +221,15 @@ func TestUnion(t *testing.T) {
 	}
 }
 
+func TestUnionAllowsNonComparableValues(t *testing.T) {
+	a := []map[string]int{{"a": 1}}
+	b := []map[string]int{{"b": 2}}
+	c := array.Union(a, b)
+	if len(c) != 2 || c[0]["a"] != 1 || c[1]["b"] != 2 {
+		t.Error("Union failed. Got", c, "Expected two map values")
+	}
+}
+
 // test array.Fill
 func TestFill(t *testing.T) {
 	a := []int{1, 2, 3, 4, 5}
@@ -320,8 +331,16 @@ func TestUnshift(t *testing.T) {
 func TestShuffle(t *testing.T) {
 	a := []int{1, 2, 3, 4, 5}
 	b := array.Shuffle(a)
-	if reflect.DeepEqual(a, b) {
-		t.Error("Shuffle failed. Got", b, "Expected", []int{1, 2, 3, 4, 5})
+	if len(b) != len(a) {
+		t.Error("Shuffle failed. Got length", len(b), "Expected", len(a))
+	}
+	sorted := slices.Clone(b)
+	slices.Sort(sorted)
+	if !reflect.DeepEqual(sorted, a) {
+		t.Error("Shuffle failed. Got", b, "Expected same elements as", a)
+	}
+	if !reflect.DeepEqual(a, []int{1, 2, 3, 4, 5}) {
+		t.Error("Shuffle mutated input. Got", a, "Expected", []int{1, 2, 3, 4, 5})
 	}
 }
 
@@ -351,4 +370,12 @@ func TestGroupBy(t *testing.T) {
 	if len(grouped) != 4 {
 		t.Error("GroupBy failed. Got", len(grouped), "Expected", 4)
 	}
+
+	key := "Item 4 - 40"
+	if len(grouped[key]) != 3 {
+		t.Error("GroupBy failed. Got", grouped[key], "Expected 3 items")
+	}
+	if grouped[key][0].Qty != 10 || grouped[key][1].Qty != 15 || grouped[key][2].Qty != 25 {
+		t.Error("GroupBy failed. Got", grouped[key], "Expected items in original order")
+	}
 }

go.mod

@@ -1,3 +1,3 @@
 module github.com/devalexandre/gofn
 
-go 1.18
+go 1.24