[ImmutableArray] add wrapper.

Author: reegeek

Documents/BenchmarksResults/ImmutableArrayWhereSelectSum.md

@@ -0,0 +1,21 @@
+## ImmutableArrayWhereSelectSum
+
+### Source
+[ImmutableArrayWhereSelectSum.cs](../../src/StructLinq.Benchmark/ImmutableArrayWhereSelectSum.cs)
+
+### Results:
+``` ini
+
+BenchmarkDotNet=v0.12.0, OS=Windows 10.0.19042
+Intel Core i7-8750H CPU 2.20GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores
+.NET Core SDK=5.0.100-preview.7.20366.6
+  [Host]     : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+  DefaultJob : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+
+
+```
+|             Method |     Mean |    Error |   StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+|------------------- |---------:|---------:|---------:|------:|--------:|------:|------:|------:|----------:|
+|               LINQ | 51.77 us | 0.492 us | 0.461 us |  1.00 |    0.00 |     - |     - |     - |     104 B |
+|         StructLinq | 68.73 us | 0.904 us | 0.846 us |  1.33 |    0.02 |     - |     - |     - |         - |
+| StructLinqFunction | 35.82 us | 0.350 us | 0.327 us |  0.69 |    0.01 |     - |     - |     - |         - |

src/StructLinq.BCL/ImmutableArray/BCLStructEnumerable.ImmutableArray.cs

@@ -0,0 +1,19 @@
+// ReSharper disable once CheckNamespace
+
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
+using StructLinq.IList;
+
+// ReSharper disable once CheckNamespace
+namespace StructLinq
+{
+    public static partial class BCLStructEnumerable
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static IListEnumerable<T, ImmutableArray<T>> ToStructEnumerable<T>(this ImmutableArray<T> enumerable) 
+        {
+            return new IListEnumerable<T, ImmutableArray<T>>(enumerable, 0, enumerable.Length);
+        }
+
+    }
+}

src/StructLinq.BCL/StructLinq.BCL.csproj

@@ -22,6 +22,7 @@
     <PackageReference Include="InlineIL.Fody" Version="1.6.0">
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
+    <PackageReference Include="System.Collections.Immutable" Version="1.3.0" />
   </ItemGroup>
 
 </Project>

src/StructLinq.Benchmark/ImmutableArrayWhereSelectToSum.cs

@@ -0,0 +1,44 @@
+using System.Collections.Immutable;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+
+namespace StructLinq.Benchmark
+{
+    [MemoryDiagnoser]
+    public class ImmutableArrayWhereSelectSum
+    {
+        private const int Count = 10000;
+        private readonly ImmutableArray<int> array;
+
+        public ImmutableArrayWhereSelectSum()
+        {
+            array = Enumerable.Range(0, Count).ToImmutableArray();
+        }
+
+       
+        [Benchmark(Baseline = true)]
+        public int LINQ() => array
+            .Where(x => (x & 1) == 0)
+            .Select(x => x * 2)
+            .Sum();
+
+        [Benchmark]
+        public int StructLinq() => array
+            .ToStructEnumerable()
+            .Where(x => (x & 1) == 0, x => x)
+            .Select(x => x * 2, x => x)
+            .Sum(x=>x);
+
+        [Benchmark]
+        public int StructLinqFunction()
+        {
+            var where = new WherePredicate();
+            var select = new SelectFunction();
+            return array
+                .ToStructEnumerable()
+                .Where(ref @where, x => x)
+                .Select(ref @select, x => x, x => x)
+                .Sum(x => x);
+        }
+    }
+}

src/StructLinq.Tests/IListTests.cs

@@ -7,8 +7,8 @@ namespace StructLinq.Tests
 {
     public class IListTests : AbstractCollectionTests<
         int, 
-        IListEnumerable<int>, 
-        IListEnumerator<int>>
+        IListEnumerable<int, IList<int>>, 
+        IListEnumerator<int, IList<int>>>
     {
         [Fact]
         public void ShouldSameAsSystem()
@@ -19,7 +19,7 @@ public void ShouldSameAsSystem()
             Assert.Equal(sysArray, structArray);
         }
 
-        protected override IListEnumerable<int> Build(int size)
+        protected override IListEnumerable<int, IList<int>> Build(int size)
         {
             IList<int> list = Enumerable.Range(-1, size).ToList();
             return list.ToStructEnumerable();

src/StructLinq/IList/IListEnumerable.cs

@@ -4,24 +4,25 @@
 
 namespace StructLinq.IList
 {
-    public struct IListEnumerable<T> : IStructCollection<T, IListEnumerator<T>>
+    public struct IListEnumerable<T, TList> : IStructCollection<T, IListEnumerator<T, TList>>
+        where TList : IList<T>
     {
         #region private fields
-        private readonly IList<T> list;
+        private readonly TList list;
         private int length;
         private int start;
         #endregion
-        public IListEnumerable(IList<T> list, int start, int length)
+        public IListEnumerable(TList list, int start, int length)
         {
             this.list = list;
             this.length = length;
             this.start = start;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public readonly IListEnumerator<T> GetEnumerator()
+        public readonly IListEnumerator<T, TList> GetEnumerator()
         {
-            return new IListEnumerator<T>(list, start, Count);
+            return new IListEnumerator<T, TList>(list, start, Count);
         }
         public readonly int Count
         {
@@ -42,7 +43,7 @@ public void Slice(uint start, uint? length)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public object Clone()
         {
-            return new IListEnumerable<T>(list, start, length);
+            return new IListEnumerable<T, TList>(list, start, length);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/StructLinq/IList/IlistEnumerator.cs

@@ -4,16 +4,17 @@
 
 namespace StructLinq.IList
 {
-    public struct IListEnumerator<T> : IStructEnumerator<T>
+    public struct IListEnumerator<T, TList> : IStructEnumerator<T>
+        where TList : IList<T>
     {
         #region private fields
-        private readonly IList<T> list;
+        private readonly TList list;
         private readonly int endIndex;
         private readonly int start;
         private int index;
 
         #endregion
-        public IListEnumerator(IList<T> list, int start, int length)
+        public IListEnumerator(TList list, int start, int length)
         {
             this.list = list;
             endIndex = length - 1 + start;

src/StructLinq/IList/StructEnumerable.IList.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using StructLinq.IList;
 
@@ -8,9 +9,17 @@ namespace StructLinq
     public static partial class StructEnumerable
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static IListEnumerable<T> ToStructEnumerable<T>(this IList<T> enumerable)
+        public static IListEnumerable<T, IList<T>> ToStructEnumerable<T>(this IList<T> enumerable)
         {
-            return new IListEnumerable<T>(enumerable, 0, enumerable.Count);
+            return new IListEnumerable<T, IList<T>>(enumerable, 0, enumerable.Count);
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static IListEnumerable<T, TList> ToStructEnumerable<T, TList>(this TList enumerable, Func<TList, IList<T>> _) 
+            where TList : IList<T>
+        {
+            return new IListEnumerable<T, TList>(enumerable, 0, enumerable.Count);
+        }
+
     }
 }