update project

Author: Roman Sorokin

README.md

@@ -81,6 +81,31 @@ strings := glinq.Select(
 // []string{"num_1", "num_2", "num_3"}
 ```
 
+#### SelectWithIndex (Method) - Same Type Transformation with Index
+
+The `SelectWithIndex` **method** transforms elements to the same type, providing the element index to the mapper function:
+
+```go
+numbers := []int{1, 2, 3}
+result := glinq.From(numbers).
+    SelectWithIndex(func(x int, idx int) int { return x * idx }).
+    ToSlice()
+// []int{0, 2, 6}
+```
+
+#### SelectWithIndex (Function) - Different Type Transformation with Index
+
+The `SelectWithIndex` **function** transforms elements to a different type, providing the element index to the mapper function:
+
+```go
+numbers := []int{1, 2, 3}
+strings := glinq.SelectWithIndex(
+    glinq.From(numbers),
+    func(x int, idx int) string { return fmt.Sprintf("num_%d_at_%d", x, idx) },
+).ToSlice()
+// []string{"num_1_at_0", "num_2_at_1", "num_3_at_2"}
+```
+
 ### Limiting Elements (Take and Skip)
 
 ```go
@@ -209,6 +234,24 @@ youngest, ok := glinq.From(people).Min(func(a, b Person) int {
 // youngest = Person{Age: 25, Name: "Bob"}, ok = true
 ```
 
+### Aggregating Elements (Aggregate)
+
+The `Aggregate` method applies an accumulator function over the Stream. The seed parameter is the initial accumulator value:
+
+```go
+numbers := []int{1, 2, 3, 4, 5}
+sum := glinq.From(numbers).Aggregate(0, func(acc, x int) int { return acc + x })
+// 15
+
+numbers := []int{2, 3, 4}
+product := glinq.From(numbers).Aggregate(1, func(acc, x int) int { return acc * x })
+// 24
+
+words := []string{"Hello", " ", "World", "!"}
+concatenated := glinq.From(words).Aggregate("", func(acc, x string) string { return acc + x })
+// "Hello World!"
+```
+
 ### Finding Maximum (Max)
 
 glinq provides **two ways** to find maximum:
@@ -267,6 +310,7 @@ These methods transform the Stream and return a new `Stream[T]`:
 
 - `Where(predicate func(T) bool) Stream[T]` - filter by condition
 - `Select(mapper func(T) T) Stream[T]` - transform elements to the same type
+- `SelectWithIndex(mapper func(T, int) T) Stream[T]` - transform elements to the same type with index
 - `Take(n int) Stream[T]` - take first n elements
 - `Skip(n int) Stream[T]` - skip first n elements
 
@@ -284,12 +328,14 @@ These methods materialize the Stream:
 - `ForEach(action func(T))` - execute action for each element
 - `Min(comparator func(T, T) int) (T, bool)` - find minimum element using comparator (works with any type)
 - `Max(comparator func(T, T) int) (T, bool)` - find maximum element using comparator (works with any type)
+- `Aggregate(seed T, accumulator func(T, T) T) T` - apply accumulator function over Stream
 
 ### Transformation Functions
 
 These standalone functions transform Stream to different types:
 
 - `Select[T, R any](s Stream[T], mapper func(T) R) Stream[R]` - transform elements to a different type (function version)
+- `SelectWithIndex[T, R any](s Stream[T], mapper func(T, int) R) Stream[R]` - transform elements to a different type with index (function version)
 
 ### Map Helper Functions
 

examples/basic/main.go

@@ -167,7 +167,84 @@ func main() {
 		func(x int) string { return fmt.Sprintf("[%d]", x*10) },
 	).ToSlice()
 	fmt.Printf("Input: %v\n", numbers8)
-	fmt.Printf("Skip(3) -> Where(x < 8) -> Take(3) -> Select: %v\n", combined)
+	fmt.Printf("Skip(3) -> Where(x < 8) -> Take(3) -> Select: %v\n\n", combined)
+
+	// Пример 14: SelectWithIndex - метод с индексом
+	fmt.Println("Example 14: SelectWithIndex (method with index)")
+	numbers9 := []int{1, 2, 3, 4, 5}
+	indexed := glinq.From(numbers9).
+		SelectWithIndex(func(x int, idx int) int { return x * idx }).
+		ToSlice()
+	fmt.Printf("Input: %v\n", numbers9)
+	fmt.Printf("SelectWithIndex(x * idx): %v\n\n", indexed)
+
+	// Пример 15: SelectWithIndex - функция с индексом (разные типы)
+	fmt.Println("Example 15: SelectWithIndex function (different types with index)")
+	numbers10 := []int{10, 20, 30}
+	indexedStrings := glinq.SelectWithIndex(
+		glinq.From(numbers10),
+		func(x int, idx int) string { return fmt.Sprintf("Value_%d_at_Index_%d", x, idx) },
+	).ToSlice()
+	fmt.Printf("Input: %v\n", numbers10)
+	fmt.Printf("SelectWithIndex to string: %v\n\n", indexedStrings)
+
+	// Пример 16: SelectWithIndex с Where
+	fmt.Println("Example 16: Where + SelectWithIndex")
+	numbers11 := []int{1, 2, 3, 4, 5, 6}
+	filteredIndexed := glinq.SelectWithIndex(
+		glinq.From(numbers11).
+			Where(func(x int) bool { return x%2 == 0 }),
+		func(x int, idx int) string {
+			return fmt.Sprintf("Even[%d]=%d", idx, x)
+		},
+	).ToSlice()
+	fmt.Printf("Input: %v\n", numbers11)
+	fmt.Printf("Where(even) -> SelectWithIndex: %v\n\n", filteredIndexed)
+
+	// Пример 17: Aggregate - сумма
+	fmt.Println("Example 17: Aggregate - Sum")
+	numbers12 := []int{1, 2, 3, 4, 5}
+	sum := glinq.From(numbers12).Aggregate(0, func(acc, x int) int { return acc + x })
+	fmt.Printf("Input: %v\n", numbers12)
+	fmt.Printf("Aggregate sum: %d\n\n", sum)
+
+	// Пример 18: Aggregate - произведение
+	fmt.Println("Example 18: Aggregate - Product")
+	numbers13 := []int{2, 3, 4}
+	product := glinq.From(numbers13).Aggregate(1, func(acc, x int) int { return acc * x })
+	fmt.Printf("Input: %v\n", numbers13)
+	fmt.Printf("Aggregate product: %d\n\n", product)
+
+	// Пример 19: Aggregate - конкатенация строк
+	fmt.Println("Example 19: Aggregate - String concatenation")
+	words := []string{"Hello", " ", "World", "!"}
+	concatenated := glinq.From(words).Aggregate("", func(acc, x string) string { return acc + x })
+	fmt.Printf("Input: %v\n", words)
+	fmt.Printf("Aggregate concatenation: '%s'\n\n", concatenated)
+
+	// Пример 20: Aggregate с фильтрацией
+	fmt.Println("Example 20: Aggregate with Where filter")
+	numbers14 := []int{1, 2, 3, 4, 5, 6, 7, 8}
+	sumOfEvens := glinq.From(numbers14).
+		Where(func(x int) bool { return x%2 == 0 }).
+		Aggregate(0, func(acc, x int) int { return acc + x })
+	fmt.Printf("Input: %v\n", numbers14)
+	fmt.Printf("Sum of even numbers: %d\n\n", sumOfEvens)
+
+	// Пример 21: Aggregate с кастомным типом
+	fmt.Println("Example 21: Aggregate with custom type")
+	type Point struct {
+		X, Y int
+	}
+	points := []Point{{1, 2}, {3, 4}, {5, 6}}
+	totalPoint := glinq.From(points).Aggregate(
+		Point{0, 0},
+		func(acc, p Point) Point {
+			return Point{acc.X + p.X, acc.Y + p.Y}
+		},
+	)
+	fmt.Printf("Input points: %+v\n", points)
+	fmt.Printf("Aggregate sum: Point{X:%d, Y:%d}\n\n", totalPoint.X, totalPoint.Y)
 
 	fmt.Println("\n=== End of Examples ===")
 }

go.mod

@@ -1,3 +1,3 @@
 module github.com/CreateLab/glinq
 
-go 1.25.0
+go 1.23.0

pkg/glinq/operators.go

@@ -42,6 +42,32 @@ func (s *stream[T]) Select(mapper func(T) T) Stream[T] {
 	}
 }
 
+// SelectWithIndex transforms elements to the same type, providing index to mapper function.
+// Supports method chaining.
+//
+// Example:
+//
+//	doubled := From([]int{1, 2, 3}).
+//	    SelectWithIndex(func(x int, idx int) int { return x * idx }).
+//	    ToSlice()
+//	// []int{0, 2, 6}
+func (s *stream[T]) SelectWithIndex(mapper func(T, int) T) Stream[T] {
+	oldSource := s.source
+	index := 0
+	return &stream[T]{
+		source: func() (T, bool) {
+			value, ok := oldSource()
+			if !ok {
+				var zero T
+				return zero, false
+			}
+			result := mapper(value, index)
+			index++
+			return result, true
+		},
+	}
+}
+
 // Map transforms elements to a different type.
 // This is a function (not a method) because in Go methods cannot have their own type parameters.
 //
@@ -65,6 +91,32 @@ func Select[T, R any](s Stream[T], mapper func(T) R) Stream[R] {
 	}
 }
 
+// SelectWithIndex transforms elements to a different type, providing index to mapper function.
+// This is a function (not a method) because in Go methods cannot have their own type parameters.
+//
+// Example:
+//
+//	strings := SelectWithIndex(
+//	    From([]int{1, 2, 3}),
+//	    func(x int, idx int) string { return fmt.Sprintf("num_%d_at_%d", x, idx) },
+//	).ToSlice()
+//	// []string{"num_1_at_0", "num_2_at_1", "num_3_at_2"}
+func SelectWithIndex[T, R any](s Stream[T], mapper func(T, int) R) Stream[R] {
+	index := 0
+	return &stream[R]{
+		source: func() (R, bool) {
+			value, ok := s.Next()
+			if !ok {
+				var zero R
+				return zero, false
+			}
+			result := mapper(value, index)
+			index++
+			return result, true
+		},
+	}
+}
+
 // Take takes the first n elements from Stream.
 func (s *stream[T]) Take(n int) Stream[T] {
 	oldSource := s.source

pkg/glinq/operators_test.go

@@ -168,3 +168,83 @@ func TestLazyEvaluation(t *testing.T) {
 		t.Errorf("expected length 3, got %d", len(result))
 	}
 }
+
+func TestSelectWithIndex(t *testing.T) {
+	t.Run("Transform same type with index", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5}
+		result := From(input).
+			SelectWithIndex(func(x int, idx int) int { return x * idx }).
+			ToSlice()
+
+		expected := []int{0, 2, 6, 12, 20}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("Chaining with Where and SelectWithIndex", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5}
+		result := From(input).
+			Where(func(x int) bool { return x > 2 }).
+			SelectWithIndex(func(x int, idx int) int { return x + idx*10 }).
+			ToSlice()
+
+		expected := []int{3, 14, 25}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+}
+
+func TestSelectWithIndexFunction(t *testing.T) {
+	t.Run("Transform int to string with index", func(t *testing.T) {
+		input := []int{1, 2, 3}
+		result := SelectWithIndex(
+			From(input),
+			func(x int, idx int) string { return fmt.Sprintf("num_%d_at_%d", x, idx) },
+		).ToSlice()
+
+		expected := []string{"num_1_at_0", "num_2_at_1", "num_3_at_2"}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("Transform to struct with index", func(t *testing.T) {
+		type User struct {
+			ID   int
+			Name string
+		}
+
+		input := []int{1, 2, 3}
+		result := SelectWithIndex(
+			From(input),
+			func(id int, idx int) User {
+				return User{ID: id, Name: fmt.Sprintf("User%d_Index%d", id, idx)}
+			},
+		).ToSlice()
+
+		if len(result) != 3 {
+			t.Errorf("Expected 3 users, got %d", len(result))
+		}
+		if result[0].ID != 1 || result[0].Name != "User1_Index0" {
+			t.Errorf("Unexpected user: %+v", result[0])
+		}
+		if result[1].ID != 2 || result[1].Name != "User2_Index1" {
+			t.Errorf("Unexpected user: %+v", result[1])
+		}
+	})
+
+	t.Run("Chaining with Where and SelectWithIndex function", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5}
+		result := SelectWithIndex(
+			From(input).Where(func(x int) bool { return x > 2 }),
+			func(x int, idx int) string { return fmt.Sprintf("Number_%d_Index_%d", x, idx) },
+		).ToSlice()
+
+		expected := []string{"Number_3_Index_0", "Number_4_Index_1", "Number_5_Index_2"}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+}

pkg/glinq/stream.go

@@ -35,6 +35,12 @@ type Stream[T any] interface {
 	// Max returns the maximum element using comparator function.
 	// Comparator should return negative value if first < second, 0 if equal, positive if first > second.
 	Max(comparator func(T, T) int) (T, bool)
+	// SelectWithIndex transforms elements to the same type, providing index to mapper function.
+	SelectWithIndex(mapper func(T, int) T) Stream[T]
+	// Aggregate applies an accumulator function over the Stream.
+	// The seed parameter is the initial accumulator value.
+	// The accumulator function is invoked for each element.
+	Aggregate(seed T, accumulator func(T, T) T) T
 }
 
 // stream represents the internal implementation of Stream.

pkg/glinq/terminal.go

@@ -185,6 +185,32 @@ func (s *stream[T]) Max(comparator func(T, T) int) (T, bool) {
 	return maxVal, found
 }
 
+// Aggregate applies an accumulator function over the Stream.
+// The seed parameter is the initial accumulator value.
+// The accumulator function is invoked for each element.
+// Returns the final accumulator value.
+//
+// Example:
+//
+//	numbers := []int{1, 2, 3, 4, 5}
+//	sum := From(numbers).Aggregate(0, func(acc, x int) int { return acc + x })
+//	// 15
+//
+//	numbers := []int{1, 2, 3}
+//	product := From(numbers).Aggregate(1, func(acc, x int) int { return acc * x })
+//	// 6
+func (s *stream[T]) Aggregate(seed T, accumulator func(T, T) T) T {
+	result := seed
+	for {
+		value, ok := s.source()
+		if !ok {
+			break
+		}
+		result = accumulator(result, value)
+	}
+	return result
+}
+
 // ToMapBy materializes Stream[T] into a map using selectors for key and value.
 //
 // Example: