factories

src/R3/Factories/Range.cs

@@ -0,0 +1,35 @@
+namespace R3
+{
+    public static partial class EventFactory
+    {
+        public static CompletableEvent<int, Unit> Range(int start, int count)
+        {
+            return new R3.Factories.Range(start, count);
+        }
+    }
+}
+
+namespace R3.Factories
+{
+    internal sealed class Range : CompletableEvent<int, Unit>
+    {
+        readonly int start;
+        readonly int count;
+
+        public Range(int start, int count)
+        {
+            this.start = start;
+            this.count = count;
+        }
+
+        protected override IDisposable SubscribeCore(Subscriber<int, Unit> subscriber)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                subscriber.OnNext(start + i);
+            }
+            subscriber.OnCompleted(default);
+            return Disposable.Empty;
+        }
+    }
+}

src/R3/Operators/Return.cs → src/R3/Factories/Return.cs

@@ -1,6 +1,6 @@
 namespace R3
 {
-    public static partial class EventFactory
+    public static partial class _EventFactory
     {
         public static CompletableEvent<TMessage, Unit> Return<TMessage>(TMessage value)
         {
@@ -31,7 +31,7 @@ public static CompletableEvent<TMessage, Unit> Return<TMessage>(TMessage value,
     }
 }
 
-namespace R3.Operators
+namespace R3.Factories
 {
     internal class Return<TMessage>(TMessage value, TimeSpan dueTime, TimeProvider timeProvider) : CompletableEvent<TMessage, Unit>
     {

src/R3/Factories/Timer.cs

@@ -0,0 +1,62 @@
+namespace R3
+{
+    public static partial class EventFactory
+    {
+        public static CompletableEvent<Unit, Unit> Timer(TimeSpan dueTime, TimeProvider timeProvider)
+        {
+            return new R3.Factories.Timer(dueTime, timeProvider);
+        }
+    }
+}
+
+namespace R3.Factories
+{
+    internal sealed class Timer : CompletableEvent<Unit, Unit>
+    {
+        readonly TimeSpan dueTime;
+        readonly TimeProvider timeProvider;
+
+        public Timer(TimeSpan dueTime, TimeProvider timeProvider)
+        {
+            this.dueTime = dueTime;
+            this.timeProvider = timeProvider;
+        }
+
+        protected override IDisposable SubscribeCore(Subscriber<Unit, Unit> subscriber)
+        {
+            var method = new _Timer(subscriber);
+            method.Timer = timeProvider.CreateStoppedTimer(_Timer.timerCallback, method);
+            method.Timer.InvokeOnce(dueTime);
+            return method;
+        }
+
+        sealed class _Timer(Subscriber<Unit, Unit> subscriber) : IDisposable
+        {
+            public static readonly TimerCallback timerCallback = NextTick;
+
+            Subscriber<Unit, Unit> subscriber = subscriber;
+
+            public ITimer? Timer { get; set; }
+
+            static void NextTick(object? state)
+            {
+                var self = (_Timer)state!;
+                try
+                {
+                    self.subscriber.OnNext(default);
+                    self.subscriber.OnCompleted();
+                }
+                finally
+                {
+                    self.Dispose();
+                }
+            }
+
+            public void Dispose()
+            {
+                Timer?.Dispose();
+                Timer = null;
+            }
+        }
+    }
+}

src/R3/Factories/ToEvent.cs

@@ -0,0 +1,26 @@
+namespace R3
+{
+    public static partial class EventFactory
+    {
+        public static CompletableEvent<TMessage, Unit> ToEvent<TMessage>(this IEnumerable<TMessage> source)
+        {
+            return new ToEvent<TMessage>(source);
+        }
+    }
+}
+
+namespace R3.Factories
+{
+    internal class ToEvent<TMessage>(IEnumerable<TMessage> source) : CompletableEvent<TMessage, Unit>
+    {
+        protected override IDisposable SubscribeCore(Subscriber<TMessage, Unit> subscriber)
+        {
+            foreach (var message in source)
+            {
+                subscriber.OnNext(message);
+            }
+            subscriber.OnCompleted(default);
+            return Disposable.Empty;
+        }
+    }
+}

src/R3/Factories/_EventFactory.cs

@@ -0,0 +1,29 @@
+namespace R3
+{
+    // TODO: this is working space, will remove this file after complete.
+
+    public static partial class EventFactory
+    {
+        // TODO: Empty, Never, Throw, Defer, DeferAsync, FromAsync, FromAsyncPattern, FromEvent, FromEventPattern, Interval, Range, Repeat, Start, Timer, Using, Create
+
+        // TODO: Convert
+        // ToArray
+        // ToAsync
+        // ToDictionary
+        // ToEnumerable
+        // ToEvent
+        // ToEventPattern
+        // ToList
+        // ToLookup
+        // ToObservable
+
+        // AsObservable
+        // AsSingleUnitObservable
+        // AsUnitObservable
+
+    }
+}
+
+namespace R3.Factories
+{
+}

src/R3/Operators/_Operators.cs

@@ -0,0 +1,14 @@
+namespace R3
+{
+    // TODO: this is working space, will remove this file after complete.
+
+    public static partial class EventExtensions
+    {
+
+    }
+}
+
+namespace R3.Operators
+{
+
+}

src/R3/R3.csproj

@@ -25,6 +25,7 @@
     <ItemGroup>
         <Using Include="R3" />
         <Using Include="R3.Operators" />
+        <Using Include="R3.Factories" />
         <Using Include="R3.Internal" />
     </ItemGroup>
 

tests/R3.Tests/OperatorTests/ReturnTest.cs

@@ -8,21 +8,21 @@ public class ReturnTest
     public void Return()
     {
         {
-            using var list = EventFactory.Return(10).LiveRecord();
+            using var list = _EventFactory.Return(10).LiveRecord();
             list.AssertEqual([10]);
             list.AssertIsCompleted();
         }
         {
             var fakeTime = new FakeTimeProvider();
 
-            using var list = EventFactory.Return(10, TimeSpan.Zero, fakeTime).LiveRecord();
+            using var list = _EventFactory.Return(10, TimeSpan.Zero, fakeTime).LiveRecord();
             list.AssertEqual([10]);
             list.AssertIsCompleted();
         }
         {
             var fakeTime = new FakeTimeProvider();
 
-            using var list = EventFactory.Return(10, TimeSpan.FromSeconds(5), fakeTime).LiveRecord();
+            using var list = _EventFactory.Return(10, TimeSpan.FromSeconds(5), fakeTime).LiveRecord();
             list.AssertEqual([]);
 
             fakeTime.Advance(TimeSpan.FromSeconds(4));
@@ -38,7 +38,7 @@ public void Return()
     [Fact]
     public void ReturnThreadPoolScheduleOptimized()
     {
-        using var list = EventFactory.Return(10).LiveRecord();
+        using var list = _EventFactory.Return(10).LiveRecord();
 
         Thread.Sleep(1);