impl TakeSkip optimization

Author: neuecc

src/FileGen/DropinGen.cs

@@ -109,6 +109,11 @@ internal static partial class ZLinqDropInExtensions
  return null;
  }
 
+ if (methodInfo.Name is "Skip" && methodInfo.ReturnType.ToString().Contains("TakeSkip"))
+ {
+ return null;
+ }
+
  if (methodInfo.Name is "Contains" && !methodInfo.GetGenericArguments().Any(x => x.Name == "TEnumerator"))
  {
  return null;

src/ZLinq/Linq/Select.cs

@@ -99,7 +99,7 @@ public void Dispose()
  source.Dispose();
  }
 
- public SelectWhere<TEnumerator, TSource, TResult> Where(Func<TResult, bool> predicate)
+ internal SelectWhere<TEnumerator, TSource, TResult> Where(Func<TResult, bool> predicate)
  => new(source, selector, predicate);
  }
 

src/ZLinq/Linq/Skip.cs

@@ -125,4 +125,146 @@ public void Dispose()
  source.Dispose();
  }
  }
+
+ [StructLayout(LayoutKind.Auto)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+#if NET9_0_OR_GREATER
+ public ref
+#else
+ public
+#endif
+ struct SkipTake<TEnumerator, TSource>(TEnumerator source, Int32 skipCount, Int32 takeCount)
+ : IValueEnumerator<TSource>
+ where TEnumerator : struct, IValueEnumerator<TSource>
+#if NET9_0_OR_GREATER
+ , allows ref struct
+#endif
+ {
+ TEnumerator source = source;
+ internal readonly int skipCount = Math.Max(0, skipCount); // ensure non-negative
+ internal readonly int takeCount = Math.Max(0, takeCount); // ensure non-negative
+ int skipped;
+ int taken;
+
+ public bool TryGetNonEnumeratedCount(out int count)
+ {
+ if (source.TryGetNonEnumeratedCount(out count))
+ {
+ // Calculate elements after skipping
+ count = Math.Max(0, count - skipCount);
+ // Apply take limit
+ count = Math.Min(count, takeCount);
+ return true;
+ }
+
+ count = default;
+ return false;
+ }
+
+ public bool TryCopyTo(Span<TSource> destination, Index offset)
+ {
+ if (source.TryGetNonEnumeratedCount(out var sourceCount))
+ {
+ // Determine actual number of elements after skipping
+ var actualSkipCount = Math.Min(sourceCount, skipCount);
+ var availableAfterSkip = sourceCount - actualSkipCount;
+
+ // Apply take limit
+ var actualCount = Math.Min(availableAfterSkip, takeCount);
+
+ if (actualCount <= 0)
+ {
+ return false;
+ }
+
+ // Calculate offset within the resulting sequence
+ var offsetInResult = offset.GetOffset(actualCount);
+
+ if (offsetInResult < 0 || offsetInResult >= actualCount)
+ {
+ return false;
+ }
+
+ // Calculate offset in source sequence (skip + offset)
+ var sourceOffset = actualSkipCount + offsetInResult;
+
+ // Calculate elements available after offset
+ var elementsAvailable = actualCount - offsetInResult;
+
+ // Calculate elements to copy
+ var elementsToCopy = Math.Min(elementsAvailable, destination.Length);
+
+ if (elementsToCopy <= 0)
+ {
+ return false;
+ }
+
+ return source.TryCopyTo(destination.Slice(0, elementsToCopy), sourceOffset);
+ }
+
+ return false;
+ }
+
+ public bool TryGetSpan(out ReadOnlySpan<TSource> span)
+ {
+ if (source.TryGetSpan(out span))
+ {
+ // Skip elements
+ if (span.Length <= skipCount)
+ {
+ span = default;
+ return true;
+ }
+
+ span = span.Slice(skipCount);
+
+ // Take elements
+ if (span.Length > takeCount)
+ {
+ span = span.Slice(0, takeCount);
+ }
+
+ return true;
+ }
+
+ span = default;
+ return false;
+ }
+
+ public bool TryGetNext(out TSource current)
+ {
+ // Skip elements if not already skipped
+ while (skipped < skipCount)
+ {
+ if (!source.TryGetNext(out var _))
+ {
+ Unsafe.SkipInit(out current);
+ return false;
+ }
+ skipped++;
+ }
+
+ // Check if we've reached the take limit
+ if (taken >= takeCount)
+ {
+ Unsafe.SkipInit(out current);
+ return false;
+ }
+
+ // Return elements after skipping and before take limit
+ if (source.TryGetNext(out current))
+ {
+ taken++;
+ return true;
+ }
+
+ Unsafe.SkipInit(out current);
+ return false;
+ }
+
+ public void Dispose()
+ {
+ source.Dispose();
+ }
+ }
 }