[Select] SelectEnumerable is now zero alloc.

reegeek · reegeek · commit 0ab3c03e6b3a · 2020-03-10T15:15:38.000+01:00
diff --git a/src/StructLinq.Benchmark/ArrayClassSum.cs b/src/StructLinq.Benchmark/ArrayClassSum.cs
@@ -19,8 +19,8 @@ public ArrayClassSum()
             array = Enumerable.Range(0, Count).Select(x => new Container(x)).ToArray();
             var @select = new ContainerSelect();
             sysArray = array.Select(x => x.Element);
-            convertArray = array.ToStructEnumerable().Select(x => x.Element);
-            safeStructArray = array.ToStructEnumerable().Select(in select, Id<int>.Value);
+            convertArray = array.ToStructEnumerable().Select(x => x.Element, x => x);
+            safeStructArray = array.ToStructEnumerable().Select(ref select, x=>x, x => x);
         }
         [Benchmark]
         public int SysSum()
@@ -55,7 +55,7 @@ public Container(int element)
 
     internal struct ContainerSelect : IFunction<Container, int>
     {
-        public readonly int Eval(in Container element)
+        public readonly int Eval(Container element)
         {
             return element.Element;
         }
diff --git a/src/StructLinq.Benchmark/ArrayReadonlyStructSum.cs b/src/StructLinq.Benchmark/ArrayReadonlyStructSum.cs
@@ -19,8 +19,8 @@ public ArrayReadonlyStructSum()
             array = Enumerable.Range(0, Count).Select(x => ReadonlyStructContainer.Create(x)).ToArray();
             var @select = new ReadonlyStructContainerSelect();
             sysArray = array.Select(x => x.Element);
-            convertArray = array.ToStructEnumerable().Select(x => x.Element);
-            safeStructArray = array.ToStructEnumerable().Select(in select, Id<int>.Value);
+            convertArray = array.ToStructEnumerable().Select(x => x.Element, x => x);
+            safeStructArray = array.ToStructEnumerable().Select(ref select, x=>x, x => x);
         }
         [Benchmark]
         public int SysSum()
@@ -44,7 +44,7 @@ public int SysSum()
 
     internal struct ReadonlyStructContainerSelect : IFunction<ReadonlyStructContainer, int>
     {
-        public readonly int Eval(in ReadonlyStructContainer element)
+        public readonly int Eval(ReadonlyStructContainer element)
         {
             return element.Element;
         }
diff --git a/src/StructLinq.Benchmark/ArraySealedClassSum.cs b/src/StructLinq.Benchmark/ArraySealedClassSum.cs
@@ -19,8 +19,8 @@ public ArraySealedClassSum()
             array = Enumerable.Range(0, Count).Select(x=> new SealedContainer(x)).ToArray();
             var @select = new SealedContainerSelect();
             sysArray = array.Select(x=> x.Element);
-            convertArray = array.ToStructEnumerable().Select(x => x.Element);
-            safeStructArray = array.ToStructEnumerable().Select(in select, Id<int>.Value);
+            convertArray = array.ToStructEnumerable().Select(x => x.Element, x => x);
+            safeStructArray = array.ToStructEnumerable().Select(ref select, x=>x, x => x);
         }
         [Benchmark]
         public int SysSum()
@@ -44,7 +44,7 @@ public int SysSum()
 
     internal struct SealedContainerSelect : IFunction<SealedContainer, int>
     {
-        public readonly int Eval(in SealedContainer element)
+        public readonly int Eval(SealedContainer element)
         {
             return element.Element;
         }
diff --git a/src/StructLinq.Benchmark/ArrayStructSum.cs b/src/StructLinq.Benchmark/ArrayStructSum.cs
@@ -19,8 +19,8 @@ public ArrayStructSum()
             array = Enumerable.Range(0, Count).Select(x => StructContainer.Create(x)).ToArray();
             var @select = new StructContainerSelect();
             sysArray = array.Select(x => x.Element);
-            convertArray = array.ToStructEnumerable().Select(x => x.Element);
-            safeStructArray = array.ToStructEnumerable().Select(in select, Id<int>.Value);
+            convertArray = array.ToStructEnumerable().Select(x => x.Element, x => x);
+            safeStructArray = array.ToStructEnumerable().Select(ref select, x=>x, x => x);
         }
         [Benchmark]
         public int SysSum()
@@ -45,7 +45,7 @@ public int SysSum()
 
     internal struct StructContainerSelect : IFunction<StructContainer, int>
     {
-        public readonly int Eval(in StructContainer element)
+        public readonly int Eval(StructContainer element)
         {
             return element.Element;
         }
diff --git a/src/StructLinq.Benchmark/ForEachOnArrayOfClassVsOfStruct.cs b/src/StructLinq.Benchmark/ForEachOnArrayOfClassVsOfStruct.cs
@@ -13,14 +13,14 @@ namespace StructLinq.Benchmark
     public class SumOnArrayOfClassVsOfStruct
     {
         private readonly ClassContainer[] sysRange;
-        private readonly SelectEnumerable<StructContainer, int, ArrayStructEnumerator<StructContainer>, StructFunction<StructContainer, int>> arrayOfStructEnumerable;
-        private readonly SelectEnumerable<ClassContainer, int, ArrayStructEnumerator<ClassContainer>, StructFunction<ClassContainer, int>> arrayOfClassEnumerable;
+        private readonly SelectEnumerable<StructContainer, int, ArrayEnumerable<StructContainer>, ArrayStructEnumerator<StructContainer>, StructFunction<StructContainer, int>> arrayOfStructEnumerable;
+        private readonly SelectEnumerable<ClassContainer, int, ArrayEnumerable<ClassContainer>, ArrayStructEnumerator<ClassContainer>, StructFunction<ClassContainer, int>> arrayOfClassEnumerable;
         private const int Count = 10000;
         public SumOnArrayOfClassVsOfStruct()
         {
             sysRange = Enumerable.Range(0, Count).Select(x=> new ClassContainer(x)).ToArray();
-            arrayOfClassEnumerable = Enumerable.Range(0, Count).Select(x=> new ClassContainer(x)).ToArray().ToStructEnumerable().Select(x=> x.Index);
-            arrayOfStructEnumerable = Enumerable.Range(0, Count).Select(x => new StructContainer(x)).ToArray().ToStructEnumerable().Select(x => x.Index);
+            arrayOfClassEnumerable = Enumerable.Range(0, Count).Select(x=> new ClassContainer(x)).ToArray().ToStructEnumerable().Select(x=> x.Index, x => x);
+            arrayOfStructEnumerable = Enumerable.Range(0, Count).Select(x => new StructContainer(x)).ToArray().ToStructEnumerable().Select(x => x.Index, x => x);
         }
 
         [Benchmark(Baseline = true)]
diff --git a/src/StructLinq.Benchmark/RangeWhereSelectSum.cs b/src/StructLinq.Benchmark/RangeWhereSelectSum.cs
@@ -25,13 +25,13 @@ public RangeWhereSelectSum()
             var select = new SelectFunction();
             convertWithDelegate = Enumerable.Range(0, Count).ToStructEnumerable()
                 .Where(x => (x & 1) == 0)
-                .Select(x => x *2);
+                .Select(x => x *2, x => x);
             convertWithStruct = Enumerable.Range(0, Count).ToStructEnumerable()
                 .Where(in where)
-                .Select(in select, Id<int>.Value);
+                .Select(ref select, x=>x, x => x);
             structRange = StructEnumerable.Range(0, Count)
                 .Where(in where)
-                .Select(in select, Id<int>.Value);
+                .Select(ref select, x=>x, x => x);
         }
         [Benchmark(Baseline = true)]
         public int SysSum()
@@ -62,15 +62,15 @@ public int SysSum()
 
     struct WherePredicate : IFunction<int, bool>
     {
-        public readonly bool Eval(in int element)
+        public readonly bool Eval(int element)
         {
             return (element & 1) == 0;
         }
     }
 
     struct SelectFunction : IFunction<int, int>
     {
-        public readonly int Eval(in int element)
+        public readonly int Eval(int element)
         {
             return element * 2;
         }
diff --git a/src/StructLinq.Benchmark/Select.cs b/src/StructLinq.Benchmark/Select.cs
@@ -1,71 +1,75 @@
-﻿using System.Collections.Generic;
-using System.Linq;
+﻿using System.Linq;
 using BenchmarkDotNet.Attributes;
-using StructLinq.IEnumerable;
-using StructLinq.Range;
-using StructLinq.Select;
 
 namespace StructLinq.Benchmark
 {
-    [MemoryDiagnoser]
+
+    //BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18363
+    //Intel Core i7-7700 CPU 3.60GHz (Kaby Lake), 1 CPU, 8 logical and 4 physical cores
+    //.NET Core SDK=3.1.101
+    //[Host]     : .NET Core 3.1.1 (CoreCLR 4.700.19.60701, CoreFX 4.700.19.60801), X64 RyuJIT
+    //DefaultJob : .NET Core 3.1.1 (CoreCLR 4.700.19.60701, CoreFX 4.700.19.60801), X64 RyuJIT
+
+
+    //```
+    //|         Method |     Mean |    Error |   StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+    //|--------------- |---------:|---------:|---------:|------:|--------:|------:|------:|------:|----------:|
+    //|      SysSelect | 66.87 us | 1.280 us | 1.524 us |  1.00 |    0.00 |     - |     - |     - |      88 B |
+    //| DelegateSelect | 30.33 us | 0.606 us | 0.744 us |  0.45 |    0.02 |     - |     - |     - |         - |
+    //|   StructSelect | 19.63 us | 0.213 us | 0.189 us |  0.30 |    0.01 |     - |     - |     - |         - |
+    //|  ConvertSelect | 69.85 us | 1.508 us | 1.411 us |  1.05 |    0.03 |     - |     - |     - |      40 B |
+
+    [MemoryDiagnoser, DisassemblyDiagnoser(recursiveDepth: 4)]
     public class Select
     {
-        private readonly IEnumerable<double> sysRange;
-        private readonly IStructEnumerable<double, SelectEnumerator<int, double, RangeEnumerator, StructFunction<int, double>>> delegateRange;
-        private readonly IStructEnumerable<double, SelectEnumerator<int, double, GenericEnumerator<int>, StructFunction<int, double>>> convertRange;
-        private readonly CountAction<double>[] countActions = new CountAction<double>[1];
         private const int Count = 10000;
-        private readonly IStructEnumerable<double, SelectEnumerator<int, double, RangeEnumerator, MultFunction>> structRange;
         public Select()
         {
-            sysRange = Enumerable.Range(0, Count).Select(x=> x * 2.0);
-            delegateRange = StructEnumerable.Range(0, Count).Select(x=> x * 2.0);
-            convertRange = Enumerable.Range(0, Count).ToStructEnumerable().Select(x=> x * 2.0);
-            var multFunction = new MultFunction();
-            structRange = StructEnumerable.Range(0, Count).Select(in multFunction, Id<double>.Value);
         }
 
         [Benchmark(Baseline = true)]
-        public int SysSelect()
+        public double SysSelect()
         {
-            int count = 0;
-            foreach (var i in sysRange)
+            double sum = 0;
+            var enumerable = Enumerable.Range(0, Count).Select(x=> x * 2.0);
+            foreach (var i in enumerable)
             {
-                count++;
+                sum+= i;
             }
-            return count;
+            return sum;
         }
 
         [Benchmark]
-        public int DelegateSelect()
+        public double DelegateSelect()
         {
-            int count = 0;
-            delegateRange.ForEach(i => count++);
-            return count;
+            return StructEnumerable
+                   .Range(0, Count)
+                   .Select(x => x * 2.0, x => x)
+                   .Sum(x=>x);
         }
 
         [Benchmark]
-        public int StructSelect()
+        public double StructSelect()
         {
-            ref CountAction<double> countAction = ref countActions[0];
-            countAction.Count = 0;
-            structRange.ForEach(ref countAction);
-            return countAction.Count;
+            var multFunction = new MultFunction();
+            return StructEnumerable.Range(0, Count)
+                            .Select(ref multFunction, x=>x, x => x)
+                            .Sum(x=> x);
         }
 
         [Benchmark]
-        public int ConvertSelect()
+        public double ConvertSelect()
         {
-            ref CountAction<double> countAction = ref countActions[0];
-            countAction.Count = 0;
-            convertRange.ForEach(ref countAction);
-            return countAction.Count;
+            return Enumerable.Range(0, Count)
+                      .ToStructEnumerable()
+                      .Select(x=> x * 2.0, x => x)
+                      .Sum(x=>x);
         }
     }
 
-    struct MultFunction : IFunction<int, double>
+    readonly struct MultFunction : IFunction<int, double>
     {
-        public readonly double Eval(in int element)
+        public double Eval(int element)
         {
             return element * 2.0;
         }
diff --git a/src/StructLinq.Benchmark/Where.cs b/src/StructLinq.Benchmark/Where.cs
@@ -68,7 +68,7 @@ public int ConvertSelect()
 
     struct WhereFunc : IFunction<int, bool>
     {
-        public readonly bool Eval(in int element)
+        public readonly bool Eval(int element)
         {
             return element > 0;
         }
diff --git a/src/StructLinq.Tests/SelectTests.cs b/src/StructLinq.Tests/SelectTests.cs
@@ -33,7 +33,7 @@ public void StructTest()
             var fct = new MultFunction();
             var structEnum = StructEnumerable
                 .Range(-50, 100)
-                .Select(in fct, Id<double>.Value)
+                .Select(ref fct, x=>x, x => x)
                 .ToArray();
             Assert.Equal(sys, structEnum);
 
@@ -46,7 +46,7 @@ protected override IEnumerable<int> Build(int size)
 
         struct MultFunction : IFunction<int, double>
         {
-            public double Eval(in int element)
+            public double Eval(int element)
             {
                 return element * 2.0;
             }
diff --git a/src/StructLinq.Tests/WhereTests.cs b/src/StructLinq.Tests/WhereTests.cs
@@ -46,7 +46,7 @@ public void StructTest()
 
         struct WhereFunc : IFunction<int, bool>
         {
-            public bool Eval(in int element)
+            public bool Eval(int element)
             {
                 return element > 0;
             }
diff --git a/src/StructLinq/Functions.cs b/src/StructLinq/Functions.cs
@@ -19,7 +19,7 @@ public StructFunction(Func<TIn, TOut> inner)
         {
             this.inner = inner;
         }
-        public readonly TOut Eval(in TIn element)
+        public readonly TOut Eval(TIn element)
         {
             return inner(element);
         }
diff --git a/src/StructLinq/IFunction.cs b/src/StructLinq/IFunction.cs
@@ -1,7 +1,7 @@
 ﻿namespace StructLinq
 {
-    public interface IFunction<TIn, out TOut>
+    public interface IFunction<in TIn, out TOut>
     {
-        TOut Eval(in TIn element);
+        TOut Eval(TIn element);
     }
 }
diff --git a/src/StructLinq/Id.cs b/src/StructLinq/Id.cs
diff --git a/src/StructLinq/Range/RangeStructEnumerable.cs b/src/StructLinq/Range/RangeStructEnumerable.cs
@@ -1,10 +1,12 @@
-﻿using StructLinq.Range;
+﻿using System.Runtime.CompilerServices;
+using StructLinq.Range;
 
 // ReSharper disable once CheckNamespace
 namespace StructLinq
 {
     public static partial class StructEnumerable
     {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static RangeEnumerable Range(int start, int count)
         {
             return new RangeEnumerable(start, count);
diff --git a/src/StructLinq/Select/SelectEnumerable.cs b/src/StructLinq/Select/SelectEnumerable.cs
@@ -1,27 +1,31 @@
 ﻿using System.Collections;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using StructLinq.IEnumerable;
 
 namespace StructLinq.Select
 {
-    public readonly struct SelectEnumerable<TIn, TOut, TEnumerator, TFunction> : IStructEnumerable<TOut, SelectEnumerator<TIn, TOut, TEnumerator, TFunction>>
+    public struct SelectEnumerable<TIn, TOut, TEnumerable, TEnumerator, TFunction> : IStructEnumerable<TOut, SelectEnumerator<TIn, TOut, TEnumerator, TFunction>>
         where TFunction : struct, IFunction<TIn, TOut>
         where TEnumerator : struct, IStructEnumerator<TIn>
+        where TEnumerable : struct, IStructEnumerable<TIn, TEnumerator>
     {
         #region private fields
-        private readonly TFunction function;
-        private readonly IStructEnumerable<TIn, TEnumerator> inner;
+        private TFunction function;
+        private TEnumerable inner;
         #endregion
-        public SelectEnumerable(in TFunction function, in IStructEnumerable<TIn, TEnumerator> inner)
+
+        public SelectEnumerable(ref TFunction function, ref TEnumerable inner)
         {
             this.function = function;
             this.inner = inner;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public SelectEnumerator<TIn, TOut, TEnumerator, TFunction> GetStructEnumerator()
         {
             var typedEnumerator = inner.GetStructEnumerator();
-            return new SelectEnumerator<TIn, TOut, TEnumerator, TFunction>(function, typedEnumerator);
+            return new SelectEnumerator<TIn, TOut, TEnumerator, TFunction>(ref function, ref typedEnumerator);
         }
 
         IEnumerator System.Collections.IEnumerable.GetEnumerator()
@@ -33,7 +37,6 @@ public IEnumerator<TOut> GetEnumerator()
         {
             return new StructEnumerator<TOut>(GetStructEnumerator());
         }
-
     }
 }
 
diff --git a/src/StructLinq/Select/SelectEnumerator.cs b/src/StructLinq/Select/SelectEnumerator.cs
diff --git a/src/StructLinq/Select/SelectStructEnumerable.cs b/src/StructLinq/Select/SelectStructEnumerable.cs

Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@ public ArrayClassSum()`
`19`	`19`	`array = Enumerable.Range(0, Count).Select(x => new Container(x)).ToArray();`
`20`	`20`	`var @select = new ContainerSelect();`
`21`	`21`	`sysArray = array.Select(x => x.Element);`
`22`		`- convertArray = array.ToStructEnumerable().Select(x => x.Element);`
`23`		`- safeStructArray = array.ToStructEnumerable().Select(in select, Id<int>.Value);`
	`22`	`+ convertArray = array.ToStructEnumerable().Select(x => x.Element, x => x);`
	`23`	`+ safeStructArray = array.ToStructEnumerable().Select(ref select, x=>x, x => x);`
`24`	`24`	`}`
`25`	`25`	`[Benchmark]`
`26`	`26`	`public int SysSum()`
`@@ -55,7 +55,7 @@ public Container(int element)`
`55`	`55`
`56`	`56`	`internal struct ContainerSelect : IFunction<Container, int>`
`57`	`57`	`{`
`58`		`- public readonly int Eval(in Container element)`
	`58`	`+ public readonly int Eval(Container element)`
`59`	`59`	`{`
`60`	`60`	`return element.Element;`
`61`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@ public ArrayReadonlyStructSum()`
`19`	`19`	`array = Enumerable.Range(0, Count).Select(x => ReadonlyStructContainer.Create(x)).ToArray();`
`20`	`20`	`var @select = new ReadonlyStructContainerSelect();`
`21`	`21`	`sysArray = array.Select(x => x.Element);`
`22`		`- convertArray = array.ToStructEnumerable().Select(x => x.Element);`
`23`		`- safeStructArray = array.ToStructEnumerable().Select(in select, Id<int>.Value);`
	`22`	`+ convertArray = array.ToStructEnumerable().Select(x => x.Element, x => x);`
	`23`	`+ safeStructArray = array.ToStructEnumerable().Select(ref select, x=>x, x => x);`
`24`	`24`	`}`
`25`	`25`	`[Benchmark]`
`26`	`26`	`public int SysSum()`
`@@ -44,7 +44,7 @@ public int SysSum()`
`44`	`44`
`45`	`45`	`internal struct ReadonlyStructContainerSelect : IFunction<ReadonlyStructContainer, int>`
`46`	`46`	`{`
`47`		`- public readonly int Eval(in ReadonlyStructContainer element)`
	`47`	`+ public readonly int Eval(ReadonlyStructContainer element)`
`48`	`48`	`{`
`49`	`49`	`return element.Element;`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@ public ArraySealedClassSum()`
`19`	`19`	`array = Enumerable.Range(0, Count).Select(x=> new SealedContainer(x)).ToArray();`
`20`	`20`	`var @select = new SealedContainerSelect();`
`21`	`21`	`sysArray = array.Select(x=> x.Element);`
`22`		`- convertArray = array.ToStructEnumerable().Select(x => x.Element);`
`23`		`- safeStructArray = array.ToStructEnumerable().Select(in select, Id<int>.Value);`
	`22`	`+ convertArray = array.ToStructEnumerable().Select(x => x.Element, x => x);`
	`23`	`+ safeStructArray = array.ToStructEnumerable().Select(ref select, x=>x, x => x);`
`24`	`24`	`}`
`25`	`25`	`[Benchmark]`
`26`	`26`	`public int SysSum()`
`@@ -44,7 +44,7 @@ public int SysSum()`
`44`	`44`
`45`	`45`	`internal struct SealedContainerSelect : IFunction<SealedContainer, int>`
`46`	`46`	`{`
`47`		`- public readonly int Eval(in SealedContainer element)`
	`47`	`+ public readonly int Eval(SealedContainer element)`
`48`	`48`	`{`
`49`	`49`	`return element.Element;`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@ public ArrayStructSum()`
`19`	`19`	`array = Enumerable.Range(0, Count).Select(x => StructContainer.Create(x)).ToArray();`
`20`	`20`	`var @select = new StructContainerSelect();`
`21`	`21`	`sysArray = array.Select(x => x.Element);`
`22`		`- convertArray = array.ToStructEnumerable().Select(x => x.Element);`
`23`		`- safeStructArray = array.ToStructEnumerable().Select(in select, Id<int>.Value);`
	`22`	`+ convertArray = array.ToStructEnumerable().Select(x => x.Element, x => x);`
	`23`	`+ safeStructArray = array.ToStructEnumerable().Select(ref select, x=>x, x => x);`
`24`	`24`	`}`
`25`	`25`	`[Benchmark]`
`26`	`26`	`public int SysSum()`
`@@ -45,7 +45,7 @@ public int SysSum()`
`45`	`45`
`46`	`46`	`internal struct StructContainerSelect : IFunction<StructContainer, int>`
`47`	`47`	`{`
`48`		`- public readonly int Eval(in StructContainer element)`
	`48`	`+ public readonly int Eval(StructContainer element)`
`49`	`49`	`{`
`50`	`50`	`return element.Element;`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,14 +13,14 @@ namespace StructLinq.Benchmark`
`13`	`13`	`public class SumOnArrayOfClassVsOfStruct`
`14`	`14`	`{`
`15`	`15`	`private readonly ClassContainer[] sysRange;`
`16`		`- private readonly SelectEnumerable<StructContainer, int, ArrayStructEnumerator<StructContainer>, StructFunction<StructContainer, int>> arrayOfStructEnumerable;`
`17`		`- private readonly SelectEnumerable<ClassContainer, int, ArrayStructEnumerator<ClassContainer>, StructFunction<ClassContainer, int>> arrayOfClassEnumerable;`
	`16`	`+ private readonly SelectEnumerable<StructContainer, int, ArrayEnumerable<StructContainer>, ArrayStructEnumerator<StructContainer>, StructFunction<StructContainer, int>> arrayOfStructEnumerable;`
	`17`	`+ private readonly SelectEnumerable<ClassContainer, int, ArrayEnumerable<ClassContainer>, ArrayStructEnumerator<ClassContainer>, StructFunction<ClassContainer, int>> arrayOfClassEnumerable;`
`18`	`18`	`private const int Count = 10000;`
`19`	`19`	`public SumOnArrayOfClassVsOfStruct()`
`20`	`20`	`{`
`21`	`21`	`sysRange = Enumerable.Range(0, Count).Select(x=> new ClassContainer(x)).ToArray();`
`22`		`- arrayOfClassEnumerable = Enumerable.Range(0, Count).Select(x=> new ClassContainer(x)).ToArray().ToStructEnumerable().Select(x=> x.Index);`
`23`		`- arrayOfStructEnumerable = Enumerable.Range(0, Count).Select(x => new StructContainer(x)).ToArray().ToStructEnumerable().Select(x => x.Index);`
	`22`	`+ arrayOfClassEnumerable = Enumerable.Range(0, Count).Select(x=> new ClassContainer(x)).ToArray().ToStructEnumerable().Select(x=> x.Index, x => x);`
	`23`	`+ arrayOfStructEnumerable = Enumerable.Range(0, Count).Select(x => new StructContainer(x)).ToArray().ToStructEnumerable().Select(x => x.Index, x => x);`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`[Benchmark(Baseline = true)]`
Original file line number	Diff line number	Diff line change
`@@ -25,13 +25,13 @@ public RangeWhereSelectSum()`
`25`	`25`	`var select = new SelectFunction();`
`26`	`26`	`convertWithDelegate = Enumerable.Range(0, Count).ToStructEnumerable()`
`27`	`27`	`.Where(x => (x & 1) == 0)`
`28`		`- .Select(x => x *2);`
	`28`	`+ .Select(x => x *2, x => x);`
`29`	`29`	`convertWithStruct = Enumerable.Range(0, Count).ToStructEnumerable()`
`30`	`30`	`.Where(in where)`
`31`		`- .Select(in select, Id<int>.Value);`
	`31`	`+ .Select(ref select, x=>x, x => x);`
`32`	`32`	`structRange = StructEnumerable.Range(0, Count)`
`33`	`33`	`.Where(in where)`
`34`		`- .Select(in select, Id<int>.Value);`
	`34`	`+ .Select(ref select, x=>x, x => x);`
`35`	`35`	`}`
`36`	`36`	`[Benchmark(Baseline = true)]`
`37`	`37`	`public int SysSum()`
`@@ -62,15 +62,15 @@ public int SysSum()`
`62`	`62`
`63`	`63`	`struct WherePredicate : IFunction<int, bool>`
`64`	`64`	`{`
`65`		`- public readonly bool Eval(in int element)`
	`65`	`+ public readonly bool Eval(int element)`
`66`	`66`	`{`
`67`	`67`	`return (element & 1) == 0;`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`struct SelectFunction : IFunction<int, int>`
`72`	`72`	`{`
`73`		`- public readonly int Eval(in int element)`
	`73`	`+ public readonly int Eval(int element)`
`74`	`74`	`{`
`75`	`75`	`return element * 2;`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ public int ConvertSelect()`
`68`	`68`
`69`	`69`	`struct WhereFunc : IFunction<int, bool>`
`70`	`70`	`{`
`71`		`- public readonly bool Eval(in int element)`
	`71`	`+ public readonly bool Eval(int element)`
`72`	`72`	`{`
`73`	`73`	`return element > 0;`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public void StructTest()`
`33`	`33`	`var fct = new MultFunction();`
`34`	`34`	`var structEnum = StructEnumerable`
`35`	`35`	`.Range(-50, 100)`
`36`		`- .Select(in fct, Id<double>.Value)`
	`36`	`+ .Select(ref fct, x=>x, x => x)`
`37`	`37`	`.ToArray();`
`38`	`38`	`Assert.Equal(sys, structEnum);`
`39`	`39`
`@@ -46,7 +46,7 @@ protected override IEnumerable<int> Build(int size)`
`46`	`46`
`47`	`47`	`struct MultFunction : IFunction<int, double>`
`48`	`48`	`{`
`49`		`- public double Eval(in int element)`
	`49`	`+ public double Eval(int element)`
`50`	`50`	`{`
`51`	`51`	`return element * 2.0;`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public void StructTest()`
`46`	`46`
`47`	`47`	`struct WhereFunc : IFunction<int, bool>`
`48`	`48`	`{`
`49`		`- public bool Eval(in int element)`
	`49`	`+ public bool Eval(int element)`
`50`	`50`	`{`
`51`	`51`	`return element > 0;`
`52`	`52`	`}`