update project

Author: Roman Sorokin

pkg/glinq/operators.go

@@ -156,3 +156,157 @@ func (s *stream[T]) Skip(n int) Stream[T] {
 		},
 	}
 }
+
+// TakeOrderedBy takes the first n smallest elements from Stream using comparator function.
+// Uses a buffer of size n to keep track of the n smallest elements.
+// Stream is read lazily, and only the buffer is sorted before being returned.
+// This is a function (not a method) because in Go methods cannot have their own type parameters.
+//
+// Example:
+//
+//	type Person struct { Age int; Name string }
+//	people := []Person{{Age: 30, Name: "Alice"}, {Age: 25, Name: "Bob"}, {Age: 35, Name: "Charlie"}}
+//	result := TakeOrderedBy(
+//	    From(people),
+//	    2,
+//	    func(a, b Person) bool { return a.Age < b.Age },
+//	).ToSlice()
+//	// []Person{{Age: 25, Name: "Bob"}, {Age: 30, Name: "Alice"}}
+func TakeOrderedBy[T any](s Stream[T], n int, less func(a, b T) bool) Stream[T] {
+	if n <= 0 {
+		return Empty[T]()
+	}
+
+	var buf []T
+	var result []T
+	var materialized bool
+
+	return &stream[T]{
+		source: func() (T, bool) {
+			if !materialized {
+				// Materialize stream and build buffer
+				for {
+					value, ok := s.Next()
+					if !ok {
+						break
+					}
+
+					if len(buf) < n {
+						buf = append(buf, value)
+					} else {
+						// Find maximum element in buffer (according to less)
+						maxIdx := 0
+						for i := 1; i < len(buf); i++ {
+							if less(buf[maxIdx], buf[i]) {
+								maxIdx = i
+							}
+						}
+						// Replace if current value is smaller (according to less)
+						if less(value, buf[maxIdx]) {
+							buf[maxIdx] = value
+						}
+					}
+				}
+
+				// Sort buffer in ascending order using less function
+				result = make([]T, len(buf))
+				copy(result, buf)
+				for i := 0; i < len(result); i++ {
+					for j := i + 1; j < len(result); j++ {
+						if less(result[j], result[i]) {
+							result[i], result[j] = result[j], result[i]
+						}
+					}
+				}
+
+				materialized = true
+			}
+
+			if len(result) == 0 {
+				var zero T
+				return zero, false
+			}
+
+			value := result[0]
+			result = result[1:]
+			return value, true
+		},
+	}
+}
+
+// TakeOrderedDescendingBy takes the first n largest elements from Stream using comparator function.
+// Uses a buffer of size n to keep track of the n largest elements.
+// Stream is read lazily, and only the buffer is sorted before being returned.
+// This is a function (not a method) because in Go methods cannot have their own type parameters.
+//
+// Example:
+//
+//	type Person struct { Age int; Name string }
+//	people := []Person{{Age: 30, Name: "Alice"}, {Age: 25, Name: "Bob"}, {Age: 35, Name: "Charlie"}}
+//	result := TakeOrderedDescendingBy(
+//	    From(people),
+//	    2,
+//	    func(a, b Person) bool { return a.Age < b.Age },
+//	).ToSlice()
+//	// []Person{{Age: 35, Name: "Charlie"}, {Age: 30, Name: "Alice"}}
+func TakeOrderedDescendingBy[T any](s Stream[T], n int, less func(a, b T) bool) Stream[T] {
+	if n <= 0 {
+		return Empty[T]()
+	}
+
+	var buf []T
+	var result []T
+	var materialized bool
+
+	return &stream[T]{
+		source: func() (T, bool) {
+			if !materialized {
+				// Materialize stream and build buffer
+				for {
+					value, ok := s.Next()
+					if !ok {
+						break
+					}
+
+					if len(buf) < n {
+						buf = append(buf, value)
+					} else {
+						// Find minimum element in buffer (according to less)
+						minIdx := 0
+						for i := 1; i < len(buf); i++ {
+							if less(buf[i], buf[minIdx]) {
+								minIdx = i
+							}
+						}
+						// Replace if current value is larger (according to less)
+						if less(buf[minIdx], value) {
+							buf[minIdx] = value
+						}
+					}
+				}
+
+				// Sort buffer in descending order using less function
+				result = make([]T, len(buf))
+				copy(result, buf)
+				for i := 0; i < len(result); i++ {
+					for j := i + 1; j < len(result); j++ {
+						if less(result[i], result[j]) {
+							result[i], result[j] = result[j], result[i]
+						}
+					}
+				}
+
+				materialized = true
+			}
+
+			if len(result) == 0 {
+				var zero T
+				return zero, false
+			}
+
+			value := result[0]
+			result = result[1:]
+			return value, true
+		},
+	}
+}