Add Generics to go-linq

aggregate.go

@@ -46,6 +46,21 @@ func (q Query) AggregateT(f interface{}) interface{} {
 	return q.Aggregate(fFunc)
 }
 
+func (q QueryG[T]) Aggregate(f func(T, T) T) T {
+	next := q.Iterate()
+
+	result, any := next()
+	if !any {
+		return *new(T)
+	}
+
+	for current, ok := next(); ok; current, ok = next() {
+		result = f(result, current)
+	}
+
+	return result
+}
+
 // AggregateWithSeed applies an accumulator function over a sequence. The
 // specified seed value is used as the initial accumulator value.
 //
@@ -93,6 +108,17 @@ func (q Query) AggregateWithSeedT(seed interface{},
 	return q.AggregateWithSeed(seed, fFunc)
 }
 
+func (q QueryG[T]) AggregateWithSeed(seed T, f func(T, T) T) T {
+	next := q.Iterate()
+	result := seed
+
+	for current, ok := next(); ok; current, ok = next() {
+		result = f(result, current)
+	}
+
+	return result
+}
+
 // AggregateWithSeedBy applies an accumulator function over a sequence. The
 // specified seed value is used as the initial accumulator value, and the
 // specified function is used to select the result value.
@@ -156,3 +182,7 @@ func (q Query) AggregateWithSeedByT(seed interface{},
 
 	return q.AggregateWithSeedBy(seed, fFunc, resultSelectorFunc)
 }
+
+func (q QueryG[T]) AggregateWithSeedBy(seed T, f func(T, T) T, resultSelector func(T) interface{}) interface{} {
+	return resultSelector(q.AggregateWithSeed(seed, f))
+}

aggregate_test.go

@@ -1,6 +1,9 @@
 package linq
 
-import "testing"
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
 import "strings"
 
 func TestAggregate(t *testing.T) {
@@ -26,6 +29,42 @@ func TestAggregate(t *testing.T) {
 	}
 }
 
+func TestAggregateG(t *testing.T) {
+	input := []string{"apple", "mango", "orange", "passionfruit", "grape"}
+	expected := "passionfruit"
+	actual := FromSliceG(input).Aggregate(func(r, i string) string {
+		if len(r) > len(i) {
+			return r
+		}
+		return i
+	})
+	assert.Equal(t, expected, actual)
+}
+
+func TestAggregateSumG(t *testing.T) {
+	input := []int{1, 2, 3, 4}
+	expected := 10
+	actual := FromSliceG(input).Aggregate(func(i1, i2 int) int {
+		return i1 + i2
+	})
+	assert.Equal(t, expected, actual)
+}
+
+func TestAggregateWithSeedG(t *testing.T) {
+	input := []int{1, 2, 3, 4}
+	expected := 15
+	actual := FromSliceG(input).AggregateWithSeed(5, func(i1, i2 int) int {
+		return i1 + i2
+	})
+	assert.Equal(t, expected, actual)
+	input = []int{}
+	expected = 5
+	actual = FromSliceG(input).AggregateWithSeed(5, func(i1, i2 int) int {
+		return i1 + i2
+	})
+	assert.Equal(t, expected, actual)
+}
+
 func TestAggregateT_PanicWhenFunctionIsInvalid(t *testing.T) {
 	mustPanicWithError(t, "AggregateT: parameter [f] has a invalid function signature. Expected: 'func(T,T)T', actual: 'func(int,string,string)string'", func() {
 		From([]int{1, 1, 1, 2, 1, 2, 3, 4, 2}).AggregateT(func(x int, r string, i string) string {
@@ -117,3 +156,22 @@ func TestAggregateWithSeedByT_PanicWhenResultSelectorFnIsInvalid(t *testing.T) {
 		)
 	})
 }
+
+func TestAggregateWithSeedByG(t *testing.T) {
+	input := []string{"apple", "mango", "orange", "passionfruit", "grape"}
+	expected := "PASSIONFRUIT"
+
+	actual := FromSliceG(input).AggregateWithSeedBy("banana",
+		func(r, i string) string {
+			if len(r) > len(i) {
+				return r
+			}
+			return i
+		},
+		func(r string) interface{} {
+			return strings.ToUpper(r)
+		},
+	).(string)
+
+	assert.Equal(t, expected, actual)
+}

concat.go

@@ -25,6 +25,29 @@ func (q Query) Append(item interface{}) Query {
 	}
 }
 
+func (q QueryG[T]) Append(item T) QueryG[T] {
+	return QueryG[T]{
+		Iterate: func() IteratorG[T] {
+			next := q.Iterate()
+			appended := false
+
+			return func() (T, bool) {
+				i, ok := next()
+				if ok {
+					return i, ok
+				}
+
+				if !appended {
+					appended = true
+					return item, true
+				}
+
+				return *new(T), false
+			}
+		},
+	}
+}
+
 // Concat concatenates two collections.
 //
 // The Concat method differs from the Union method because the Concat method
@@ -53,6 +76,29 @@ func (q Query) Concat(q2 Query) Query {
 	}
 }
 
+func (q QueryG[T]) Concat(q2 QueryG[T]) QueryG[T] {
+	return QueryG[T]{
+		Iterate: func() IteratorG[T] {
+			next := q.Iterate()
+			next2 := q2.Iterate()
+			use1 := true
+
+			return func() (item T, ok bool) {
+				if use1 {
+					item, ok = next()
+					if ok {
+						return
+					}
+
+					use1 = false
+				}
+
+				return next2()
+			}
+		},
+	}
+}
+
 // Prepend inserts an item to the beginning of a collection, so it becomes the
 // first item.
 func (q Query) Prepend(item interface{}) Query {
@@ -72,3 +118,21 @@ func (q Query) Prepend(item interface{}) Query {
 		},
 	}
 }
+
+func (q QueryG[T]) Prepend(item T) QueryG[T] {
+	return QueryG[T]{
+		Iterate: func() IteratorG[T] {
+			next := q.Iterate()
+			prepended := false
+
+			return func() (T, bool) {
+				if prepended {
+					return next()
+				}
+
+				prepended = true
+				return item, true
+			}
+		},
+	}
+}

concat_test.go

@@ -1,6 +1,9 @@
 package linq
 
-import "testing"
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
 
 func TestAppend(t *testing.T) {
 	input := []int{1, 2, 3, 4}
@@ -11,6 +14,13 @@ func TestAppend(t *testing.T) {
 	}
 }
 
+func TestAppendG(t *testing.T) {
+	input := []int{1, 2, 3, 4}
+	expected := []int{1, 2, 3, 4, 5}
+	actual := FromSliceG(input).Append(5).ToSlice()
+	assert.Equal(t, expected, actual)
+}
+
 func TestConcat(t *testing.T) {
 	input1 := []int{1, 2, 3}
 	input2 := []int{4, 5}
@@ -21,6 +31,14 @@ func TestConcat(t *testing.T) {
 	}
 }
 
+func TestConcatG(t *testing.T) {
+	input1 := []int{1, 2, 3}
+	input2 := []int{4, 5}
+	expected := []int{1, 2, 3, 4, 5}
+	actual := FromSliceG(input1).Concat(FromSliceG(input2)).ToSlice()
+	assert.Equal(t, expected, actual)
+}
+
 func TestPrepend(t *testing.T) {
 	input := []int{1, 2, 3, 4}
 	want := []interface{}{0, 1, 2, 3, 4}
@@ -29,3 +47,10 @@ func TestPrepend(t *testing.T) {
 		t.Errorf("From(%v).Prepend()=%v expected %v", input, toSlice(q), want)
 	}
 }
+
+func TestPrependG(t *testing.T) {
+	input := []int{1, 2, 3, 4}
+	want := []int{0, 1, 2, 3, 4}
+	actual := FromSliceG(input).Prepend(0).ToSlice()
+	assert.Equal(t, want, actual)
+}

defaultifempty.go

@@ -31,3 +31,33 @@ func (q Query) DefaultIfEmpty(defaultValue interface{}) Query {
 		},
 	}
 }
+
+func (q QueryG[T]) DefaultIfEmpty(defaultValue T) QueryG[T] {
+	return QueryG[T]{
+		Iterate: func() IteratorG[T] {
+			next := q.Iterate()
+			state := 1
+
+			return func() (item T, ok bool) {
+				switch state {
+				case 1:
+					item, ok = next()
+					if ok {
+						state = 2
+					} else {
+						item = defaultValue
+						ok = true
+						state = -1
+					}
+					return
+				case 2:
+					for item, ok = next(); ok; item, ok = next() {
+						return
+					}
+					return
+				}
+				return
+			}
+		},
+	}
+}

defaultifempty_test.go

@@ -1,6 +1,7 @@
 package linq
 
 import (
+	"github.com/stretchr/testify/assert"
 	"testing"
 )
 
@@ -23,3 +24,21 @@ func TestDefaultIfEmpty(t *testing.T) {
 	}
 
 }
+
+func TestDefaultIfEmptyG(t *testing.T) {
+	defaultValue := 0
+	tests := []struct {
+		input []int
+		want  []int
+	}{
+		{[]int{}, []int{defaultValue}},
+		{[]int{1, 2, 3, 4, 5}, []int{1, 2, 3, 4, 5}},
+	}
+
+	for _, test := range tests {
+		actual := FromSliceG(test.input).DefaultIfEmpty(defaultValue).ToSlice()
+
+		assert.Equal(t, test.want, actual)
+	}
+
+}

distinct.go

@@ -22,6 +22,10 @@ func (q Query) Distinct() Query {
 	}
 }
 
+func (q QueryG[T]) Distinct() QueryG[T] {
+	return AsQueryG[T](q.AsQuery().Distinct())
+}
+
 // Distinct method returns distinct elements from a collection. The result is an
 // ordered collection that contains no duplicate values.
 //
@@ -50,6 +54,10 @@ func (oq OrderedQuery) Distinct() OrderedQuery {
 	}
 }
 
+func (q OrderedQueryG[T]) Distinct() OrderedQueryG[T] {
+	return asOrderQueryG[T](q.orderedQuery.Distinct())
+}
+
 // DistinctBy method returns distinct elements from a collection. This method
 // executes selector function for each element to determine a value to compare.
 // The result is an unordered collection that contains no duplicate values.
@@ -74,6 +82,12 @@ func (q Query) DistinctBy(selector func(interface{}) interface{}) Query {
 	}
 }
 
+func (e *Expended[T1, T2]) DistinctBy(selector func(T1) T2) QueryG[T1] {
+	return AsQueryG[T1](e.q.AsQuery().DistinctBy(func(i interface{}) interface{} {
+		return selector(i.(T1))
+	}))
+}
+
 // DistinctByT is the typed version of DistinctBy.
 //
 //   - selectorFn is of type "func(TSource) TSource".