[Zip] add extension.

Author: reegeek

Documents/BenchmarksResults/Zip.md

@@ -0,0 +1,21 @@
+## Zip
+
+### Source
+[Zip.cs](../../src/StructLinq.Benchmark/Zip.cs)
+
+### Results:
+``` ini
+
+BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19042
+Intel Core i7-7700 CPU 3.60GHz (Kaby Lake), 1 CPU, 8 logical and 4 physical cores
+.NET Core SDK=5.0.203
+  [Host]     : .NET Core 5.0.6 (CoreCLR 5.0.621.22011, CoreFX 5.0.621.22011), X64 RyuJIT
+  DefaultJob : .NET Core 5.0.6 (CoreCLR 5.0.621.22011, CoreFX 5.0.621.22011), X64 RyuJIT
+
+
+```
+|             Method |     Mean |    Error |   StdDev | Ratio |  Gen 0 | Gen 1 | Gen 2 | Allocated |
+|------------------- |---------:|---------:|---------:|------:|-------:|------:|------:|----------:|
+|               Linq | 70.70 μs | 0.718 μs | 0.672 μs |  1.00 |      - |     - |     - |     144 B |
+|         StructLinq | 12.76 μs | 0.022 μs | 0.020 μs |  0.18 | 0.0153 |     - |     - |      64 B |
+| StructLinqFunction | 10.38 μs | 0.014 μs | 0.012 μs |  0.15 |      - |     - |     - |         - |

src/StructLinq.Benchmark/Zip.cs

@@ -0,0 +1,64 @@
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+
+namespace StructLinq.Benchmark
+{
+    [MemoryDiagnoser]
+    public class Zip
+    {
+        private const int Count1 = 10000;
+        private const int Count2 = 5000;
+        public int[] array1;
+        public int[] array2;
+
+        public Zip()
+        {
+            array1 = Enumerable.Range(0, Count1).ToArray();
+            array2 = Enumerable.Range(0, Count2).ToArray();
+        }
+
+        [Benchmark(Baseline = true)]
+        public int Linq()
+        {
+            var sum = 0;
+#if !NETFRAMEWORK
+            foreach (var i in array1.Zip(array2))
+            {
+                sum += i.First + i.Second;
+            }
+#else
+            foreach (var i in array1.Zip(array2, (i, i1) => (i, i1)))
+            {
+                sum += i.Item1 + i.Item2;
+            }
+#endif
+
+            return sum;
+        }
+
+        [Benchmark]
+        public int StructLinq()
+        {
+            var sum = 0;
+            foreach (var i in array1.ToStructEnumerable().Zip(array2.ToStructEnumerable()))
+            {
+                sum += i.Item1 + i.Item2;
+            }
+
+            return sum;
+        }
+
+        [Benchmark]
+        public int StructLinqFunction()
+        {
+            var sum = 0;
+            foreach (var i in array1.ToStructEnumerable().Zip(array2.ToStructEnumerable(), x=> x, x=>x))
+            {
+                sum += i.Item1 + i.Item2;
+            }
+
+            return sum;
+        }
+
+    }
+}

src/StructLinq.Tests/ZipTests.cs

@@ -0,0 +1,34 @@
+using System.Linq;
+using StructLinq.Range;
+using StructLinq.Zip;
+using Xunit;
+
+namespace StructLinq.Tests
+{
+    public class ZipTests : AbstractEnumerableTests<(int, int),
+        ZipEnumerable<int, RangeEnumerable, RangeEnumerator, int, RangeEnumerable, RangeEnumerator>,
+        ZipEnumerator<int, RangeEnumerator, int, RangeEnumerator>>
+    {
+        protected override ZipEnumerable<int, RangeEnumerable, RangeEnumerator, int, RangeEnumerable, RangeEnumerator> Build(int size)
+        {
+            return new(StructEnumerable.Range(-10, size), StructEnumerable.Range(10, size));
+        }
+
+        [Theory]
+        [InlineData(0, 10)]
+        [InlineData(10, 0)]
+        [InlineData(5, 10)]
+        [InlineData(10, 5)]
+        [InlineData(10, 10)]
+        public void ShouldBeTheSameAsSystem(int size1, int size2)
+        {
+            var array1 = Enumerable.Range(-10, size1).ToArray();
+            var array2 = Enumerable.Range(-20, size2).ToArray();
+            var expected = array1.Zip(array2, (x, y)=> (x, y)).ToArray();
+            var values = array1.ToStructEnumerable()
+                               .Zip(array2.ToStructEnumerable(), x => x, x => x)
+                               .ToArray();
+            Assert.Equal(expected, values);
+        }
+    }
+}

src/StructLinq/StructLinq.csproj

@@ -20,6 +20,7 @@
     </PackageReference>
     <PackageReference Include="System.Buffers" Version="4.5.1" />
     <PackageReference Include="System.Collections.Immutable" Version="5.0.0" />
+    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
   </ItemGroup>
 
   <ItemGroup>

src/StructLinq/Zip/StructEnumerable.Zip.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Runtime.CompilerServices;
+using StructLinq.Zip;
+
+// ReSharper disable once CheckNamespace
+namespace StructLinq
+{
+    public static partial class StructEnumerable
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ZipEnumerable<T1, TEnumerable1, TEnumerator1, T2, TEnumerable2, TEnumerator2> Zip<T1, TEnumerable1, TEnumerator1, T2, TEnumerable2, TEnumerator2>(this TEnumerable1 enumerable1, TEnumerable2 enumerable2, 
+                                                                                                                                                                        Func<TEnumerable1, IStructEnumerable<T1, TEnumerator1>> _,
+                                                                                                                                                                        Func<TEnumerable2, IStructEnumerable<T2, TEnumerator2>> __)
+            where TEnumerable1 : IStructEnumerable<T1, TEnumerator1>
+            where TEnumerator1 : struct, IStructEnumerator<T1>
+            where TEnumerable2 : IStructEnumerable<T2, TEnumerator2>
+            where TEnumerator2 : struct, IStructEnumerator<T2>
+        {
+            return new (enumerable1, enumerable2);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ZipEnumerable<T1, IStructEnumerable<T1, TEnumerator1>, TEnumerator1, T2, IStructEnumerable<T2, TEnumerator2>, TEnumerator2> Zip<T1, TEnumerator1, T2, TEnumerator2>(this IStructEnumerable<T1, TEnumerator1> enumerable1, IStructEnumerable<T2, TEnumerator2> enumerable2)
+            where TEnumerator1 : struct, IStructEnumerator<T1>
+            where TEnumerator2 : struct, IStructEnumerator<T2>
+        {
+            return new (enumerable1, enumerable2);
+        }
+
+    }
+}

src/StructLinq/Zip/ZipEnumerable.cs

@@ -0,0 +1,39 @@
+using System.Runtime.CompilerServices;
+
+namespace StructLinq.Zip
+{
+    public struct ZipEnumerable<T1, TEnumerable1, TEnumerator1, T2, TEnumerable2, TEnumerator2> : IStructEnumerable<(T1 First, T2 Second), ZipEnumerator<T1, TEnumerator1, T2, TEnumerator2>>
+        where TEnumerator1 : struct, IStructEnumerator<T1>
+        where TEnumerator2 : struct, IStructEnumerator<T2>
+        where TEnumerable1 : IStructEnumerable<T1, TEnumerator1>
+        where TEnumerable2 : IStructEnumerable<T2, TEnumerator2>
+    {
+        private readonly TEnumerable1 enumerable1;
+        private readonly TEnumerable2 enumerable2;
+
+        public ZipEnumerable(TEnumerable1 enumerable1, TEnumerable2 enumerable2)
+        {
+            this.enumerable1 = enumerable1;
+            this.enumerable2 = enumerable2;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ZipEnumerator<T1, TEnumerator1, T2, TEnumerator2> GetEnumerator()
+        {
+            return new (enumerable1.GetEnumerator(), enumerable2.GetEnumerator());
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public VisitStatus Visit<TVisitor>(ref TVisitor visitor) where TVisitor : IVisitor<(T1, T2)>
+        {
+            foreach (var input in this)
+            {
+                if (!visitor.Visit(input))
+                    return VisitStatus.VisitorFinished;
+            }
+
+            return VisitStatus.EnumeratorFinished;
+
+        }
+    }
+}

src/StructLinq/Zip/ZipEnumerator.cs

@@ -0,0 +1,44 @@
+using System.Runtime.CompilerServices;
+
+namespace StructLinq.Zip
+{
+    public struct ZipEnumerator<T1, TEnumerator1, T2, TEnumerator2> : IStructEnumerator<(T1, T2)>
+        where TEnumerator1 : struct, IStructEnumerator<T1>
+        where TEnumerator2 : struct, IStructEnumerator<T2>
+    {
+        private TEnumerator1 enumerator1;
+        private TEnumerator2 enumerator2;
+
+        public ZipEnumerator(TEnumerator1 enumerator1, TEnumerator2 enumerator2)
+        {
+            this.enumerator1 = enumerator1;
+            this.enumerator2 = enumerator2;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Dispose()
+        {
+            enumerator1.Dispose();
+            enumerator2.Dispose();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool MoveNext()
+        {
+            return enumerator1.MoveNext() && enumerator2.MoveNext();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Reset()
+        {
+            enumerator1.Reset();
+            enumerator2.Reset();
+        }
+
+        public (T1, T2) Current
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (enumerator1.Current, enumerator2.Current);
+        }
+    }
+}