Rewrite collections package as generic functions (#79)

This change also bumps the Go version to 1.18.

Author: infraredgirl

.circleci/config.yml

@@ -1,6 +1,6 @@
 defaults: &defaults
   docker:
-    - image: 087285199408.dkr.ecr.us-east-1.amazonaws.com/circle-ci-test-image-base:go1.17-tf1.2-tg37.4-pck1.8-ci50.1
+    - image: 087285199408.dkr.ecr.us-east-1.amazonaws.com/circle-ci-test-image-base:go1.18-tf1.3-tg39.1-pck1.8-ci50.7
   environment:
     GO111MODULE: auto
 version: 2.1

collections/lists.go

@@ -1,7 +1,7 @@
 package collections
 
-// Return true if the given list contains the given element
-func ListContainsElement(list []string, element string) bool {
+// ListContainsElement returns true if the given list contains the given element
+func ListContainsElement[S ~[]E, E comparable](list S, element any) bool {
 	for _, item := range list {
 		if item == element {
 			return true
@@ -11,9 +11,9 @@ func ListContainsElement(list []string, element string) bool {
 	return false
 }
 
-// Return a copy of the given list with all instances of the given element removed
-func RemoveElementFromList(list []string, element string) []string {
-	out := []string{}
+// RemoveElementFromList returns a copy of the given list with all instances of the given element removed
+func RemoveElementFromList[S ~[]E, E comparable](list S, element any) S {
+	out := S{}
 	for _, item := range list {
 		if item != element {
 			out = append(out, item)
@@ -23,23 +23,23 @@ func RemoveElementFromList(list []string, element string) []string {
 }
 
 // MakeCopyOfList will return a new list that is a copy of the given list.
-func MakeCopyOfList(list []string) []string {
-	copyOfList := make([]string, len(list))
+func MakeCopyOfList[S ~[]E, E comparable](list S) S {
+	copyOfList := make(S, len(list))
 	copy(copyOfList, list)
 	return copyOfList
 }
 
-// BatchListIntoGroupsOf will group the provided string slice into groups of size n, with the last of being truncated to
-// the remaining count of strings.  Returns nil if n is <= 0
-func BatchListIntoGroupsOf(slice []string, batchSize int) [][]string {
+// BatchListIntoGroupsOf will group the provided slice into groups of size n, with the last of being truncated to
+// the remaining count of elements.  Returns nil if n is <= 0
+func BatchListIntoGroupsOf[S ~[]E, E comparable](slice S, batchSize int) []S {
 	if batchSize <= 0 {
 		return nil
 	}
 
 	// Taken from SliceTricks: https://github.com/golang/go/wiki/SliceTricks#batching-with-minimal-allocation
 	// Intuition: We repeatedly slice off batchSize elements from slice and append it to the output, until there
 	// is not enough.
-	output := [][]string{}
+	output := []S{}
 	for batchSize < len(slice) {
 		slice, output = slice[batchSize:], append(output, slice[0:batchSize:batchSize])
 	}

collections/lists_test.go

@@ -2,20 +2,25 @@ package collections
 
 import (
 	"fmt"
-	"github.com/stretchr/testify/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-func TestMakeCopyOfListMakesACopy(t *testing.T) {
-	original := []string{"foo", "bar", "baz"}
-	copyOfList := MakeCopyOfList(original)
-	assert.Equal(t, original, copyOfList)
+func TestMakeCopyOfList(t *testing.T) {
+	originalStr := []string{"foo", "bar", "baz"}
+	copyOfListStr := MakeCopyOfList(originalStr)
+	assert.Equal(t, originalStr, copyOfListStr)
+
+	originalInt := []int{1, 2, 3}
+	copyOfListInt := MakeCopyOfList(originalInt)
+	assert.Equal(t, originalInt, copyOfListInt)
 }
 
 func TestListContainsElement(t *testing.T) {
 	t.Parallel()
 
-	testCases := []struct {
+	testCasesStr := []struct {
 		list     []string
 		element  string
 		expected bool
@@ -28,7 +33,25 @@ func TestListContainsElement(t *testing.T) {
 		{[]string{"bar", "foo", "baz"}, "", false},
 	}
 
-	for _, testCase := range testCases {
+	for _, testCase := range testCasesStr {
+		actual := ListContainsElement(testCase.list, testCase.element)
+		assert.Equal(t, testCase.expected, actual, "For list %v and element %s", testCase.list, testCase.element)
+	}
+
+	testCasesInt := []struct {
+		list     []int
+		element  int
+		expected bool
+	}{
+		{[]int{}, 0, false},
+		{[]int{}, 1, false},
+		{[]int{1}, 1, true},
+		{[]int{1, 2, 3}, 1, true},
+		{[]int{1, 2, 3}, 4, false},
+		{[]int{1, 2, 3}, 0, false},
+	}
+
+	for _, testCase := range testCasesInt {
 		actual := ListContainsElement(testCase.list, testCase.element)
 		assert.Equal(t, testCase.expected, actual, "For list %v and element %s", testCase.list, testCase.element)
 	}
@@ -37,7 +60,7 @@ func TestListContainsElement(t *testing.T) {
 func TestRemoveElementFromList(t *testing.T) {
 	t.Parallel()
 
-	testCases := []struct {
+	testCasesStr := []struct {
 		list     []string
 		element  string
 		expected []string
@@ -51,7 +74,28 @@ func TestRemoveElementFromList(t *testing.T) {
 		{[]string{"bar", "foo", "baz"}, "", []string{"bar", "foo", "baz"}},
 	}
 
-	for _, testCase := range testCases {
+	for _, testCase := range testCasesStr {
+		actual := RemoveElementFromList(testCase.list, testCase.element)
+		assert.Equal(t, testCase.expected, actual, "For list %v and element %s", testCase.list, testCase.element)
+	}
+
+	type customInt int
+
+	testCasesCustomInt := []struct {
+		list     []customInt
+		element  customInt
+		expected []customInt
+	}{
+		{[]customInt{}, 0, []customInt{}},
+		{[]customInt{}, 1, []customInt{}},
+		{[]customInt{1}, 1, []customInt{}},
+		{[]customInt{1}, 2, []customInt{1}},
+		{[]customInt{1, 2, 3}, 1, []customInt{2, 3}},
+		{[]customInt{1, 2, 3}, 4, []customInt{1, 2, 3}},
+		{[]customInt{1, 2, 3}, 0, []customInt{1, 2, 3}},
+	}
+
+	for _, testCase := range testCasesCustomInt {
 		actual := RemoveElementFromList(testCase.list, testCase.element)
 		assert.Equal(t, testCase.expected, actual, "For list %v and element %s", testCase.list, testCase.element)
 	}
@@ -60,7 +104,7 @@ func TestRemoveElementFromList(t *testing.T) {
 func TestBatchListIntoGroupsOf(t *testing.T) {
 	t.Parallel()
 
-	testCases := []struct {
+	testCasesStr := []struct {
 		stringList []string
 		n          int
 		result     [][]string
@@ -69,33 +113,26 @@ func TestBatchListIntoGroupsOf(t *testing.T) {
 			[]string{"macaroni", "gentoo", "magellanic", "adelie", "little", "king", "emperor"},
 			2,
 			[][]string{
-				[]string{"macaroni", "gentoo"},
-				[]string{"magellanic", "adelie"},
-				[]string{"little", "king"},
-				[]string{"emperor"},
+				{"macaroni", "gentoo"},
+				{"magellanic", "adelie"},
+				{"little", "king"},
+				{"emperor"},
 			},
 		},
 		{
 			[]string{"macaroni", "gentoo", "magellanic", "adelie", "king", "emperor"},
 			2,
 			[][]string{
-				[]string{"macaroni", "gentoo"},
-				[]string{"magellanic", "adelie"},
-				[]string{"king", "emperor"},
-			},
-		},
-		{
-			[]string{"macaroni", "gentoo", "magellanic"},
-			5,
-			[][]string{
-				[]string{"macaroni", "gentoo", "magellanic"},
+				{"macaroni", "gentoo"},
+				{"magellanic", "adelie"},
+				{"king", "emperor"},
 			},
 		},
 		{
 			[]string{"macaroni", "gentoo", "magellanic"},
 			5,
 			[][]string{
-				[]string{"macaroni", "gentoo", "magellanic"},
+				{"macaroni", "gentoo", "magellanic"},
 			},
 		},
 		{
@@ -115,7 +152,7 @@ func TestBatchListIntoGroupsOf(t *testing.T) {
 		},
 	}
 
-	for idx, testCase := range testCases {
+	for idx, testCase := range testCasesStr {
 		t.Run(fmt.Sprintf("%s_%d", t.Name(), idx), func(t *testing.T) {
 			t.Parallel()
 			original := MakeCopyOfList(testCase.stringList)
@@ -124,4 +161,62 @@ func TestBatchListIntoGroupsOf(t *testing.T) {
 			assert.Equal(t, testCase.stringList, original)
 		})
 	}
+
+	testCasesInt := []struct {
+		intList []int
+		n       int
+		result  [][]int
+	}{
+		{
+			[]int{1, 2, 3, 4, 5, 6, 7},
+			2,
+			[][]int{
+				{1, 2},
+				{3, 4},
+				{5, 6},
+				{7},
+			},
+		},
+		{
+			[]int{1, 2, 3, 4, 5, 6},
+			2,
+			[][]int{
+				{1, 2},
+				{3, 4},
+				{5, 6},
+			},
+		},
+		{
+			[]int{1, 2, 3},
+			5,
+			[][]int{
+				{1, 2, 3},
+			},
+		},
+		{
+			[]int{1, 2, 3},
+			-1,
+			nil,
+		},
+		{
+			[]int{1, 2, 3},
+			0,
+			nil,
+		},
+		{
+			[]int{},
+			7,
+			[][]int{},
+		},
+	}
+
+	for idx, testCase := range testCasesInt {
+		t.Run(fmt.Sprintf("%s_%d", t.Name(), idx), func(t *testing.T) {
+			t.Parallel()
+			original := MakeCopyOfList(testCase.intList)
+			assert.Equal(t, BatchListIntoGroupsOf(testCase.intList, testCase.n), testCase.result)
+			// Make sure the function doesn't modify the original list
+			assert.Equal(t, testCase.intList, original)
+		})
+	}
 }

collections/maps.go

@@ -4,34 +4,37 @@ import (
 	"fmt"
 	"sort"
 	"strings"
+
+	"golang.org/x/exp/constraints"
+	"golang.org/x/exp/maps"
 )
 
 const (
 	DefaultKeyValueStringSliceFormat = "%s=%s"
 )
 
-// Merge all the maps into one. Sadly, Go has no generics, so this is only defined for string to interface maps.
-func MergeMaps(maps ...map[string]interface{}) map[string]interface{} {
-	out := map[string]interface{}{}
+// MergeMaps merges all the maps into one
+func MergeMaps[K comparable, V any](mapsToMerge ...map[K]V) map[K]V {
+	out := map[K]V{}
 
-	for _, currMap := range maps {
-		for key, value := range currMap {
-			out[key] = value
-		}
+	for _, currMap := range mapsToMerge {
+		maps.Copy(out, currMap)
 	}
 
 	return out
 }
 
-// Return the keys for the given map, sorted alphabetically
-func Keys(m map[string]string) []string {
-	out := []string{}
+// Keys returns the keys for the given map, sorted
+func Keys[K constraints.Ordered, V any](m map[K]V) []K {
+	out := []K{}
 
-	for key, _ := range m {
+	for key := range m {
 		out = append(out, key)
 	}
 
-	sort.Strings(out)
+	sort.Slice(out, func(i, j int) bool {
+		return out[i] < out[j]
+	})
 
 	return out
 }
@@ -42,8 +45,8 @@ func KeyValueStringSlice(m map[string]string) []string {
 }
 
 // KeyValueStringSliceWithFormat returns a string slice using the specified format, sorted alphabetically.
-// The format should consist of at least two '%s' string verbs.
-func KeyValueStringSliceWithFormat(m map[string]string, format string) []string {
+// The format should consist of at least two format specifiers.
+func KeyValueStringSliceWithFormat[K comparable, V any](m map[K]V, format string) []string {
 	out := []string{}
 
 	for key, value := range m {