Merge pull request #772 from polyadic/avoid-to-async-enumerable

Avoid ToAsyncEnumerable when not really necessary
polyadic · Nov 29, 2023 · 0cf0448 · 0cf0448
2 parents ceef7b5 + 6c64077
commit 0cf0448
Show file tree

Hide file tree

Showing 7 changed files with 45 additions and 64 deletions.
diff --git a/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/IntersperseTest.cs b/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/IntersperseTest.cs
@@ -20,16 +20,22 @@ public async Task InterspersingAnEmptyEnumerableReturnsAnEmptyEnumerable()
     [Fact]
     public async Task InterspersingASequenceWithOneElementReturnsOriginalSequence()
     {
-        var source = Sequence.Return(10).ToAsyncEnumerable();
+        var source = AsyncSequence.Return(10);
         Assert.True(await source.SequenceEqualAsync(source.Intersperse(42)));
     }
 
     [Theory]
-    [InlineData(new[] { 1, 0, 2 }, new[] { 1, 2 })]
-    [InlineData(new[] { 1, 0, 2, 0, 3 }, new[] { 1, 2, 3 })]
-    [InlineData(new[] { 1, 0, 2, 0, 3, 0, 4 }, new[] { 1, 2, 3, 4 })]
-    public async Task InterspersingASequenceWithMoreThanOneElementReturnsExpectedSequence(IEnumerable<int> expected, IEnumerable<int> source)
+    [MemberData(nameof(ValueReferenceEnumerables))]
+    public async Task InterspersingASequenceWithMoreThanOneElementReturnsExpectedSequence(IAsyncEnumerable<int> expected, IAsyncEnumerable<int> source)
     {
-        Assert.True(await expected.ToAsyncEnumerable().SequenceEqualAsync(source.ToAsyncEnumerable().Intersperse(0)));
+        Assert.True(await expected.SequenceEqualAsync(source.Intersperse(0)));
     }
+
+    public static TheoryData<IAsyncEnumerable<int>, IAsyncEnumerable<int>> ValueReferenceEnumerables()
+        => new()
+        {
+            { AsyncSequence.Return(1, 0, 2), AsyncSequence.Return(1, 2) },
+            { AsyncSequence.Return(1, 0, 2, 0, 3), AsyncSequence.Return(1, 2, 3) },
+            { AsyncSequence.Return(1, 0, 2, 0, 3, 0, 4), AsyncSequence.Return(1, 2, 3, 4) },
+        };
 }
diff --git a/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/MergeTest.cs b/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/MergeTest.cs
@@ -18,17 +18,17 @@ public void MergeIsEnumeratedLazily()
     }
 
     [Fact]
-    public async Task MergeEmptySequencesResultsInAnEmptySequence()
+    public Task MergeEmptySequencesResultsInAnEmptySequence()
     {
         var emptySequence = AsyncEnumerable.Empty<int>();
 
-        await AsyncAssert.Empty(emptySequence.Merge(emptySequence, emptySequence, emptySequence));
+        return AsyncAssert.Empty(emptySequence.Merge(emptySequence, emptySequence, emptySequence));
     }
 
     [Fact]
     public async Task MergeAnEmptySequenceWithANonEmptySequenceResultsInTheNonEmptySequenceAsync()
     {
-        var nonEmptySequence = new List<int> { 1, 2, 4, 7 }.ToAsyncEnumerable();
+        var nonEmptySequence = AsyncSequence.Return(1, 2, 4, 7);
         var emptySequence = AsyncEnumerable.Empty<int>();
 
         await AsyncAssert.Equal(nonEmptySequence, nonEmptySequence.Merge(emptySequence));
@@ -38,41 +38,41 @@ public async Task MergeAnEmptySequenceWithANonEmptySequenceResultsInTheNonEmptyS
     [Property]
     public void TwoSingleSequencesAreMergedCorrectlyAsync(int first, int second)
     {
-        var sequence1 = Sequence.Return(first).ToAsyncEnumerable();
-        var sequence2 = Sequence.Return(second).ToAsyncEnumerable();
+        var sequence1 = AsyncSequence.Return(first);
+        var sequence2 = AsyncSequence.Return(second);
 
         var merged = sequence1.Merge(sequence2);
         Assert.True(merged.FirstAsync().Result <= merged.LastAsync().Result);
     }
 
     [Fact]
-    public async Task MergeTwoSequencesToOneAsync()
+    public Task MergeTwoSequencesToOneAsync()
     {
-        var sequence1 = new List<int> { 1, 2, 4, 7 }.ToAsyncEnumerable();
-        var sequence2 = new List<int> { 3, 5, 6, 8 }.ToAsyncEnumerable();
+        var sequence1 = AsyncSequence.Return(1, 2, 4, 7);
+        var sequence2 = AsyncSequence.Return(3, 5, 6, 8);
         var expected = AsyncEnumerable.Range(1, 8);
 
-        await AsyncAssert.Equal(expected, sequence1.Merge(sequence2));
+        return AsyncAssert.Equal(expected, sequence1.Merge(sequence2));
     }
 
     [Fact]
-    public async Task MergeASequenceOfSequences()
+    public Task MergeASequenceOfSequences()
     {
-        var sequence1 = new List<int> { 1, 2, 4, 7 }.ToAsyncEnumerable();
-        var sequence2 = new List<int> { 3, 5, 6, 8 }.ToAsyncEnumerable();
+        var sequence1 = AsyncSequence.Return(1, 2, 4, 7);
+        var sequence2 = AsyncSequence.Return(3, 5, 6, 8);
         var mergable = ImmutableList<IAsyncEnumerable<int>>.Empty.Add(sequence1).Add(sequence2);
         var expected = AsyncEnumerable.Range(1, 8);
 
-        await AsyncAssert.Equal(expected, mergable.Merge());
+        return AsyncAssert.Equal(expected, mergable.Merge());
     }
 
     [Fact]
-    public async Task MergeASequenceWithADifferentComparer()
+    public Task MergeASequenceWithADifferentComparer()
     {
-        var sequence1 = new List<int> { 7, 4, 2, 1 }.ToAsyncEnumerable();
-        var sequence2 = new List<int> { 8, 6, 5, 3 }.ToAsyncEnumerable();
+        var sequence1 = AsyncSequence.Return(7, 4, 2, 1);
+        var sequence2 = AsyncSequence.Return(8, 6, 5, 3);
         var expected = AsyncEnumerable.Range(1, 8).Reverse();
 
-        await AsyncAssert.Equal(expected, sequence1.Merge(sequence2, DescendingIntComparer.Create()));
+        return AsyncAssert.Equal(expected, sequence1.Merge(sequence2, DescendingIntComparer.Create()));
     }
 }
diff --git a/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/TestData.cs b/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/TestData.cs
@@ -15,11 +15,11 @@ public static readonly IAsyncEnumerable<string> EnumerableWithOneItem
         = AsyncSequence.Return(FirstItem);
 
     public static readonly IAsyncEnumerable<int> EnumerableTwoItems
-        = new[] { 42, 1337 }.ToAsyncEnumerable();
+        = AsyncSequence.Return(42, 1337);
 
     public static readonly IAsyncEnumerable<string> EnumerableWithMoreThanOneItem
-        = new[] { FirstItem, MiddleItem, LastItem }.ToAsyncEnumerable();
+        = AsyncSequence.Return(FirstItem, MiddleItem, LastItem);
 
     public static readonly IAsyncEnumerable<int> OneToFive
-        = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable();
+        = AsyncSequence.Return(1, 2, 3, 4, 5);
 }
diff --git a/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/WhereNotNullTest.cs b/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/WhereNotNullTest.cs
@@ -13,42 +13,20 @@ public void WhereNotNullIsEnumeratedLazily()
     }
 
     [Fact]
-    public async Task WhereNotNullRemovesNullReferenceValues()
+    public Task WhereNotNullRemovesNullReferenceValues()
     {
-        var input = new[]
-        {
-            null,
-            "foo",
-            null,
-            "bar",
-            null,
-        }.ToAsyncEnumerable();
-        var expectedResult = new[]
-        {
-            "foo",
-            "bar",
-        }.ToAsyncEnumerable();
+        var input = AsyncSequence.Return(null, "foo", null, "bar", null);
+        var expectedResult = AsyncSequence.Return("foo", "bar");
 
-        await AsyncAssert.Equal(expectedResult, input.WhereNotNull());
+        return AsyncAssert.Equal(expectedResult, input.WhereNotNull());
     }
 
     [Fact]
-    public async Task WhereNotNullRemovesNullValueTypeValues()
+    public Task WhereNotNullRemovesNullValueTypeValues()
     {
-        var input = new int?[]
-        {
-            null,
-            10,
-            null,
-            20,
-            null,
-        }.ToAsyncEnumerable();
-        var expectedResult = new[]
-        {
-            10,
-            20,
-        }.ToAsyncEnumerable();
+        var input = AsyncSequence.Return<int?>(null, 10, null, 20, null);
+        var expectedResult = AsyncSequence.Return(10, 20);
 
-        await AsyncAssert.Equal(expectedResult, input.WhereNotNull());
+        return AsyncAssert.Equal(expectedResult, input.WhereNotNull());
     }
 }
diff --git a/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/WithPreviousTest.cs b/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/WithPreviousTest.cs
@@ -1,4 +1,3 @@
-using System.Collections.Immutable;
 using Funcky.Async.Test.TestUtilities;
 
 namespace Funcky.Async.Test.Extensions.AsyncEnumerableExtensions;
@@ -36,12 +35,12 @@ await AsyncAssert.Collection(sequenceWithPrevious, value =>
     [Fact]
     public async Task ASequenceWithMoreThanOneElementWithPreviousHasPreviousSetExceptOnFirstElement()
     {
-        var sequence = ImmutableArray.Create("foo", "bar", "baz", "qux").ToAsyncEnumerable();
-        var expectedSequenceWithPrevious = ImmutableArray.Create(
+        var sequence = AsyncSequence.Return("foo", "bar", "baz", "qux");
+        var expectedSequenceWithPrevious = AsyncSequence.Return(
             new ValueWithPrevious<string>("foo", Option<string>.None),
             new ValueWithPrevious<string>("bar", "foo"),
             new ValueWithPrevious<string>("baz", "bar"),
-            new ValueWithPrevious<string>("qux", "baz")).ToAsyncEnumerable();
+            new ValueWithPrevious<string>("qux", "baz"));
 
         Assert.Equal(await expectedSequenceWithPrevious.ToListAsync(), await sequence.WithPrevious().ToListAsync());
     }

diff --git a/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/ZipLongestTest.cs b/Funcky.Async.Test/Extensions/AsyncEnumerableExtensions/ZipLongestTest.cs
@@ -27,7 +27,7 @@ public async Task GivenTwoEmptySequencesZipLongestReturnsAnEmptySequence()
     public async Task GivenTwoSequencesOfTheSameLengthWeGetNoNoneValue()
     {
         var numbers = AsyncEnumerable.Range(0, 3);
-        var strings = new[] { "Alpha", "Beta", "Gamma" }.ToAsyncEnumerable();
+        var strings = AsyncSequence.Return("Alpha", "Beta", "Gamma");
 
         var zipped = numbers
             .ZipLongest(strings);
@@ -43,7 +43,7 @@ public async Task GivenTwoSequencesOfTheSameLengthWeGetNoNoneValue()
     public async Task GivenTwoSequencesWeOfDifferentLengthWeGetTheLongerAndFillWithNone()
     {
         var numbers = AsyncEnumerable.Range(0, 10);
-        var strings = new[] { "Alpha", "Beta", "Gamma" }.ToAsyncEnumerable();
+        var strings = AsyncSequence.Return("Alpha", "Beta", "Gamma");
 
         var zipped = numbers
             .ZipLongest(strings);

diff --git a/Funcky.Test/TestUtils/RepeatingSequence.cs b/Funcky.Test/TestUtils/RepeatingSequence.cs
@@ -1,5 +1,3 @@
-using FsCheck;
-
 namespace Funcky.Test.TestUtils;
 
 public static class RepeatingSequence