From 1c43c5c8f8752314f3d3e267c96ef95dc07dbc0f Mon Sep 17 00:00:00 2001
From: Peter Wehrfritz <peter.wehrfritz@mailbox.org>
Date: Fri, 6 Jul 2018 10:45:41 +0200
Subject: [PATCH] Introduce a common base class for the single values, and
 resolve some rebase conflicts.

---
 .../Linq/Observable/AppendPrepend.cs          | 70 +++++++------------
 .../Linq/QueryLanguage.Single.cs              |  4 +-
 2 files changed, 26 insertions(+), 48 deletions(-)

diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/AppendPrepend.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/AppendPrepend.cs
index 2e78b8d66d..6346d33608 100644
--- a/Rx.NET/Source/src/System.Reactive/Linq/Observable/AppendPrepend.cs
+++ b/Rx.NET/Source/src/System.Reactive/Linq/Observable/AppendPrepend.cs
@@ -16,20 +16,20 @@ internal interface IAppendPrepend : IObservable<TSource>
             IScheduler Scheduler { get; }
         }
 
-        internal sealed class SingleValue : Producer<TSource, SingleValue._>, IAppendPrepend
+        internal abstract class SingleBase<TSink> : Producer<TSource, TSink>, IAppendPrepend
+            where TSink : IDisposable
         {
-            private readonly IObservable<TSource> _source;
-            private readonly TSource _value;
-            private readonly bool _append;
+            protected readonly IObservable<TSource> _source;
+            protected readonly TSource _value;
+            protected readonly bool _append;
 
-            public IScheduler Scheduler { get; }
+            public abstract IScheduler Scheduler { get; }
 
-            public SingleValue(IObservable<TSource> source, TSource value, IScheduler scheduler, bool append)
+            public SingleBase(IObservable<TSource> source, TSource value, bool append)
             {
                 _source = source;
                 _value = value;
                 _append = append;
-                Scheduler = scheduler;
             }
 
             public IAppendPrepend Append(TSource value)
@@ -79,6 +79,18 @@ private IAppendPrepend CreateAppendPrepend(Node<TSource> prepend, Node<TSource>
 
                 return new Recursive(_source, prepend, append, Scheduler);
             }
+        }
+
+
+        internal sealed class SingleValue : SingleBase<SingleValue._>
+        {
+            public override IScheduler Scheduler { get; }
+
+            public SingleValue(IObservable<TSource> source, TSource value, IScheduler scheduler, bool append)
+                : base (source, value, append)
+            {
+                Scheduler = scheduler;
+            }
 
             protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
 
@@ -479,47 +491,13 @@ public T[] ToReverseArray()
             }
         }
 
-        internal sealed class AppendPrependSingleImmediate<TSource> : Producer<TSource, AppendPrependSingleImmediate<TSource>._>, IAppendPrepend<TSource>
+        internal sealed class SingleImmediate : SingleBase<SingleImmediate._>
         {
-            private readonly IObservable<TSource> _source;
-            private readonly TSource _value;
-            private readonly bool _append;
-
-            public IScheduler Scheduler { get { return ImmediateScheduler.Instance; } }
-
-            public AppendPrependSingleImmediate(IObservable<TSource> source, TSource value, bool append)
-            {
-                _source = source;
-                _value = value;
-                _append = append;
-            }
-
-            public IAppendPrepend<TSource> Append(TSource value)
-            {
-                var prev = new Node<TSource>(_value);
-
-                if (_append)
-                {
-                    return new AppendPrependMultiple<TSource>(_source,
-                        null, new Node<TSource>(prev, value), Scheduler);
-                }
-
-                return new AppendPrependMultiple<TSource>(_source,
-                    prev, new Node<TSource>(value), Scheduler);
-            }
+            public override IScheduler Scheduler => ImmediateScheduler.Instance;
 
-            public IAppendPrepend<TSource> Prepend(TSource value)
+            public SingleImmediate(IObservable<TSource> source, TSource value, bool append)
+                : base(source, value, append)
             {
-                var prev = new Node<TSource>(_value);
-
-                if (_append)
-                {
-                    return new AppendPrependMultiple<TSource>(_source,
-                        new Node<TSource>(value), prev, Scheduler);
-                }
-
-                return new AppendPrependMultiple<TSource>(_source,
-                    new Node<TSource>(prev, value), null, Scheduler);
             }
 
             protected override _ CreateSink(IObserver<TSource> observer) => new _(this, observer);
@@ -532,7 +510,7 @@ internal sealed class _ : IdentitySink<TSource>
                 private readonly TSource _value;
                 private readonly bool _append;
 
-                public _(AppendPrependSingleImmediate<TSource> parent, IObserver<TSource> observer)
+                public _(SingleImmediate parent, IObserver<TSource> observer)
                     : base(observer)
                 {
                     _source = parent._source;
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Single.cs b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Single.cs
index 186fca779e..e80b5bf123 100644
--- a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Single.cs
+++ b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Single.cs
@@ -32,7 +32,7 @@ private static IObservable<TSource> Append_<TSource>(IObservable<TSource> source
             }
             if (scheduler == ImmediateScheduler.Instance)
             {
-                return new AppendPrepend<TSource>.SingleImmediate<TSource>(source, value, true);
+                return new AppendPrepend<TSource>.SingleImmediate(source, value, append: true);
             }
             return new AppendPrepend<TSource>.SingleValue(source, value, scheduler, append: true);
         }
@@ -213,7 +213,7 @@ private static IObservable<TSource> Prepend_<TSource>(IObservable<TSource> sourc
 
             if (scheduler == ImmediateScheduler.Instance)
             {
-                return new AppendPrepend.AppendPrependSingleImmediate<TSource>(source, value, false);
+                return new AppendPrepend<TSource>.SingleImmediate(source, value, append: false);
             }
 
             return new AppendPrepend<TSource>.SingleValue(source, value, scheduler, append: false);