Never

src/R3/Factories/Empty.cs

@@ -4,7 +4,7 @@ public static partial class EventFactory
     {
         public static CompletableEvent<TMessage, Unit> Empty<TMessage>()
         {
-            return new Empty<TMessage>();
+            return R3.Factories.Empty<TMessage>.Instance;
         }
 
         public static CompletableEvent<TMessage, Unit> Empty<TMessage>(TimeProvider timeProvider)
@@ -23,11 +23,19 @@ namespace R3.Factories
 {
     internal sealed class Empty<TMessage> : CompletableEvent<TMessage, Unit>
     {
+        // singleton
+        public static readonly Empty<TMessage> Instance = new Empty<TMessage>();
+
         protected override IDisposable SubscribeCore(Subscriber<TMessage, Unit> subscriber)
         {
             subscriber.OnCompleted(default);
             return Disposable.Empty;
         }
+
+        Empty()
+        {
+
+        }
     }
 
     internal sealed class EmptyT<TMessage>(TimeSpan dueTime, TimeProvider timeProvider) : CompletableEvent<TMessage, Unit>

src/R3/Factories/Never.cs

@@ -0,0 +1,55 @@
+namespace R3
+{
+    public static partial class EventFactory
+    {
+        // Never
+        public static Event<T> Never<T>()
+        {
+            return R3.Factories.Never<T>.Instance;
+        }
+
+        // NeverComplete
+        public static CompletableEvent<TMessage, TComplete> NeverComplete<TMessage, TComplete>()
+        {
+            return R3.Factories.NeverComplete<TMessage, TComplete>.Instance;
+        }
+    }
+}
+
+namespace R3.Factories
+{
+    // Never
+    internal sealed class Never<T> : Event<T>
+    {
+        // singleton
+        public static readonly Never<T> Instance = new Never<T>();
+
+        Never()
+        {
+
+        }
+
+        protected override IDisposable SubscribeCore(Subscriber<T> subscriber)
+        {
+            return Disposable.Empty;
+        }
+    }
+
+
+    // NeverComplete
+    internal sealed class NeverComplete<TMessage, TComplete> : CompletableEvent<TMessage, TComplete>
+    {
+        // singleton
+        public static readonly NeverComplete<TMessage, TComplete> Instance = new NeverComplete<TMessage, TComplete>();
+
+        NeverComplete()
+        {
+
+        }
+
+        protected override IDisposable SubscribeCore(Subscriber<TMessage, TComplete> subscriber)
+        {
+            return Disposable.Empty;
+        }
+    }
+}

src/R3/Factories/_EventFactory.cs

@@ -4,7 +4,7 @@ public static partial class EventFactory
     {
         // TODO: this is working space, will remove this file after complete.
 
-        // TODO: Empty, Never, Throw, Defer, DeferAsync, FromAsync, FromAsyncPattern, FromEvent, FromEventPattern, Interval, Range, Repeat, Start, Timer, Using, Create
+        // TODO: Throw, Defer, DeferAsync, FromAsync, FromAsyncPattern, FromEvent, FromEventPattern, Interval, Range, Repeat, Start, Timer, Using, Create
 
         // TODO: Convert
         // ToArray
@@ -26,5 +26,5 @@ public static partial class EventFactory
 namespace R3.Factories
 {
 
-  
+
 }

tests/R3.Tests/FactoryTests/NeverTest.cs

@@ -0,0 +1,19 @@
+namespace R3.Tests.FactoryTests;
+
+public class NeverTest
+{
+    [Fact]
+    public void Never()
+    {
+        using var list = EventFactory.Never<int>().LiveRecord();
+        list.AssertIsNotCompleted();
+    }
+
+    // NeverComplete test
+    [Fact]
+    public void NeverComplete()
+    {
+        using var list = EventFactory.NeverComplete<int, int>().LiveRecord();
+        list.AssertIsNotCompleted();
+    }
+}