update project

Author: Roman Sorokin

.golangci.yml

@@ -9,9 +9,7 @@ linters:
     - govet
     - ineffassign
     - staticcheck
-    - typecheck
     - unused
-    - gofmt
     - goimports
     - misspell
     - gocritic

README.md

@@ -52,7 +52,13 @@ evens := glinq.From(numbers).
 // [2, 4]
 ```
 
-### Transformation (Select)
+### Transformation
+
+glinq provides **two ways** to transform elements:
+
+#### Select (Method) - Same Type Transformation
+
+The `Select` **method** transforms elements to the same type and supports method chaining:
 
 ```go
 numbers := []int{1, 2, 3}
@@ -62,6 +68,19 @@ squared := glinq.From(numbers).
 // [1, 4, 9]
 ```
 
+#### Select (Function) - Different Type Transformation
+
+The `Select` **function** transforms elements to a different type. It's a standalone function (not a method) because Go methods cannot have their own type parameters:
+
+```go
+numbers := []int{1, 2, 3}
+strings := glinq.Select(
+    glinq.From(numbers),
+    func(x int) string { return fmt.Sprintf("num_%d", x) },
+).ToSlice()
+// []string{"num_1", "num_2", "num_3"}
+```
+
 ### Limiting Elements (Take and Skip)
 
 ```go
@@ -139,6 +158,84 @@ first, ok := glinq.From(numbers).First()
 // first = 1, ok = true
 ```
 
+### Splitting into Chunks (Chunk)
+
+```go
+numbers := []int{1, 2, 3, 4, 5, 6, 7}
+chunks := glinq.From(numbers).Chunk(3)
+// [][]int{{1, 2, 3}, {4, 5, 6}, {7}}
+```
+
+### Getting Last Element (Last)
+
+```go
+numbers := []int{1, 2, 3, 4, 5}
+last, ok := glinq.From(numbers).Last()
+// last = 5, ok = true
+```
+
+### Summing Elements (Sum)
+
+```go
+numbers := []int{1, 2, 3, 4, 5}
+sum := glinq.Sum(glinq.From(numbers))
+// 15
+```
+
+### Finding Minimum (Min)
+
+glinq provides **two ways** to find minimum:
+
+#### Min (Function) - For Ordered Types
+
+The `Min` **function** works with ordered types (int, uint, float, string):
+
+```go
+numbers := []int{5, 2, 8, 1, 9}
+min, ok := glinq.Min(glinq.From(numbers))
+// min = 1, ok = true
+```
+
+#### Min (Method) - With Comparator
+
+The `Min` **method** works with any type using a comparator function:
+
+```go
+type Person struct { Age int; Name string }
+people := []Person{{Age: 30, Name: "Alice"}, {Age: 25, Name: "Bob"}}
+youngest, ok := glinq.From(people).Min(func(a, b Person) int {
+    return a.Age - b.Age
+})
+// youngest = Person{Age: 25, Name: "Bob"}, ok = true
+```
+
+### Finding Maximum (Max)
+
+glinq provides **two ways** to find maximum:
+
+#### Max (Function) - For Ordered Types
+
+The `Max` **function** works with ordered types (int, uint, float, string):
+
+```go
+numbers := []int{5, 2, 8, 1, 9}
+max, ok := glinq.Max(glinq.From(numbers))
+// max = 9, ok = true
+```
+
+#### Max (Method) - With Comparator
+
+The `Max` **method** works with any type using a comparator function:
+
+```go
+type Person struct { Age int; Name string }
+people := []Person{{Age: 30, Name: "Alice"}, {Age: 25, Name: "Bob"}}
+oldest, ok := glinq.From(people).Max(func(a, b Person) int {
+    return a.Age - b.Age
+})
+// oldest = Person{Age: 30, Name: "Alice"}, ok = true
+```
+
 ### Lazy Evaluation Demonstration
 
 ```go
@@ -151,36 +248,72 @@ result := glinq.Range(1, 1000000).
 // Only ~6 elements processed, not a million!
 ```
 
-## Supported Operations
+## API Reference
+
+glinq provides both **methods** (on `Stream[T]` interface) and **standalone functions**. Methods support method chaining, while functions are used when type parameters are needed.
 
-### Creators
+### Creator Functions
+
+These functions create a new `Stream[T]`:
 
 - `From[T any](slice []T) Stream[T]` - create Stream from slice
 - `Empty[T any]() Stream[T]` - create empty Stream
 - `Range(start, count int) Stream[int]` - create Stream of integers
 - `FromMap[K, V](m map[K]V) Stream[KeyValue[K, V]]` - create Stream from map
 
-### Operators
+### Stream Methods (Operators)
+
+These methods transform the Stream and return a new `Stream[T]`:
 
 - `Where(predicate func(T) bool) Stream[T]` - filter by condition
-- `Select[R any](mapper func(T) R) Stream[R]` - transform elements
+- `Select(mapper func(T) T) Stream[T]` - transform elements to the same type
 - `Take(n int) Stream[T]` - take first n elements
 - `Skip(n int) Stream[T]` - skip first n elements
 
-### Terminal Operations
+### Stream Methods (Terminal Operations)
+
+These methods materialize the Stream:
 
 - `ToSlice() []T` - convert Stream to slice
+- `Chunk(size int) [][]T` - split Stream into chunks of specified size
 - `First() (T, bool)` - get first element
+- `Last() (T, bool)` - get last element
 - `Count() int` - count number of elements
 - `Any(predicate func(T) bool) bool` - check if any element exists
 - `All(predicate func(T) bool) bool` - check if all elements satisfy condition
 - `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)
+
+### 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)
+
+### Map Helper Functions
+
+These functions work with `Stream[KeyValue[K, V]]`:
 
-### Helper Functions
+- `Keys[K, V](s Stream[KeyValue[K, V]]) Stream[K]` - extract keys from KeyValue pairs
+- `Values[K, V](s Stream[KeyValue[K, V]]) Stream[V]` - extract values from KeyValue pairs
+- `ToMap[K, V](s Stream[KeyValue[K, V]]) map[K]V` - convert Stream[KeyValue] to map
 
-- `Keys[K, V](stream Stream[KeyValue[K, V]]) Stream[K]` - extract keys
-- `Values[K, V](stream Stream[KeyValue[K, V]]) Stream[V]` - extract values
-- `ToMap[K, V](stream Stream[KeyValue[K, V]]) map[K]V` - convert to map
+### Terminal Functions
+
+These standalone functions materialize Streams:
+
+- `ToMapBy[T, K, V](s Stream[T], keySelector func(T) K, valueSelector func(T) V) map[K]V` - convert Stream[T] to map using selectors
+
+### Numeric Functions
+
+These functions work with numeric and ordered types:
+
+- `Sum[T Numeric](s Stream[T]) T` - calculate sum of all elements (works with int, uint, float types)
+- `Min[T Ordered](s Stream[T]) (T, bool)` - find minimum element for ordered types (works with int, uint, float, string types)
+- `Max[T Ordered](s Stream[T]) (T, bool)` - find maximum element for ordered types (works with int, uint, float, string types)
+
+**Note**: For custom types or complex comparisons, use the `Min` and `Max` methods with comparator functions instead.
 
 ## Requirements
 
@@ -201,7 +334,3 @@ go run examples/basic/main.go
 ## License
 
 MIT
-
-## Author
-
-your-username

examples/basic/main.go

@@ -29,35 +29,35 @@ func main() {
 	fmt.Printf("Input: %v\n", numbers2)
 	fmt.Printf("Filtered (> 5) and mapped (x * 2): %v\n\n", result)
 
-	// Пример 3: Map - преобразование в другой тип (int -> string)
-	fmt.Println("Example 3: Map (int -> string)")
+	// Пример 3: Select - преобразование в другой тип (int -> string)
+	fmt.Println("Example 3: Select (int -> string)")
 	numbers3 := []int{1, 2, 3, 4, 5}
-	strings := glinq.Map(
+	strings := glinq.Select(
 		glinq.From(numbers3),
 		func(x int) string { return fmt.Sprintf("Number: %d", x) },
 	).ToSlice()
 	fmt.Printf("Input: %v\n", numbers3)
 	fmt.Printf("Strings: %v\n\n", strings)
 
-	// Пример 4: Map с Where (combined)
-	fmt.Println("Example 4: Where + Map (different type)")
+	// Пример 4: Select с Where (combined)
+	fmt.Println("Example 4: Where + Select (different type)")
 	numbers4 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	filtered := glinq.Map(
+	filtered := glinq.Select(
 		glinq.From(numbers4).Where(func(x int) bool { return x%2 == 0 }),
 		func(x int) string { return fmt.Sprintf("Even: %d", x) },
 	).ToSlice()
 	fmt.Printf("Input: %v\n", numbers4)
 	fmt.Printf("Even numbers as strings: %v\n\n", filtered)
 
-	// Пример 5: Map в структуру
-	fmt.Println("Example 5: Map to struct")
+	// Пример 5: Select в структуру
+	fmt.Println("Example 5: Select to struct")
 	type User struct {
 		ID   int
 		Name string
 	}
 
 	ids := []int{1, 2, 3}
-	users := glinq.Map(
+	users := glinq.Select(
 		glinq.From(ids),
 		func(id int) User {
 			return User{ID: id, Name: fmt.Sprintf("User%d", id)}
@@ -109,10 +109,10 @@ func main() {
 		ToSlice()
 	fmt.Printf("Result: %v\n\n", lazyResult)
 
-	// Пример 9: Lazy evaluation с Map
-	fmt.Println("Example 9: Lazy evaluation with Map")
+	// Пример 9: Lazy evaluation с Select
+	fmt.Println("Example 9: Lazy evaluation with Select")
 	fmt.Println("Notice: only 3 elements are processed due to Take(3)")
-	lazy := glinq.Map(
+	lazy := glinq.Select(
 		glinq.Range(1, 20).
 			Where(func(x int) bool {
 				fmt.Printf("  Checking %d\n", x)
@@ -156,18 +156,18 @@ func main() {
 	fmt.Printf("Input: %v\n", numbers7)
 	fmt.Printf("Skip(2) -> Where(even) -> Select(x*x) -> Take(3): %v\n\n", complex)
 
-	// Пример 13: Комбинация Skip, Map, Take
-	fmt.Println("Example 13: Skip + Map + Take")
+	// Пример 13: Комбинация Skip, Select, Take
+	fmt.Println("Example 13: Skip + Select + Take")
 	numbers8 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	combined := glinq.Map(
+	combined := glinq.Select(
 		glinq.From(numbers8).
 			Skip(3).
 			Where(func(x int) bool { return x < 8 }).
 			Take(3),
 		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) -> Map: %v\n", combined)
+	fmt.Printf("Skip(3) -> Where(x < 8) -> Take(3) -> Select: %v\n", combined)
 
 	fmt.Println("\n=== End of Examples ===")
 }

pkg/glinq/chunk_test.go

@@ -0,0 +1,97 @@
+package glinq
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestChunk(t *testing.T) {
+	t.Run("Chunk with exact division", func(t *testing.T) {
+		slice := []int{1, 2, 3, 4, 5, 6}
+		result := From(slice).Chunk(3)
+
+		expected := [][]int{{1, 2, 3}, {4, 5, 6}}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("Chunk with remainder", func(t *testing.T) {
+		slice := []int{1, 2, 3, 4, 5, 6, 7}
+		result := From(slice).Chunk(3)
+
+		expected := [][]int{{1, 2, 3}, {4, 5, 6}, {7}}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("Chunk with single element chunks", func(t *testing.T) {
+		slice := []int{1, 2, 3}
+		result := From(slice).Chunk(1)
+
+		expected := [][]int{{1}, {2}, {3}}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("Chunk larger than slice", func(t *testing.T) {
+		slice := []int{1, 2, 3}
+		result := From(slice).Chunk(10)
+
+		expected := [][]int{{1, 2, 3}}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("Chunk empty slice", func(t *testing.T) {
+		slice := []int{}
+		result := From(slice).Chunk(3)
+
+		if len(result) != 0 {
+			t.Errorf("Expected empty result, got %v", result)
+		}
+	})
+
+	t.Run("Chunk with zero size", func(t *testing.T) {
+		slice := []int{1, 2, 3}
+		result := From(slice).Chunk(0)
+
+		if result != nil {
+			t.Errorf("Expected nil, got %v", result)
+		}
+	})
+
+	t.Run("Chunk with negative size", func(t *testing.T) {
+		slice := []int{1, 2, 3}
+		result := From(slice).Chunk(-1)
+
+		if result != nil {
+			t.Errorf("Expected nil, got %v", result)
+		}
+	})
+
+	t.Run("Chunk with filtered stream", func(t *testing.T) {
+		slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+		result := From(slice).
+			Where(func(x int) bool { return x%2 == 0 }).
+			Chunk(2)
+
+		expected := [][]int{{2, 4}, {6, 8}, {10}}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("Chunk with strings", func(t *testing.T) {
+		slice := []string{"a", "b", "c", "d", "e"}
+		result := From(slice).Chunk(2)
+
+		expected := [][]string{{"a", "b"}, {"c", "d"}, {"e"}}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+}