initial release

Author: solsw

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021-2023 Oleg Subachev
+Copyright (c) 2021-2024 Oleg Subachev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,26 +1,26 @@
 # go2linq
 [![Go Reference](https://pkg.go.dev/badge/github.com/solsw/go2linq.svg)](https://pkg.go.dev/github.com/solsw/go2linq/v3)
 
-**go2linq** is Go implementation of .NET's 
+**go2linq v4** is Go implementation of .NET's 
 [LINQ to Objects](https://learn.microsoft.com/dotnet/csharp/programming-guide/concepts/linq/linq-to-objects).
 (See also: [Language Integrated Query](https://en.wikipedia.org/wiki/Language_Integrated_Query),
 [LINQ](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/linq/),
 [Enumerable Class](https://learn.microsoft.com/dotnet/api/system.linq.enumerable).)
 
-**go2linq** was initially inspired by Jon Skeet's [Edulinq series](https://codeblog.jonskeet.uk/category/edulinq/).
+**go2linq v4** is based on [iter.Seq](https://go.dev/wiki/RangefuncExperiment), so it requires setting *GOEXPERIMENT=rangefunc* when executing **go** commands.
 
 ---
 
 ## Installation
 
 ```
-go get github.com/solsw/go2linq/v3
+go get github.com/solsw/go2linq/v4
 ```
 
 ## Examples
 
 Examples of **go2linq** usage are in the `Example...` functions in test files
-(see [Examples](https://pkg.go.dev/github.com/solsw/go2linq/v3#pkg-examples)).
+(see [Examples](https://pkg.go.dev/github.com/solsw/go2linq/v4#pkg-examples)).
 
 ### Quick and easy example:
 
@@ -30,21 +30,19 @@ package main
 import (
 	"fmt"
 
-	"github.com/solsw/go2linq/v3"
+	"github.com/solsw/go2linq/v4"
 )
 
 func main() {
-	filter := go2linq.WhereMust(
-		go2linq.NewEnSlice(1, 2, 3, 4, 5, 6, 7, 8),
+	filter, _ := go2linq.Where(
+		go2linq.VarAll(1, 2, 3, 4, 5, 6, 7, 8),
 		func(i int) bool { return i > 6 || i%2 == 0 },
 	)
-	squares := go2linq.SelectMust(
+	squares, _ := go2linq.Select(
 		filter,
 		func(i int) string { return fmt.Sprintf("%d: %d", i, i*i) },
 	)
-	enr := squares.GetEnumerator()
-	for enr.MoveNext() {
-		square := enr.Current()
+	for square := range squares {
 		fmt.Println(square)
 	}
 }

aggregate.go

@@ -1,72 +1,64 @@
 package go2linq
 
 import (
-	"github.com/solsw/errorhelper"
+	"iter"
+
 	"github.com/solsw/generichelper"
 )
 
-// Reimplementing LINQ to Objects: Part 13 - Aggregate
-// https://codeblog.jonskeet.uk/2010/12/30/reimplementing-linq-to-objects-part-13-aggregate/
-// https://learn.microsoft.com/dotnet/api/system.linq.enumerable.aggregate
-
 // [Aggregate] applies an accumulator function over a sequence.
 //
 // [Aggregate]: https://learn.microsoft.com/dotnet/api/system.linq.enumerable.aggregate
-func Aggregate[Source any](source Enumerable[Source], accumulator func(Source, Source) Source) (Source, error) {
+func Aggregate[Source any](source iter.Seq[Source], accumulator func(Source, Source) Source) (Source, error) {
 	if source == nil {
 		return generichelper.ZeroValue[Source](), ErrNilSource
 	}
 	if accumulator == nil {
 		return generichelper.ZeroValue[Source](), ErrNilAccumulator
 	}
-	enr := source.GetEnumerator()
-	if !enr.MoveNext() {
-		return generichelper.ZeroValue[Source](), ErrEmptySource
+	var res Source
+	empty := true
+	first := true
+	for s := range source {
+		empty = false
+		if first {
+			first = false
+			res = s
+			continue
+		}
+		res = accumulator(res, s)
 	}
-	r := enr.Current()
-	for enr.MoveNext() {
-		r = accumulator(r, enr.Current())
+	if empty {
+		return generichelper.ZeroValue[Source](), ErrEmptySource
 	}
-	return r, nil
-}
-
-// AggregateMust is like [Aggregate] but panics in case of error.
-func AggregateMust[Source any](source Enumerable[Source], accumulator func(Source, Source) Source) Source {
-	return errorhelper.Must(Aggregate(source, accumulator))
+	return res, nil
 }
 
 // [AggregateSeed] applies an accumulator function over a sequence.
 // The specified seed value is used as the initial accumulator value.
 //
 // [AggregateSeed]: https://learn.microsoft.com/dotnet/api/system.linq.enumerable.aggregate
-func AggregateSeed[Source, Accumulate any](source Enumerable[Source],
+func AggregateSeed[Source, Accumulate any](source iter.Seq[Source],
 	seed Accumulate, accumulator func(Accumulate, Source) Accumulate) (Accumulate, error) {
 	if source == nil {
 		return generichelper.ZeroValue[Accumulate](), ErrNilSource
 	}
 	if accumulator == nil {
 		return generichelper.ZeroValue[Accumulate](), ErrNilAccumulator
 	}
-	enr := source.GetEnumerator()
-	r := seed
-	for enr.MoveNext() {
-		r = accumulator(r, enr.Current())
+	res := seed
+	for s := range source {
+		res = accumulator(res, s)
 	}
-	return r, nil
-}
-
-// AggregateSeedMust is like [AggregateSeed] but panics in case of error.
-func AggregateSeedMust[Source, Accumulate any](source Enumerable[Source],
-	seed Accumulate, accumulator func(Accumulate, Source) Accumulate) Accumulate {
-	return errorhelper.Must(AggregateSeed(source, seed, accumulator))
+	return res, nil
 }
 
 // [AggregateSeedSel] 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.
 //
 // [AggregateSeedSel]: https://learn.microsoft.com/dotnet/api/system.linq.enumerable.aggregate
-func AggregateSeedSel[Source, Accumulate, Result any](source Enumerable[Source], seed Accumulate,
+func AggregateSeedSel[Source, Accumulate, Result any](source iter.Seq[Source], seed Accumulate,
 	accumulator func(Accumulate, Source) Accumulate, resultSelector func(Accumulate) Result) (Result, error) {
 	if source == nil {
 		return generichelper.ZeroValue[Result](), ErrNilSource
@@ -77,16 +69,9 @@ func AggregateSeedSel[Source, Accumulate, Result any](source Enumerable[Source],
 	if resultSelector == nil {
 		return generichelper.ZeroValue[Result](), ErrNilSelector
 	}
-	enr := source.GetEnumerator()
-	r := seed
-	for enr.MoveNext() {
-		r = accumulator(r, enr.Current())
+	res := seed
+	for s := range source {
+		res = accumulator(res, s)
 	}
-	return resultSelector(r), nil
-}
-
-// AggregateSeedSelMust is like [AggregateSeedSel] but panics in case of error.
-func AggregateSeedSelMust[Source, Accumulate, Result any](source Enumerable[Source], seed Accumulate,
-	accumulator func(Accumulate, Source) Accumulate, resultSelector func(Accumulate) Result) Result {
-	return errorhelper.Must(AggregateSeedSel(source, seed, accumulator, resultSelector))
+	return resultSelector(res), nil
 }

aggregate_test.go

@@ -2,6 +2,7 @@ package go2linq
 
 import (
 	"fmt"
+	"iter"
 	"reflect"
 	"strings"
 	"testing"
@@ -11,7 +12,7 @@ import (
 
 func TestAggregate_int(t *testing.T) {
 	type args struct {
-		source      Enumerable[int]
+		source      iter.Seq[int]
 		accumulator func(int, int) int
 	}
 	tests := []struct {
@@ -31,15 +32,15 @@ func TestAggregate_int(t *testing.T) {
 		},
 		{name: "NullFuncUnseeded",
 			args: args{
-				source:      NewEnSlice(1, 3),
+				source:      VarAll(1, 3),
 				accumulator: nil,
 			},
 			wantErr:     true,
 			expectedErr: ErrNilAccumulator,
 		},
 		{name: "UnseededAggregation",
 			args: args{
-				source:      NewEnSlice(1, 4, 5),
+				source:      VarAll(1, 4, 5),
 				accumulator: func(ag, el int) int { return ag*2 + el },
 			},
 			want: 17,
@@ -54,14 +55,14 @@ func TestAggregate_int(t *testing.T) {
 		},
 		{name: "UnseededSingleElementAggregation",
 			args: args{
-				source:      NewEnSlice(1),
+				source:      VarAll(1),
 				accumulator: func(ag, el int) int { return ag*2 + el },
 			},
 			want: 1,
 		},
 		{name: "FirstElementOfInputIsUsedAsSeedForUnseededOverload",
 			args: args{
-				source:      NewEnSlice(5, 3, 2),
+				source:      VarAll(5, 3, 2),
 				accumulator: func(ag, el int) int { return ag * el },
 			},
 			want: 30,
@@ -89,7 +90,7 @@ func TestAggregate_int(t *testing.T) {
 
 func TestAggregateSeed_int_int(t *testing.T) {
 	type args struct {
-		source      Enumerable[int]
+		source      iter.Seq[int]
 		seed        int
 		accumulator func(int, int) int
 	}
@@ -111,7 +112,7 @@ func TestAggregateSeed_int_int(t *testing.T) {
 		},
 		{name: "NullFuncSeeded",
 			args: args{
-				source:      NewEnSlice(1, 3),
+				source:      VarAll(1, 3),
 				seed:        5,
 				accumulator: nil,
 			},
@@ -120,7 +121,7 @@ func TestAggregateSeed_int_int(t *testing.T) {
 		},
 		{name: "SeededAggregation",
 			args: args{
-				source:      NewEnSlice(1, 4, 5),
+				source:      VarAll(1, 4, 5),
 				seed:        5,
 				accumulator: func(ac, el int) int { return ac*2 + el },
 			},
@@ -155,20 +156,21 @@ func TestAggregateSeed_int_int(t *testing.T) {
 	}
 }
 
-func TestAggregateSeedMust_int32_int64(t *testing.T) {
+func TestAggregateSeed_int32_int64(t *testing.T) {
 	type args struct {
-		source      Enumerable[int32]
+		source      iter.Seq[int32]
 		seed        int64
 		accumulator func(int64, int32) int64
 	}
 	tests := []struct {
-		name string
-		args args
-		want int64
+		name    string
+		args    args
+		want    int64
+		wantErr bool
 	}{
 		{name: "DifferentSourceAndAccumulatorTypes",
 			args: args{
-				source:      NewEnSlice(int32(2000000000), int32(2000000000), int32(2000000000)),
+				source:      VarAll(int32(2000000000), int32(2000000000), int32(2000000000)),
 				seed:        int64(0),
 				accumulator: func(ac int64, el int32) int64 { return ac + int64(el) },
 			},
@@ -177,17 +179,21 @@ func TestAggregateSeedMust_int32_int64(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := AggregateSeedMust(tt.args.source, tt.args.seed, tt.args.accumulator)
+			got, err := AggregateSeed(tt.args.source, tt.args.seed, tt.args.accumulator)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("AggregateSeed() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
 			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("AggregateSeedMust() = %v, want %v", got, tt.want)
+				t.Errorf("AggregateSeed() = %v, want %v", got, tt.want)
 			}
 		})
 	}
 }
 
 func TestAggregateSeedSel_int_int_string(t *testing.T) {
 	type args struct {
-		source         Enumerable[int]
+		source         iter.Seq[int]
 		seed           int
 		accumulator    func(int, int) int
 		resultSelector func(int) string
@@ -211,7 +217,7 @@ func TestAggregateSeedSel_int_int_string(t *testing.T) {
 		},
 		{name: "NullFuncSeededWithResultSelector",
 			args: args{
-				source:         NewEnSlice(1, 3),
+				source:         VarAll(1, 3),
 				seed:           5,
 				accumulator:    nil,
 				resultSelector: func(r int) string { return fmt.Sprint(r) },
@@ -221,7 +227,7 @@ func TestAggregateSeedSel_int_int_string(t *testing.T) {
 		},
 		{name: "NullProjectionSeededWithResultSelector",
 			args: args{
-				source:         NewEnSlice(1, 3),
+				source:         VarAll(1, 3),
 				seed:           5,
 				accumulator:    func(ac, el int) int { return ac + el },
 				resultSelector: nil,
@@ -231,7 +237,7 @@ func TestAggregateSeedSel_int_int_string(t *testing.T) {
 		},
 		{name: "SeededAggregationWithResultSelector",
 			args: args{
-				source:         NewEnSlice(1, 4, 5),
+				source:         VarAll(1, 4, 5),
 				seed:           5,
 				accumulator:    func(ac, el int) int { return ac*2 + el },
 				resultSelector: func(r int) string { return fmt.Sprint(r) },
@@ -268,29 +274,29 @@ func TestAggregateSeedSel_int_int_string(t *testing.T) {
 	}
 }
 
-// see the last example from Enumerable.Aggregate help
+// last example from
 // https://learn.microsoft.com/dotnet/api/system.linq.enumerable.aggregate
-func ExampleAggregateMust() {
+func ExampleAggregate() {
 	sentence := "the quick brown fox jumps over the lazy dog"
 	// Split the string into individual words.
 	words := strings.Fields(sentence)
 	// Prepend each word to the beginning of the new sentence to reverse the word order.
-	reversed := AggregateMust(
-		NewEnSlice(words...),
+	reversed, _ := Aggregate(
+		SliceAll(words),
 		func(workingSentence, next string) string { return next + " " + workingSentence },
 	)
 	fmt.Println(reversed)
 	// Output:
 	// dog lazy the over jumps fox brown quick the
 }
 
-// see the second example from Enumerable.Aggregate help
+// second example from
 // https://learn.microsoft.com/dotnet/api/system.linq.enumerable.aggregate
-func ExampleAggregateSeedMust() {
+func ExampleAggregateSeed() {
 	ints := []int{4, 8, 8, 3, 9, 0, 7, 8, 2}
 	// Count the even numbers in the array, using a seed value of 0.
-	numEven := AggregateSeedMust(
-		NewEnSlice(ints...),
+	numEven, _ := AggregateSeed(
+		SliceAll(ints),
 		0,
 		func(total, next int) int {
 			if next%2 == 0 {
@@ -304,13 +310,13 @@ func ExampleAggregateSeedMust() {
 	// The number of even integers is: 6
 }
 
-// see the first example from Enumerable.Aggregate help
+// first example from
 // https://learn.microsoft.com/dotnet/api/system.linq.enumerable.aggregate
-func ExampleAggregateSeedSelMust() {
+func ExampleAggregateSeedSel() {
 	fruits := []string{"apple", "mango", "orange", "passionfruit", "grape"}
 	// Determine whether any string in the array is longer than "banana".
-	longestName := AggregateSeedSelMust(
-		NewEnSlice(fruits...),
+	longestName, _ := AggregateSeedSel(
+		SliceAll(fruits),
 		"banana",
 		func(longest, next string) string {
 			if len(next) > len(longest) {