Implement Chunk method

src/flatcollections-array/FlatArray.Tests/FlatArray.Tests.csproj

@@ -24,10 +24,10 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
     <PackageReference Include="PrimeFuncPack.UnitTest.Data" Version="3.1.0" />
-    <PackageReference Include="xunit" Version="2.7.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.7">
+    <PackageReference Include="xunit" Version="2.9.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

src/flatcollections-array/FlatArray.Tests/Internal.Helper/FlatArray/FlatArray.Verify.cs

@@ -49,4 +49,24 @@ internal static void VerifyTruncatedState<T>(this FlatArray<T> actual, params T[
 
         Assert.Equal(expectedItems, truncatedItems);
     }
+
+    internal static void VerifyTruncatedState<T>(this FlatArray<FlatArray<T>> actual, params T[][]? expectedItems)
+    {
+        var actualLength = actual.GetStructFieldValue<int>("length");
+        Assert.StrictEqual(expectedItems?.Length ?? default, actualLength);
+
+        var actualItems = actual.GetFieldValue<FlatArray<T>[]?>("items");
+        if (actualItems is null)
+        {
+            Assert.Null(expectedItems);
+            return;
+        }
+
+        Assert.NotNull(expectedItems);
+
+        for (var i = 0; i < actualLength; i++)
+        {
+            actualItems[i].VerifyTruncatedState(expectedItems[i]);
+        }
+    }
 }

src/flatcollections-array/FlatArray.Tests/Tests.FlatArray.T/Functional/Chunk.cs

@@ -0,0 +1,113 @@
+using System;
+using Xunit;
+using static PrimeFuncPack.UnitTest.TestData;
+
+namespace PrimeFuncPack.Core.Tests;
+
+partial class FlatArrayTest
+{
+    [Theory]
+    [MemberData(nameof(Chunk_InvalidSizeTestData))]
+    public static void Chunk_SizeIsInvalid_ExpectArgumentOutOfRangeException(
+        FlatArray<string> source, int size)
+    {
+        var ex = Assert.Throws<ArgumentOutOfRangeException>(Test);
+        Assert.Equal("size", ex.ParamName);
+
+        void Test()
+            =>
+            _ = source.Chunk(size);
+    }
+
+    [Theory]
+    [MemberData(nameof(Chunk_ValidTestData))]
+    public static void Chunk_SizeIsValid_ExpectCorrectChunks(
+        FlatArray<string> source, int size, string[][]? expectedChunks)
+    {
+        var actual = source.Chunk(size);
+        actual.VerifyTruncatedState(expectedChunks);
+    }
+
+    public static TheoryData<FlatArray<string>, int> Chunk_InvalidSizeTestData
+        =>
+        new()
+        {
+            {
+                default,
+                0
+            },
+            {
+                default,
+                -1
+            },
+            {
+                new[] { SomeString, AnotherString }.InitializeFlatArray(),
+                0
+            },
+            {
+                new[] { SomeString, AnotherString }.InitializeFlatArray(),
+                -1
+            }
+        };
+
+    public static TheoryData<FlatArray<string>, int, string[][]?> Chunk_ValidTestData
+        =>
+        new()
+        {
+            {
+                default,
+                1,
+                null
+            },
+            {
+                new[] { EmptyString }.InitializeFlatArray(0),
+                1,
+                null
+            },
+            {
+                default,
+                3,
+                null
+            },
+            {
+                new[] { SomeString, EmptyString, WhiteSpaceString, AnotherString }.InitializeFlatArray(3),
+                2,
+                [
+                    [SomeString, EmptyString],
+                    [WhiteSpaceString]
+                ]
+            },
+            {
+                new[] { SomeString, EmptyString, WhiteSpaceString, AnotherString }.InitializeFlatArray(4),
+                2,
+                [
+                    [SomeString, EmptyString],
+                    [WhiteSpaceString, AnotherString]
+                ]
+            },
+            {
+                new[] { SomeString, EmptyString, WhiteSpaceString, AnotherString, TabString }.InitializeFlatArray(5),
+                2,
+                [
+                    [SomeString, EmptyString],
+                    [WhiteSpaceString, AnotherString],
+                    [TabString]
+                ]
+            },
+            {
+                new[] { ThreeWhiteSpacesString, AnotherString, SomeString, null! }.InitializeFlatArray(3),
+                3,
+                [
+                    [ThreeWhiteSpacesString, AnotherString, SomeString]
+                ]
+            },
+            {
+                new[] { ThreeWhiteSpacesString, AnotherString, SomeString, null! }.InitializeFlatArray(4),
+                3,
+                [
+                    [ThreeWhiteSpacesString, AnotherString, SomeString],
+                    [null!]
+                ]
+            }
+        };
+}

src/flatcollections-array/FlatArray/FlatArray.T/Functional/Function.Chunk.cs

@@ -0,0 +1,40 @@
+namespace System;
+
+partial struct FlatArray<T>
+{
+    public FlatArray<FlatArray<T>> Chunk(int size)
+    {
+        if (size < 1)
+        {
+            throw InnerExceptionFactory.SizeOutsideBounds(nameof(size), size);
+        }
+
+        if (length == default)
+        {
+            return default;
+        }
+
+        var chunksLength = length / size;
+        if (length % size != default)
+        {
+            chunksLength++;
+        }
+
+        var chunks = new FlatArray<T>[chunksLength];
+        for (var i = 0; i < chunks.Length; i++)
+        {
+            var start = i * size;
+
+            var chunkLength = length - start;
+            if (chunkLength > size)
+            {
+                chunkLength = size;
+            }
+
+            var chunkItems = InnerArrayHelper.CopySegment(items!, start, chunkLength);
+            chunks[i] = new(chunkLength, chunkItems);
+        }
+
+        return chunks;
+    }
+}

src/flatcollections-array/FlatArray/FlatArray.T/InnerExceptionFactory/FlatArray.InnerExceptionFactory.cs

@@ -14,6 +14,10 @@ internal static ArgumentOutOfRangeException SegmentOutsideBounds(int segmentStar
             =>
             new(null, Invariant($"Segment must be within the array bounds. Segment start was {segmentStart}. Segment length was {segmentLength}. Array length was {arrayLength}."));
 
+        internal static ArgumentOutOfRangeException SizeOutsideBounds(string paramName, int size)
+            =>
+            new(paramName, Invariant($"Size must be greater than 0 but was {size}."));
+
         internal static IndexOutOfRangeException IndexOutOfRange(int index, int length)
             =>
             new(Invariant($"Index must be greater than or equal to zero and less than the array length. Index was {index}. Array length was {length}."));

src/flatcollections-array/FlatArray/FlatArray.csproj

@@ -18,7 +18,7 @@
     <Description>PrimeFuncPack Core.FlatArray is a core library for .NET consisting of immutable FlatArray targeted for use in functional programming.</Description>
     <RootNamespace>System</RootNamespace>
     <AssemblyName>PrimeFuncPack.Core.FlatArray</AssemblyName>
-    <Version>1.4.0</Version>
+    <Version>1.5.0-preview.1</Version>
   </PropertyGroup>
 
   <ItemGroup>

src/flatcollections/FlatCollections/FlatCollections.csproj

@@ -18,7 +18,7 @@
     <Description>PrimeFuncPack Core.FlatCollections is a set of immutable Flat collections for .NET designed for developing business applications based on functional programming.</Description>
     <RootNamespace>System</RootNamespace>
     <AssemblyName>PrimeFuncPack.Core.FlatCollections</AssemblyName>
-    <Version>1.4.0</Version>
+    <Version>1.5.0-preview.1</Version>
   </PropertyGroup>
 
   <ItemGroup>
@@ -33,7 +33,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="PrimeFuncPack.Core.FlatArray" Version="1.4.0" />
+    <PackageReference Include="PrimeFuncPack.Core.FlatArray" Version="1.5.0-preview.1" />
   </ItemGroup>
 
 </Project>