go-linq v4 (#125)

Author: kalaninja

README.md

@@ -12,12 +12,12 @@ A powerful language integrated query (LINQ) library for Go.
 
 When used with Go modules, use the following import path:
 
-    go get github.com/ahmetb/go-linq/v3
+    go get github.com/ahmetb/go-linq/v4
 
 Older versions of Go using different dependency management tools can use the
 following import path to prevent breaking API changes:
 
-    go get gopkg.in/ahmetb/go-linq.v3
+    go get gopkg.in/ahmetb/go-linq.v4
 
 ## Quickstart
 
@@ -28,7 +28,7 @@ Usage is as easy as chaining methods like:
 **Example 1: Find all owners of cars manufactured after 2015**
 
 ```go
-import . "github.com/ahmetb/go-linq/v3"
+import . "github.com/ahmetb/go-linq/v4"
 
 type Car struct {
     year int
@@ -40,9 +40,9 @@ type Car struct {
 
 var owners []string
 
-From(cars).Where(func(c interface{}) bool {
+FromSlice(cars).Where(func(c any) bool {
 	return c.(Car).year >= 2015
-}).Select(func(c interface{}) interface{} {
+}).Select(func(c any) any {
 	return c.(Car).owner
 }).ToSlice(&owners)
 ```
@@ -53,7 +53,7 @@ Or, you can use generic functions, like `WhereT` and `SelectT` to simplify your
 ```go
 var owners []string
 
-From(cars).WhereT(func(c Car) bool {
+FromSlice(cars).WhereT(func(c Car) bool {
 	return c.year >= 2015
 }).SelectT(func(c Car) string {
 	return c.owner
@@ -63,27 +63,27 @@ From(cars).WhereT(func(c Car) bool {
 **Example 2: Find the author who has written the most books**
 
 ```go
-import . "github.com/ahmetb/go-linq/v3"
+import . "github.com/ahmetb/go-linq/v4"
 
 type Book struct {
 	id      int
 	title   string
 	authors []string
 }
 
-author := From(books).SelectMany( // make a flat array of authors
-	func(book interface{}) Query {
+author := FromSlice(books).SelectMany( // make a flat array of authors
+	func(book any) Query {
 		return From(book.(Book).authors)
 	}).GroupBy( // group by author
-	func(author interface{}) interface{} {
+	func(author any) any {
 		return author // author as key
-	}, func(author interface{}) interface{} {
+	}, func(author any) any {
 		return author // author as value
 	}).OrderByDescending( // sort groups by its length
-	func(group interface{}) interface{} {
+	func(group any) any {
 		return len(group.(Group).Group)
 	}).Select( // get authors out of groups
-	func(group interface{}) interface{} {
+	func(group any) any {
 		return group.(Group).Key
 	}).First() // take the first author
 ```
@@ -94,21 +94,16 @@ author := From(books).SelectMany( // make a flat array of authors
 type MyQuery Query
 
 func (q MyQuery) GreaterThan(threshold int) Query {
-	return Query{
-		Iterate: func() Iterator {
-			next := q.Iterate()
-
-			return func() (item interface{}, ok bool) {
-				for item, ok = next(); ok; item, ok = next() {
-					if item.(int) > threshold {
-						return
-					}
-				}
-
-				return
-			}
-		},
-	}
+    return Query{
+        Iterate: func(yield func(any) bool) {
+            q.Iterate(func(item any) bool {
+                if item.(int) > threshold {
+                    return yield(item)
+                }
+                return true
+            })
+        },
+    }
 }
 
 result := MyQuery(Range(1,10)).GreaterThan(5).Results()
@@ -117,25 +112,25 @@ result := MyQuery(Range(1,10)).GreaterThan(5).Results()
 ## Generic Functions
 
 Although Go doesn't implement generics, with some reflection tricks, you can use go-linq without
-typing `interface{}`s and type assertions. This will introduce a performance penalty (5x-10x slower)
+typing `any`s and type assertions. This will introduce a performance penalty (5x-10x slower)
 but will yield in a cleaner and more readable code.
 
 Methods with `T` suffix (such as `WhereT`) accept functions with generic types. So instead of
 
-    .Select(func(v interface{}) interface{} {...})
+    .Select(func(v any) any {...})
 
 you can type:
 
     .SelectT(func(v YourType) YourOtherType {...})
 
-This will make your code free of `interface{}` and type assertions.
+This will make your code free of `any` and type assertions.
 
 **Example 4: "MapReduce" in a slice of string sentences to list the top 5 most used words using generic functions**
 
 ```go
 var results []string
 
-From(sentences).
+FromSlice(sentences).
 	// split sentences to words
 	SelectManyT(func(sentence string) Query {
 		return From(strings.Split(sentence, " "))
@@ -161,11 +156,49 @@ From(sentences).
 	ToSlice(&results)
 ```
 
+## Manual Iteration
+
+Since **go-linq v4** manual iteration follows Go’s standard iterator pattern introduced with the `iter` package.
+The Query type exposes an `Iterate` field of type `iter.Seq[any]`, making it easier to integrate with Go’s native
+iteration style.
+
+**Example 5: Iterate over a query using the standard `for ... range` loop**
+
+```go
+q := FromSlice([]int{1, 2, 3, 4})
+
+for v := range q.Iterate {
+	fmt.Println(v)
+}
+```
+
 **More examples** can be found in the [documentation](https://godoc.org/github.com/ahmetb/go-linq).
 
+## Data Source Constructors
+
+Since **go-linq v4**, a new family of constructor functions provides a type-safe and efficient way to create queries from
+various data sources. Each function is optimized for its specific input type, avoiding the overhead of reflection.
+
+Available constructors:
+- `FromSlice` - creates a query from a slice
+- `FromMap` - creates a query from a map
+- `FromChannel` - creates a query from a channel
+- `FromChannelWithContext` - creates a query from a channel with `Context` support
+- `FromString` - creates a query from a string (iterating over runes)
+- `FromIterable` - creates a query from a custom collection implementing the `Iterable` interface
+
+The older `From` function remains available for backward compatibility, but it relies on runtime reflection and is
+significantly less efficient. For all new code, it’s recommended to use the explicit `From*` constructors.
+
 ## Release Notes
 
 ```text
+v4.0.0 (2025-10-12)
+* Breaking change: Migrated to standard Go iterator pattern. (thanks @kalaninja!)
+* Added typed constructors: FromSlice(), FromMap(), FromChannel(),
+ FromChannelWithContext(), FromString().
+* Breaking change: Removed FromChannelT() in favor of FromChannel().
+
 v3.2.0 (2020-12-29)
 * Added FromChannelT().
 * Added DefaultIfEmpty().

aggregate.go

@@ -1,20 +1,23 @@
 package linq
 
+import "iter"
+
 // Aggregate applies an accumulator function over a sequence.
 //
 // Aggregate method makes it simple to perform a calculation over a sequence of
-// values. This method works by calling f() one time for each element in source
+// values. This method works by calling f() one time for each element in a source
 // except the first one. Each time f() is called, Aggregate passes both the
 // element from the sequence and an aggregated value (as the first argument to
-// f()). The first element of source is used as the initial aggregate value. The
+// f()). The first element of the source is used as the initial aggregate value. The
 // result of f() replaces the previous aggregated value.
 //
 // Aggregate returns the final result of f().
-func (q Query) Aggregate(f func(interface{}, interface{}) interface{}) interface{} {
-	next := q.Iterate()
+func (q Query) Aggregate(f func(accumulator, item any) any) any {
+	next, stop := iter.Pull(q.Iterate)
+	defer stop()
 
-	result, any := next()
-	if !any {
+	result, ok := next()
+	if !ok {
 		return nil
 	}
 
@@ -30,7 +33,7 @@ func (q Query) Aggregate(f func(interface{}, interface{}) interface{}) interface
 //   - f is of type: func(TSource, TSource) TSource
 //
 // NOTE: Aggregate has better performance than AggregateT.
-func (q Query) AggregateT(f interface{}) interface{} {
+func (q Query) AggregateT(f any) any {
 	fGenericFunc, err := newGenericFunc(
 		"AggregateT", "f", f,
 		simpleParamValidator(newElemTypeSlice(new(genericType), new(genericType)), newElemTypeSlice(new(genericType))),
@@ -39,7 +42,7 @@ func (q Query) AggregateT(f interface{}) interface{} {
 		panic(err)
 	}
 
-	fFunc := func(result interface{}, current interface{}) interface{} {
+	fFunc := func(result any, current any) any {
 		return fGenericFunc.Call(result, current)
 	}
 
@@ -50,20 +53,18 @@ func (q Query) AggregateT(f interface{}) interface{} {
 // specified seed value is used as the initial accumulator value.
 //
 // Aggregate method makes it simple to perform a calculation over a sequence of
-// values. This method works by calling f() one time for each element in source
+// values. This method works by calling f() one time for each element in a source
 // except the first one. Each time f() is called, Aggregate passes both the
 // element from the sequence and an aggregated value (as the first argument to
 // f()). The value of the seed parameter is used as the initial aggregate value.
 // The result of f() replaces the previous aggregated value.
 //
 // Aggregate returns the final result of f().
-func (q Query) AggregateWithSeed(seed interface{},
-	f func(interface{}, interface{}) interface{}) interface{} {
-
-	next := q.Iterate()
+func (q Query) AggregateWithSeed(seed any,
+	f func(accumulator, item any) any) any {
 	result := seed
 
-	for current, ok := next(); ok; current, ok = next() {
+	for current := range q.Iterate {
 		result = f(result, current)
 	}
 
@@ -76,8 +77,8 @@ func (q Query) AggregateWithSeed(seed interface{},
 //
 // NOTE: AggregateWithSeed has better performance than
 // AggregateWithSeedT.
-func (q Query) AggregateWithSeedT(seed interface{},
-	f interface{}) interface{} {
+func (q Query) AggregateWithSeedT(seed any,
+	f any) any {
 	fGenericFunc, err := newGenericFunc(
 		"AggregateWithSeed", "f", f,
 		simpleParamValidator(newElemTypeSlice(new(genericType), new(genericType)), newElemTypeSlice(new(genericType))),
@@ -86,7 +87,7 @@ func (q Query) AggregateWithSeedT(seed interface{},
 		panic(err)
 	}
 
-	fFunc := func(result interface{}, current interface{}) interface{} {
+	fFunc := func(result any, current any) any {
 		return fGenericFunc.Call(result, current)
 	}
 
@@ -106,14 +107,13 @@ func (q Query) AggregateWithSeedT(seed interface{},
 //
 // The final result of func is passed to resultSelector to obtain the final
 // result of Aggregate.
-func (q Query) AggregateWithSeedBy(seed interface{},
-	f func(interface{}, interface{}) interface{},
-	resultSelector func(interface{}) interface{}) interface{} {
+func (q Query) AggregateWithSeedBy(seed any,
+	f func(accumulator, item any) any,
+	resultSelector func(any) any) any {
 
-	next := q.Iterate()
 	result := seed
 
-	for current, ok := next(); ok; current, ok = next() {
+	for current := range q.Iterate {
 		result = f(result, current)
 	}
 
@@ -127,9 +127,9 @@ func (q Query) AggregateWithSeedBy(seed interface{},
 //
 // NOTE: AggregateWithSeedBy has better performance than
 // AggregateWithSeedByT.
-func (q Query) AggregateWithSeedByT(seed interface{},
-	f interface{},
-	resultSelectorFn interface{}) interface{} {
+func (q Query) AggregateWithSeedByT(seed any,
+	f any,
+	resultSelectorFn any) any {
 	fGenericFunc, err := newGenericFunc(
 		"AggregateWithSeedByT", "f", f,
 		simpleParamValidator(newElemTypeSlice(new(genericType), new(genericType)), newElemTypeSlice(new(genericType))),
@@ -138,7 +138,7 @@ func (q Query) AggregateWithSeedByT(seed interface{},
 		panic(err)
 	}
 
-	fFunc := func(result interface{}, current interface{}) interface{} {
+	fFunc := func(result any, current any) any {
 		return fGenericFunc.Call(result, current)
 	}
 
@@ -150,7 +150,7 @@ func (q Query) AggregateWithSeedByT(seed interface{},
 		panic(err)
 	}
 
-	resultSelectorFunc := func(result interface{}) interface{} {
+	resultSelectorFunc := func(result any) any {
 		return resultSelectorGenericFunc.Call(result)
 	}
 

aggregate_test.go

@@ -5,15 +5,15 @@ import "strings"
 
 func TestAggregate(t *testing.T) {
 	tests := []struct {
-		input interface{}
-		want  interface{}
+		input any
+		want  any
 	}{
 		{[]string{"apple", "mango", "orange", "passionfruit", "grape"}, "passionfruit"},
 		{[]string{}, nil},
 	}
 
 	for _, test := range tests {
-		r := From(test.input).Aggregate(func(r interface{}, i interface{}) interface{} {
+		r := From(test.input).Aggregate(func(r any, i any) any {
 			if len(r.(string)) > len(i.(string)) {
 				return r
 			}
@@ -42,7 +42,7 @@ func TestAggregateWithSeed(t *testing.T) {
 	want := "passionfruit"
 
 	r := From(input).AggregateWithSeed(want,
-		func(r interface{}, i interface{}) interface{} {
+		func(r any, i any) any {
 			if len(r.(string)) > len(i.(string)) {
 				return r
 			}
@@ -70,13 +70,13 @@ func TestAggregateWithSeedBy(t *testing.T) {
 	want := "PASSIONFRUIT"
 
 	r := From(input).AggregateWithSeedBy("banana",
-		func(r interface{}, i interface{}) interface{} {
+		func(r any, i any) any {
 			if len(r.(string)) > len(i.(string)) {
 				return r
 			}
 			return i
 		},
-		func(r interface{}) interface{} {
+		func(r any) any {
 			return strings.ToUpper(r.(string))
 		},
 	)