fix structs size

Roman Sorokin · Roman Sorokin · commit 2a76d42c4673 · 2025-11-18T09:46:40.000+03:00
diff --git a/pkg/glinq/distinct.go b/pkg/glinq/distinct.go
@@ -25,7 +25,7 @@ func Distinct[T comparable](enum Enumerable[T]) Stream[T] {
 				}
 			}
 		},
-		size: nil, // LOSE: unknown how many duplicates
+		size: -1, // LOSE: unknown how many duplicates
 	}
 }
 
@@ -54,6 +54,6 @@ func (s *stream[T]) DistinctBy(keySelector func(T) any) Stream[T] {
 				}
 			}
 		},
-		size: nil, // LOSE: unknown how many duplicates
+		size: -1, // LOSE: unknown how many duplicates
 	}
 }
diff --git a/pkg/glinq/kv.go b/pkg/glinq/kv.go
@@ -27,7 +27,6 @@ func FromMap[K comparable, V any](m map[K]V) Stream[KeyValue[K, V]] {
 		keys = append(keys, key)
 	}
 
-	size := len(m)
 	return &stream[KeyValue[K, V]]{
 		sourceFactory: func() func() (KeyValue[K, V], bool) {
 			index := 0 // Fresh index for each iterator
@@ -42,7 +41,7 @@ func FromMap[K comparable, V any](m map[K]V) Stream[KeyValue[K, V]] {
 				return KeyValue[K, V]{Key: key, Value: value}, true
 			}
 		},
-		size: &size,
+		size: len(m),
 	}
 }
 
@@ -66,7 +65,6 @@ func FromMapSafe[K comparable, V any](m map[K]V) Stream[KeyValue[K, V]] {
 		pairs = append(pairs, KeyValue[K, V]{Key: key, Value: value})
 	}
 
-	size := len(pairs)
 	return &stream[KeyValue[K, V]]{
 		sourceFactory: func() func() (KeyValue[K, V], bool) {
 			index := 0 // Fresh index for each iterator
@@ -79,17 +77,17 @@ func FromMapSafe[K comparable, V any](m map[K]V) Stream[KeyValue[K, V]] {
 				return result, true
 			}
 		},
-		size: &size,
+		size: len(pairs),
 	}
 }
 
 // Keys extracts only keys from Enumerable[KeyValue].
 // SIZE: Preserves size if source is Sizable (1-to-1 transformation).
 func Keys[K comparable, V any](enum Enumerable[KeyValue[K, V]]) Stream[K] {
-	var size *int
+	size := -1
 	if sizable, ok := enum.(Sizable[KeyValue[K, V]]); ok {
 		if s, known := sizable.Size(); known {
-			size = &s
+			size = s
 		}
 	}
 	return &stream[K]{
@@ -110,10 +108,10 @@ func Keys[K comparable, V any](enum Enumerable[KeyValue[K, V]]) Stream[K] {
 // Values extracts only values from Enumerable[KeyValue].
 // SIZE: Preserves size if source is Sizable (1-to-1 transformation).
 func Values[K comparable, V any](enum Enumerable[KeyValue[K, V]]) Stream[V] {
-	var size *int
+	size := -1
 	if sizable, ok := enum.(Sizable[KeyValue[K, V]]); ok {
 		if s, known := sizable.Size(); known {
-			size = &s
+			size = s
 		}
 	}
 	return &stream[V]{
@@ -178,8 +176,7 @@ func GroupBy[T any, K comparable](enum Enumerable[T], keySelector func(T) K) Str
 		pairs = append(pairs, KeyValue[K, []T]{Key: key, Value: values})
 	}
 
-	// SIZE: Unknown - depends on how many unique keys exist
-	size := len(pairs)
+	// SIZE: Known after materialization
 	return &stream[KeyValue[K, []T]]{
 		sourceFactory: func() func() (KeyValue[K, []T], bool) {
 			index := 0 // Fresh index for each iterator
@@ -192,6 +189,6 @@ func GroupBy[T any, K comparable](enum Enumerable[T], keySelector func(T) K) Str
 				return result, true
 			}
 		},
-		size: &size, // Actually we know it after materialization
+		size: len(pairs), // Actually we know it after materialization
 	}
 }
diff --git a/pkg/glinq/operators.go b/pkg/glinq/operators.go
@@ -22,7 +22,7 @@ func (s *stream[T]) Where(predicate func(T) bool) Stream[T] {
 				}
 			}
 		},
-		size: nil, // LOSE: unknown how many pass filter
+		size: -1, // LOSE: unknown how many pass filter
 	}
 }
 
@@ -98,10 +98,10 @@ func (s *stream[T]) SelectWithIndex(mapper func(T, int) T) Stream[T] {
 //	).ToSlice()
 //	// []string{"num_1", "num_2", "num_3"}
 func Select[T, R any](enum Enumerable[T], mapper func(T) R) Stream[R] {
-	var size *int
+	size := -1
 	if sizable, ok := enum.(Sizable[T]); ok {
 		if s, known := sizable.Size(); known {
-			size = &s
+			size = s
 		}
 	}
 	return &stream[R]{
@@ -132,10 +132,10 @@ func Select[T, R any](enum Enumerable[T], mapper func(T) R) Stream[R] {
 //	).ToSlice()
 //	// []string{"num_1_at_0", "num_2_at_1", "num_3_at_2"}
 func SelectWithIndex[T, R any](enum Enumerable[T], mapper func(T, int) R) Stream[R] {
-	var size *int
+	size := -1
 	if sizable, ok := enum.(Sizable[T]); ok {
 		if s, known := sizable.Size(); known {
-			size = &s
+			size = s
 		}
 	}
 	return &stream[R]{
@@ -160,16 +160,15 @@ func SelectWithIndex[T, R any](enum Enumerable[T], mapper func(T, int) R) Stream
 //
 // SIZE: Calculated as min(sourceSize, n) if source size known, else n.
 func (s *stream[T]) Take(n int) Stream[T] {
-	var newSize *int
-	if s.size != nil {
-		size := *s.size
-		if size < n {
-			newSize = &size
+	var newSize int
+	if s.size != -1 {
+		if s.size < n {
+			newSize = s.size
 		} else {
-			newSize = &n
+			newSize = n
 		}
 	} else {
-		newSize = &n // Don't know source size, but result won't exceed n
+		newSize = n // Don't know source size, but result won't exceed n
 	}
 
 	return &stream[T]{
@@ -198,15 +197,15 @@ func (s *stream[T]) Take(n int) Stream[T] {
 //
 // SIZE: Calculated as max(0, sourceSize - n) if source size known, else unknown.
 func (s *stream[T]) Skip(n int) Stream[T] {
-	var newSize *int
-	if s.size != nil {
-		size := *s.size - n
+	var newSize int = -1
+	if s.size != -1 {
+		size := s.size - n
 		if size < 0 {
 			size = 0
 		}
-		newSize = &size
+		newSize = size
 	}
-	// else: nil (unknown)
+	// else: -1 (unknown)
 
 	return &stream[T]{
 		sourceFactory: func() func() (T, bool) {
@@ -224,7 +223,7 @@ func (s *stream[T]) Skip(n int) Stream[T] {
 				return source()
 			}
 		},
-		size: newSize, // CALCULATED: max(0, source - n) or nil
+		size: newSize, // CALCULATED: max(0, source - n) or -1
 	}
 }
 
@@ -274,19 +273,19 @@ func TakeOrderedBy[T any](enum Enumerable[T], n int, less func(a, b T) bool) Str
 		return Empty[T]()
 	}
 
-	var size *int
+	var size int
 	if sizable, ok := enum.(Sizable[T]); ok {
 		if s, known := sizable.Size(); known {
 			if s < n {
-				size = &s
+				size = s
 			} else {
-				size = &n
+				size = n
 			}
 		} else {
-			size = &n // Don't know source size, but result won't exceed n
+			size = n // Don't know source size, but result won't exceed n
 		}
 	} else {
-		size = &n // Don't know source size, but result won't exceed n
+		size = n // Don't know source size, but result won't exceed n
 	}
 
 	return &stream[T]{
@@ -413,6 +412,6 @@ func SelectMany[T, R any](enum Enumerable[T], selector func(T) Enumerable[R]) St
 				}
 			}
 		},
-		size: nil, // LOSE: 1-to-many transformation
+		size: -1, // LOSE: 1-to-many transformation
 	}
 }
diff --git a/pkg/glinq/ordering.go b/pkg/glinq/ordering.go
@@ -15,7 +15,6 @@ func (s *stream[T]) orderBy(ascending bool, comparator func(T, T) int) Stream[T]
 	})
 
 	// SIZE: Preserves size (1-to-1 transformation, materializes)
-	size := len(sorted)
 	return &stream[T]{
 		sourceFactory: func() func() (T, bool) {
 			index := 0 // Fresh index for each iterator
@@ -29,7 +28,7 @@ func (s *stream[T]) orderBy(ascending bool, comparator func(T, T) int) Stream[T]
 				return result, true
 			}
 		},
-		size: &size, // PRESERVE: 1-to-1 transformation
+		size: len(sorted), // PRESERVE: 1-to-1 transformation
 	}
 }
 
diff --git a/pkg/glinq/set.go b/pkg/glinq/set.go
@@ -5,16 +5,15 @@ package glinq
 //
 // SIZE: Calculated as currentSize + otherSize if both known, else unknown.
 func (s *stream[T]) Concat(other Enumerable[T]) Stream[T] {
-	var newSize *int
-	if s.size != nil {
+	var newSize int = -1
+	if s.size != -1 {
 		if sizable, ok := other.(Sizable[T]); ok {
 			if otherSize, known := sizable.Size(); known {
-				size := *s.size + otherSize
-				newSize = &size
+				newSize = s.size + otherSize
 			}
 		}
 	}
-	// else: nil (unknown)
+	// else: -1 (unknown)
 
 	return &stream[T]{
 		sourceFactory: func() func() (T, bool) {
@@ -79,7 +78,7 @@ func Union[T comparable](e1, e2 Enumerable[T]) Stream[T] {
 				}
 			}
 		},
-		size: nil, // LOSE: unknown how many duplicates
+		size: -1, // LOSE: unknown how many duplicates
 	}
 }
 
@@ -117,7 +116,7 @@ func Intersect[T comparable](e1, e2 Enumerable[T]) Stream[T] {
 				}
 			}
 		},
-		size: nil, // LOSE: unknown result count
+		size: -1, // LOSE: unknown result count
 	}
 }
 
@@ -155,6 +154,6 @@ func Except[T comparable](e1, e2 Enumerable[T]) Stream[T] {
 				}
 			}
 		},
-		size: nil, // LOSE: unknown result count
+		size: -1, // LOSE: unknown result count
 	}
 }
diff --git a/pkg/glinq/stream.go b/pkg/glinq/stream.go
@@ -38,8 +38,11 @@ type Stream[T any] interface {
 	First() (T, bool)
 	// Count returns the number of elements in Stream.
 	Count() int
-	// Any checks if there is at least one element satisfying the predicate.
-	Any(predicate func(T) bool) bool
+	// Any checks if there is at least one element in the Stream.
+	// OPTIMIZATION: Returns O(1) if size is known, otherwise iterates until first element.
+	Any() bool
+	// AnyMatch checks if there is at least one element satisfying the predicate.
+	AnyMatch(predicate func(T) bool) bool
 	// All checks if all elements satisfy the predicate.
 	All(predicate func(T) bool) bool
 	// ForEach executes an action for each element in Stream.
@@ -115,7 +118,7 @@ type Stream[T any] interface {
 type stream[T any] struct {
 	sourceFactory   func() func() (T, bool)
 	currentIterator func() (T, bool) // For Enumerable.Next()
-	size            *int             // nil if unknown, pointer to size if known
+	size            int              // -1 if unknown, actual size if known
 }
 
 // From creates a Stream from a slice.
@@ -132,7 +135,6 @@ type stream[T any] struct {
 //	stream := From(numbers)
 //	// Efficient - no copying!
 func From[T any](slice []T) Stream[T] {
-	size := len(slice)
 	return &stream[T]{
 		sourceFactory: func() func() (T, bool) {
 			index := 0 // Fresh index for each iterator
@@ -146,7 +148,7 @@ func From[T any](slice []T) Stream[T] {
 				return result, true
 			}
 		},
-		size: &size,
+		size: len(slice),
 	}
 }
 
@@ -168,7 +170,6 @@ func FromSafe[T any](slice []T) Stream[T] {
 	data := make([]T, len(slice))
 	copy(data, slice)
 
-	size := len(data)
 	return &stream[T]{
 		sourceFactory: func() func() (T, bool) {
 			index := 0 // Fresh index for each iterator
@@ -182,21 +183,20 @@ func FromSafe[T any](slice []T) Stream[T] {
 				return result, true
 			}
 		},
-		size: &size,
+		size: len(data),
 	}
 }
 
 // Empty creates an empty Stream that contains no elements.
 func Empty[T any]() Stream[T] {
-	size := 0
 	return &stream[T]{
 		sourceFactory: func() func() (T, bool) {
 			return func() (T, bool) {
 				var zero T
 				return zero, false
 			}
 		},
-		size: &size,
+		size: 0,
 	}
 }
 
@@ -214,7 +214,7 @@ func Range(start, count int) Stream[int] {
 				return result, true
 			}
 		},
-		size: &count,
+		size: count,
 	}
 }
 
@@ -228,19 +228,19 @@ func (s *stream[T]) Next() (T, bool) {
 
 // Size implements Sizable
 func (s *stream[T]) Size() (int, bool) {
-	if s.size == nil {
+	if s.size == -1 {
 		return 0, false
 	}
-	return *s.size, true
+	return s.size, true
 }
 
 // FromEnumerable creates a Stream from any Enumerable.
 // SIZE: Preserves size if source is Sizable, otherwise unknown.
 func FromEnumerable[T any](enum Enumerable[T]) Stream[T] {
-	var size *int
+	size := -1
 	if sizable, ok := enum.(Sizable[T]); ok {
 		if s, known := sizable.Size(); known {
-			size = &s
+			size = s
 		}
 	}
 	return &stream[T]{
diff --git a/pkg/glinq/terminal.go b/pkg/glinq/terminal.go
diff --git a/pkg/glinq/terminal_test.go b/pkg/glinq/terminal_test.go

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ func Distinct[T comparable](enum Enumerable[T]) Stream[T] {`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`	`},`
`28`		`- size: nil, // LOSE: unknown how many duplicates`
	`28`	`+ size: -1, // LOSE: unknown how many duplicates`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`@@ -54,6 +54,6 @@ func (s *stream[T]) DistinctBy(keySelector func(T) any) Stream[T] {`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`},`
`57`		`- size: nil, // LOSE: unknown how many duplicates`
	`57`	`+ size: -1, // LOSE: unknown how many duplicates`
`58`	`58`	`}`
`59`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,6 @@ func FromMap[K comparable, V any](m map[K]V) Stream[KeyValue[K, V]] {`
`27`	`27`	`keys = append(keys, key)`
`28`	`28`	`}`
`29`	`29`
`30`		`- size := len(m)`
`31`	`30`	`return &stream[KeyValue[K, V]]{`
`32`	`31`	`sourceFactory: func() func() (KeyValue[K, V], bool) {`
`33`	`32`	`index := 0 // Fresh index for each iterator`
`@@ -42,7 +41,7 @@ func FromMap[K comparable, V any](m map[K]V) Stream[KeyValue[K, V]] {`
`42`	`41`	`return KeyValue[K, V]{Key: key, Value: value}, true`
`43`	`42`	`}`
`44`	`43`	`},`
`45`		`- size: &size,`
	`44`	`+ size: len(m),`
`46`	`45`	`}`
`47`	`46`	`}`
`48`	`47`
`@@ -66,7 +65,6 @@ func FromMapSafe[K comparable, V any](m map[K]V) Stream[KeyValue[K, V]] {`
`66`	`65`	`pairs = append(pairs, KeyValue[K, V]{Key: key, Value: value})`
`67`	`66`	`}`
`68`	`67`
`69`		`- size := len(pairs)`
`70`	`68`	`return &stream[KeyValue[K, V]]{`
`71`	`69`	`sourceFactory: func() func() (KeyValue[K, V], bool) {`
`72`	`70`	`index := 0 // Fresh index for each iterator`
`@@ -79,17 +77,17 @@ func FromMapSafe[K comparable, V any](m map[K]V) Stream[KeyValue[K, V]] {`
`79`	`77`	`return result, true`
`80`	`78`	`}`
`81`	`79`	`},`
`82`		`- size: &size,`
	`80`	`+ size: len(pairs),`
`83`	`81`	`}`
`84`	`82`	`}`
`85`	`83`
`86`	`84`	`// Keys extracts only keys from Enumerable[KeyValue].`
`87`	`85`	`// SIZE: Preserves size if source is Sizable (1-to-1 transformation).`
`88`	`86`	`func Keys[K comparable, V any](enum Enumerable[KeyValue[K, V]]) Stream[K] {`
`89`		`- var size *int`
	`87`	`+ size := -1`
`90`	`88`	`if sizable, ok := enum.(Sizable[KeyValue[K, V]]); ok {`
`91`	`89`	`if s, known := sizable.Size(); known {`
`92`		`- size = &s`
	`90`	`+ size = s`
`93`	`91`	`}`
`94`	`92`	`}`
`95`	`93`	`return &stream[K]{`
`@@ -110,10 +108,10 @@ func Keys[K comparable, V any](enum Enumerable[KeyValue[K, V]]) Stream[K] {`
`110`	`108`	`// Values extracts only values from Enumerable[KeyValue].`
`111`	`109`	`// SIZE: Preserves size if source is Sizable (1-to-1 transformation).`
`112`	`110`	`func Values[K comparable, V any](enum Enumerable[KeyValue[K, V]]) Stream[V] {`
`113`		`- var size *int`
	`111`	`+ size := -1`
`114`	`112`	`if sizable, ok := enum.(Sizable[KeyValue[K, V]]); ok {`
`115`	`113`	`if s, known := sizable.Size(); known {`
`116`		`- size = &s`
	`114`	`+ size = s`
`117`	`115`	`}`
`118`	`116`	`}`
`119`	`117`	`return &stream[V]{`
`@@ -178,8 +176,7 @@ func GroupBy[T any, K comparable](enum Enumerable[T], keySelector func(T) K) Str`
`178`	`176`	`pairs = append(pairs, KeyValue[K, []T]{Key: key, Value: values})`
`179`	`177`	`}`
`180`	`178`
`181`		`- // SIZE: Unknown - depends on how many unique keys exist`
`182`		`- size := len(pairs)`
	`179`	`+ // SIZE: Known after materialization`
`183`	`180`	`return &stream[KeyValue[K, []T]]{`
`184`	`181`	`sourceFactory: func() func() (KeyValue[K, []T], bool) {`
`185`	`182`	`index := 0 // Fresh index for each iterator`
`@@ -192,6 +189,6 @@ func GroupBy[T any, K comparable](enum Enumerable[T], keySelector func(T) K) Str`
`192`	`189`	`return result, true`
`193`	`190`	`}`
`194`	`191`	`},`
`195`		`- size: &size, // Actually we know it after materialization`
	`192`	`+ size: len(pairs), // Actually we know it after materialization`
`196`	`193`	`}`
`197`	`194`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ func (s *stream[T]) Where(predicate func(T) bool) Stream[T] {`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`	`},`
`25`		`- size: nil, // LOSE: unknown how many pass filter`
	`25`	`+ size: -1, // LOSE: unknown how many pass filter`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`@@ -98,10 +98,10 @@ func (s *stream[T]) SelectWithIndex(mapper func(T, int) T) Stream[T] {`
`98`	`98`	`// ).ToSlice()`
`99`	`99`	`// // []string{"num_1", "num_2", "num_3"}`
`100`	`100`	`func Select[T, R any](enum Enumerable[T], mapper func(T) R) Stream[R] {`
`101`		`- var size *int`
	`101`	`+ size := -1`
`102`	`102`	`if sizable, ok := enum.(Sizable[T]); ok {`
`103`	`103`	`if s, known := sizable.Size(); known {`
`104`		`- size = &s`
	`104`	`+ size = s`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`	`return &stream[R]{`
`@@ -132,10 +132,10 @@ func Select[T, R any](enum Enumerable[T], mapper func(T) R) Stream[R] {`
`132`	`132`	`// ).ToSlice()`
`133`	`133`	`// // []string{"num_1_at_0", "num_2_at_1", "num_3_at_2"}`
`134`	`134`	`func SelectWithIndex[T, R any](enum Enumerable[T], mapper func(T, int) R) Stream[R] {`
`135`		`- var size *int`
	`135`	`+ size := -1`
`136`	`136`	`if sizable, ok := enum.(Sizable[T]); ok {`
`137`	`137`	`if s, known := sizable.Size(); known {`
`138`		`- size = &s`
	`138`	`+ size = s`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`	`return &stream[R]{`
`@@ -160,16 +160,15 @@ func SelectWithIndex[T, R any](enum Enumerable[T], mapper func(T, int) R) Stream`
`160`	`160`	`//`
`161`	`161`	`// SIZE: Calculated as min(sourceSize, n) if source size known, else n.`
`162`	`162`	`func (s *stream[T]) Take(n int) Stream[T] {`
`163`		`- var newSize *int`
`164`		`- if s.size != nil {`
`165`		`- size := *s.size`
`166`		`- if size < n {`
`167`		`- newSize = &size`
	`163`	`+ var newSize int`
	`164`	`+ if s.size != -1 {`
	`165`	`+ if s.size < n {`
	`166`	`+ newSize = s.size`
`168`	`167`	`} else {`
`169`		`- newSize = &n`
	`168`	`+ newSize = n`
`170`	`169`	`}`
`171`	`170`	`} else {`
`172`		`- newSize = &n // Don't know source size, but result won't exceed n`
	`171`	`+ newSize = n // Don't know source size, but result won't exceed n`
`173`	`172`	`}`
`174`	`173`
`175`	`174`	`return &stream[T]{`
`@@ -198,15 +197,15 @@ func (s *stream[T]) Take(n int) Stream[T] {`
`198`	`197`	`//`
`199`	`198`	`// SIZE: Calculated as max(0, sourceSize - n) if source size known, else unknown.`
`200`	`199`	`func (s *stream[T]) Skip(n int) Stream[T] {`
`201`		`- var newSize *int`
`202`		`- if s.size != nil {`
`203`		`- size := *s.size - n`
	`200`	`+ var newSize int = -1`
	`201`	`+ if s.size != -1 {`
	`202`	`+ size := s.size - n`
`204`	`203`	`if size < 0 {`
`205`	`204`	`size = 0`
`206`	`205`	`}`
`207`		`- newSize = &size`
	`206`	`+ newSize = size`
`208`	`207`	`}`
`209`		`- // else: nil (unknown)`
	`208`	`+ // else: -1 (unknown)`
`210`	`209`
`211`	`210`	`return &stream[T]{`
`212`	`211`	`sourceFactory: func() func() (T, bool) {`
`@@ -224,7 +223,7 @@ func (s *stream[T]) Skip(n int) Stream[T] {`
`224`	`223`	`return source()`
`225`	`224`	`}`
`226`	`225`	`},`
`227`		`- size: newSize, // CALCULATED: max(0, source - n) or nil`
	`226`	`+ size: newSize, // CALCULATED: max(0, source - n) or -1`
`228`	`227`	`}`
`229`	`228`	`}`
`230`	`229`
`@@ -274,19 +273,19 @@ func TakeOrderedBy[T any](enum Enumerable[T], n int, less func(a, b T) bool) Str`
`274`	`273`	`return Empty[T]()`
`275`	`274`	`}`
`276`	`275`
`277`		`- var size *int`
	`276`	`+ var size int`
`278`	`277`	`if sizable, ok := enum.(Sizable[T]); ok {`
`279`	`278`	`if s, known := sizable.Size(); known {`
`280`	`279`	`if s < n {`
`281`		`- size = &s`
	`280`	`+ size = s`
`282`	`281`	`} else {`
`283`		`- size = &n`
	`282`	`+ size = n`
`284`	`283`	`}`
`285`	`284`	`} else {`
`286`		`- size = &n // Don't know source size, but result won't exceed n`
	`285`	`+ size = n // Don't know source size, but result won't exceed n`
`287`	`286`	`}`
`288`	`287`	`} else {`
`289`		`- size = &n // Don't know source size, but result won't exceed n`
	`288`	`+ size = n // Don't know source size, but result won't exceed n`
`290`	`289`	`}`
`291`	`290`
`292`	`291`	`return &stream[T]{`
`@@ -413,6 +412,6 @@ func SelectMany[T, R any](enum Enumerable[T], selector func(T) Enumerable[R]) St`
`413`	`412`	`}`
`414`	`413`	`}`
`415`	`414`	`},`
`416`		`- size: nil, // LOSE: 1-to-many transformation`
	`415`	`+ size: -1, // LOSE: 1-to-many transformation`
`417`	`416`	`}`
`418`	`417`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,6 @@ func (s *stream[T]) orderBy(ascending bool, comparator func(T, T) int) Stream[T]`
`15`	`15`	`})`
`16`	`16`
`17`	`17`	`// SIZE: Preserves size (1-to-1 transformation, materializes)`
`18`		`- size := len(sorted)`
`19`	`18`	`return &stream[T]{`
`20`	`19`	`sourceFactory: func() func() (T, bool) {`
`21`	`20`	`index := 0 // Fresh index for each iterator`
`@@ -29,7 +28,7 @@ func (s *stream[T]) orderBy(ascending bool, comparator func(T, T) int) Stream[T]`
`29`	`28`	`return result, true`
`30`	`29`	`}`
`31`	`30`	`},`
`32`		`- size: &size, // PRESERVE: 1-to-1 transformation`
	`31`	`+ size: len(sorted), // PRESERVE: 1-to-1 transformation`
`33`	`32`	`}`
`34`	`33`	`}`
`35`	`34`
Original file line number	Diff line number	Diff line change
`@@ -5,16 +5,15 @@ package glinq`
`5`	`5`	`//`
`6`	`6`	`// SIZE: Calculated as currentSize + otherSize if both known, else unknown.`
`7`	`7`	`func (s *stream[T]) Concat(other Enumerable[T]) Stream[T] {`
`8`		`- var newSize *int`
`9`		`- if s.size != nil {`
	`8`	`+ var newSize int = -1`
	`9`	`+ if s.size != -1 {`
`10`	`10`	`if sizable, ok := other.(Sizable[T]); ok {`
`11`	`11`	`if otherSize, known := sizable.Size(); known {`
`12`		`- size := *s.size + otherSize`
`13`		`- newSize = &size`
	`12`	`+ newSize = s.size + otherSize`
`14`	`13`	`}`
`15`	`14`	`}`
`16`	`15`	`}`
`17`		`- // else: nil (unknown)`
	`16`	`+ // else: -1 (unknown)`
`18`	`17`
`19`	`18`	`return &stream[T]{`
`20`	`19`	`sourceFactory: func() func() (T, bool) {`
`@@ -79,7 +78,7 @@ func Union[T comparable](e1, e2 Enumerable[T]) Stream[T] {`
`79`	`78`	`}`
`80`	`79`	`}`
`81`	`80`	`},`
`82`		`- size: nil, // LOSE: unknown how many duplicates`
	`81`	`+ size: -1, // LOSE: unknown how many duplicates`
`83`	`82`	`}`
`84`	`83`	`}`
`85`	`84`
`@@ -117,7 +116,7 @@ func Intersect[T comparable](e1, e2 Enumerable[T]) Stream[T] {`
`117`	`116`	`}`
`118`	`117`	`}`
`119`	`118`	`},`
`120`		`- size: nil, // LOSE: unknown result count`
	`119`	`+ size: -1, // LOSE: unknown result count`
`121`	`120`	`}`
`122`	`121`	`}`
`123`	`122`
`@@ -155,6 +154,6 @@ func Except[T comparable](e1, e2 Enumerable[T]) Stream[T] {`
`155`	`154`	`}`
`156`	`155`	`}`
`157`	`156`	`},`
`158`		`- size: nil, // LOSE: unknown result count`
	`157`	`+ size: -1, // LOSE: unknown result count`
`159`	`158`	`}`
`160`	`159`	`}`