Add {Cycle,Repeat}Materialized

Funcky.Test/Sequence/CycleMaterializedTest.cs

@@ -0,0 +1,47 @@
+using FsCheck;
+using FsCheck.Xunit;
+using Funcky.Test.TestUtils;
+
+namespace Funcky.Test;
+
+public sealed class CycleMaterializedTest
+{
+    [Fact]
+    public void IsEnumeratedLazily()
+    {
+        var doNotEnumerate = new FailOnEnumerateCollection<object>(Count: 1);
+        _ = Sequence.CycleMaterialized(doNotEnumerate);
+    }
+
+    [Fact]
+    public void CyclingAnEmptySetThrowsAnException()
+        => Assert.Throws<InvalidOperationException>(CycleEmptySequence);
+
+    [Property]
+    public Property CanProduceArbitraryManyItems(NonEmptySet<int> sequence, PositiveInt arbitraryElements)
+    {
+        var cycleRange = Sequence.CycleMaterialized(sequence.Get.Materialize());
+
+        return (cycleRange.Take(arbitraryElements.Get).Count() == arbitraryElements.Get)
+            .ToProperty();
+    }
+
+    [Property]
+    public Property RepeatsTheElementsArbitraryManyTimes(NonEmptySet<int> sequence, PositiveInt arbitraryElements)
+    {
+        var cycleRange = Sequence.CycleMaterialized(sequence.Get.Materialize());
+
+        return cycleRange
+            .IsSequenceRepeating(sequence.Get)
+            .NTimes(arbitraryElements.Get)
+            .ToProperty();
+    }
+
+    private static void CycleEmptySequence()
+    {
+        var cycledRange = Sequence.CycleMaterialized(Array.Empty<int>());
+        using var enumerator = cycledRange.GetEnumerator();
+
+        enumerator.MoveNext();
+    }
+}

Funcky.Test/Sequence/CycleRangeTest.cs

@@ -15,8 +15,8 @@ public void CycleRangeIsEnumeratedLazily()
     }
 
     [Fact]
-    public void CyclingAnEmptySetThrowsAnArgumentException()
-            => Assert.Throws<InvalidOperationException>(CycleEmptySequence);
+    public void CyclingAnEmptySetThrowsAnException()
+        => Assert.Throws<InvalidOperationException>(CycleEmptySequence);
 
     [Property]
     public Property CycleRangeCanProduceArbitraryManyItems(NonEmptySet<int> sequence, PositiveInt arbitraryElements)

Funcky.Test/Sequence/RepeatMaterializedTest.cs

@@ -0,0 +1,43 @@
+using FsCheck;
+using FsCheck.Xunit;
+using Funcky.Test.TestUtils;
+
+namespace Funcky.Test;
+
+public sealed class RepeatMaterializedTest
+{
+    [Fact]
+    public void IsEnumeratedLazily()
+    {
+        var doNotEnumerate = new FailOnEnumerateCollection<object>(Count: 0);
+        _ = Sequence.RepeatMaterialized(doNotEnumerate, 2);
+    }
+
+    [Property]
+    public Property ARepeatedEmptySequenceIsStillEmpty(NonNegativeInt count)
+    {
+        var repeated = Sequence.RepeatMaterialized(Array.Empty<object>(), count.Get);
+        return (!repeated.Any()).ToProperty();
+    }
+
+    [Property]
+    public Property TheLengthOfTheGeneratedSequenceIsCorrect(List<int> list, NonNegativeInt count)
+    {
+        var repeatRange = Sequence.RepeatMaterialized(list, count.Get);
+
+        var materialized = repeatRange.ToList();
+
+        return (materialized.Count == list.Count * count.Get).ToProperty();
+    }
+
+    [Property]
+    public Property TheSequenceRepeatsTheGivenNumberOfTimes(List<int> list, NonNegativeInt count)
+    {
+        var repeatRange = Sequence.RepeatMaterialized(list, count.Get);
+
+        return repeatRange
+            .IsSequenceRepeating(list)
+            .NTimes(count.Get)
+            .ToProperty();
+    }
+}

Funcky.Test/TestUtils/FailOnEnumerateCollection.cs

@@ -3,7 +3,7 @@
 
 namespace Funcky.Test.TestUtils;
 
-internal record FailOnEnumerateCollection<T>(int Count) : ICollection<T>
+internal record FailOnEnumerateCollection<T>(int Count) : ICollection<T>, IReadOnlyCollection<T>
 {
     public bool IsReadOnly => true;
 

Funcky/PublicAPI.Unshipped.txt

@@ -5,3 +5,5 @@ static Funcky.DownCast<TResult>.From<TItem>(Funcky.Monads.Result<TItem!> result)
 static Funcky.DownCast<TResult>.From<TLeft, TRight>(Funcky.Monads.Either<TLeft, TRight!> either, System.Func<TLeft>! failedCast) -> Funcky.Monads.Either<TLeft, TResult!>
 static Funcky.Extensions.ParseExtensions.ParseTypeNameOrNone(this System.ReadOnlySpan<char> candidate, System.Reflection.Metadata.TypeNameParseOptions? options = null) -> Funcky.Monads.Option<System.Reflection.Metadata.TypeName!>
 static Funcky.Extensions.ParseExtensions.ParseAssemblyNameInfoOrNone(this System.ReadOnlySpan<char> candidate) -> Funcky.Monads.Option<System.Reflection.Metadata.AssemblyNameInfo!>
+static Funcky.Sequence.CycleMaterialized<TSource>(System.Collections.Generic.IReadOnlyCollection<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+static Funcky.Sequence.RepeatMaterialized<TSource>(System.Collections.Generic.IReadOnlyCollection<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!

Funcky/Sequence/Sequence.CycleMaterialized.cs

@@ -0,0 +1,11 @@
+namespace Funcky;
+
+public static partial class Sequence
+{
+    /// <inheritdoc cref="CycleRange{TSource}(IEnumerable{TSource})"/>
+    [Pure]
+    public static IEnumerable<TSource> CycleMaterialized<TSource>(IReadOnlyCollection<TSource> source)
+        => source.Count > 0
+            ? Cycle(source).SelectMany(Identity)
+            : throw new InvalidOperationException("you cannot cycle an empty enumerable");
+}

Funcky/Sequence/Sequence.RepeatMaterialized.cs

@@ -0,0 +1,9 @@
+namespace Funcky;
+
+public static partial class Sequence
+{
+    /// <inheritdoc cref="RepeatRange{TSource}(IEnumerable{TSource},int)"/>
+    [Pure]
+    public static IEnumerable<TSource> RepeatMaterialized<TSource>(IReadOnlyCollection<TSource> source, int count)
+        => Enumerable.Repeat(source, count).SelectMany(Identity);
+}