Allow scan over value-less sequences

While not obviously useful, it becomes useful iff the delegate have side-effects.
symmetryinvestments · Sep 18, 2024 · 2acd64f · 2acd64f
1 parent b6ef86e
commit 2acd64f
Show file tree

Hide file tree

Showing 2 changed files with 28 additions and 7 deletions.
diff --git a/source/concurrency/sequence.d b/source/concurrency/sequence.d
@@ -321,9 +321,14 @@ auto nextTransform(Sequence, NextTransformer)(Sequence s, NextTransformer t) {
 }
 
 struct SequenceNextTransform(Sequence, NextTransformer) {
+    import concurrency.sender : VoidSender;
     import concurrency : just;
     alias Value = void;
-    alias Element = typeof(t.setNext(just(Sequence.Element.init))).Value;
+    static if (is(Sequence.Element == void)) {
+        alias Element = typeof(t.setNext(VoidSender())).Value;
+    } else {
+        alias Element = typeof(t.setNext(just(Sequence.Element.init))).Value;
+    }
     Sequence s;
     NextTransformer t;
     auto connect(Receiver)(return Receiver receiver) @safe return scope {
@@ -506,7 +511,7 @@ struct SequenceTakeReceiver(Receiver) {
                     return Result!(Sender.Value)(Cancelled());
                 else {
                     state.n--;
-                    return Result!(Sender.Value)();
+                    return Result!(Sender.Value)(Completed());
                 }
             }));
         } else {
@@ -923,10 +928,17 @@ struct ScanSequenceTransformer(Fun, Seed) {
     Seed seed;
     auto setNext(Sender)(Sender sender) {
         import concurrency.operations : then;
-        return sender.then((Sender.Value value) @safe shared {
-            seed = fun(value, seed);
-            return seed;
-        });
+        static if (is(Sender.Value == void)) {
+            return sender.then(() @safe shared {
+                seed = fun(seed);
+                return seed;
+            });
+        } else {
+            return sender.then((Sender.Value value) @safe shared {
+                seed = fun(value, seed);
+                return seed;
+            });
+        }
     }
 }
 

diff --git a/tests/ut/concurrency/sequence.d b/tests/ut/concurrency/sequence.d
@@ -35,6 +35,8 @@ import unit_threaded;
 @("take")
 @safe unittest {
     [1,2,3,4].sequence.take(3).toList().syncWait.value.should == [1,2,3];
+    [1,2,3,4].sequence.take(3).transform((int i) => i*2).toList().syncWait.value.should == [2,4,6];
+    [1,2,3,4].sequence.transform((int i) => i*2).take(3).toList().syncWait.value.should == [2,4,6];
 }
 
 @("deferSequence.function")
@@ -135,11 +137,18 @@ import unit_threaded;
     just([1,2].sequence).flatten.nextTransform(Transformer()).toList.syncWait.value.should == [1,2];
 }
 
-@("scan")
+@("scan.value")
 @safe unittest {
     [1,1,1,1].sequence.scan((int i, int acc) => acc + i, 0).toList().syncWait.value.should == [1,2,3,4];
 }
 
+@("scan.void")
+@safe unittest {
+    import core.time : msecs;
+    interval(1.msecs, false).scan((int acc) => acc + 1, 0).take(4).toList.syncWait.value.should == [1,2,3,4];
+    interval(1.msecs, false).take(4).scan((int acc) => acc + 1, 0).toList.syncWait.value.should == [1,2,3,4];
+}
+
 @("iotaSequence.basic")
 @safe unittest {
     iotaSequence(5, 10).toList().syncWait.value.should == [5,6,7,8,9];