com.fofx.observething 1.1.0 → 1.1.1-dev.161

package/Runtime/Operators/BatchOperator.cs

@@ -3,69 +3,70 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public interface IBatchOp<T> : IOperation where T : IOperation
+    public class BatchOperator<T> : IInitializationOperationsProvider<IReadOnlyList<T>>, IPendingObserver
     {
-        IReadOnlyList<T> operations { get; set; }
-    }
+        public bool immediate { get; } = false;
+        public uint priority { get; private set; }
+        public bool disposed { get; private set; }
 
-    public struct BatchOp<T> : IBatchOp<T> where T : IOperation
-    {
-        public IObservable<T> source { get; set; }
-        public IReadOnlyList<T> operations { get; set; }
+        private IEventStreamObservable<T> _source;
+        private ObservableEventStream<IReadOnlyList<T>> _operand;
+        private IDisposable _subscriptions;
+        private bool _pending;
 
-        IObservable<IOperation> IOperation.source => (IObservable<IOperation>)source;
-    }
+        private List<T> _batchedOperations = new List<T>();
 
-    // public class BatchOperator<T> : ObservableBase<IBatchObserver<T>, BatchOp<T>>, IBatchOperand<T>, IBatchObservable<T> where T : IOperation
-    // {
-    //     private Func<IBatchOperand<T>, IInitializationOperationsProvider<T>> _generateOperator;
-    //     private IInitializationOperationsProvider<T> _operator;
-    //     private bool _active = false;
+        public BatchOperator(IEventStreamObservable<T> source, ObservableEventStream<IReadOnlyList<T>> operand)
+        {
+            priority = source.context.AllocateObserverPriority();
 
-    //     public BatchOperator(ObservationContext context, Func<IBatchOperand<T>, IInitializationOperationsProvider<T>> generateOperator) : base(context)
-    //     {
-    //         _generateOperator = generateOperator;
-    //     }
+            _source = source;
+            _operand = operand;
 
-    //     protected override void OnFirstObserverAdded()
-    //     {
-    //         _active = true;
-    //         _operator = _generateOperator.Invoke(this);
-    //     }
+            _subscriptions = source.Subscribe(new EventStreamObserver<T>(
+                onNext: HandleSourceOperation,
+                onError: operand.OnError,
+                onDispose: Dispose
+            ), immediate: true);
+        }
 
-    //     protected override void OnLastObserverRemoved()
-    //     {
-    //         _active = false;
-    //         _operator?.Dispose();
-    //         _operator = null;
-    //     }
+        private void HandleSourceOperation(T operation)
+        {
+            _batchedOperations.Add(operation);
 
-    //     protected override void DisposeInternal()
-    //     {
-    //         _operator?.Dispose();
-    //         _operator = null;
-    //     }
+            if (_pending)
+                return;
 
-    //     void IBatchOperand<T>.EnqueuePendingOperation(IReadOnlyList<T> operation)
-    //         => EnqueuePendingOperation(new() { source = this, operations = operation });
+            _pending = true;
+            _source.context.RegisterPendingObserver(this);
+            _source.context.NotifyPendingObserversIfNecessary();
+        }
 
-    //     void IOperand.OnError(Exception error)
-    //         => OnError(error);
+        public IEnumerable<IReadOnlyList<T>> GetInitializationOperations()
+        {
+            List<T> initOps = new List<T>();
+            var subscription = _source.Subscribe(new EventStreamObserver<T>(x => initOps.Add(x)));
+            subscription.Dispose();
+            yield return initOps;
+        }
 
-    //     void IOperand.OnDisposed()
-    //     {
-    //         if (!_active)
-    //             return;
+        public void SendNext()
+        {
+            _pending = false;
 
-    //         Dispose();
-    //     }
+            var batch = _batchedOperations.ToArray();
+            _batchedOperations.Clear();
 
-    //     protected override IEnumerable<BatchOp<T>> GetInitializationOperations()
-    //     {
-    //         yield return new BatchOp<T>() { source = this, operations = _operator.GetInitializationOperations() };
-    //     }
+            _operand.EnqueueOperation(batch);
+        }
 
-    //     protected override void SendOperation(IBatchObserver<T> observer, BatchOp<T> operation)
-    //         => observer.OnNext(operation.operations);
-    // }
+        public void Dispose()
+        {
+            disposed = true;
+            _source.context.DeallocateObserverPriority(priority);
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
 }

package/Runtime/Operators/BatchOperator.cs.meta

@@ -1,2 +1,2 @@
 fileFormatVersion: 2
-guid: 0ad77fb1c6773c540bd984e9eab9c4be
+guid: d36db333036392248810c9ce317875ec

package/Runtime/{Observables/CastObservable.cs → Operators/CastOperator.cs}

@@ -2,12 +2,12 @@ using System;
 
 namespace ObserveThing
 {
-    public class CastValueObservable<T> : IDisposable
+    public class CastValueOperator<T> : IDisposable
     {
         private ObservableValue<T> _operand;
         private IDisposable _subscription;
 
-        public CastValueObservable(IValueObservable source, ObservableValue<T> operand)
+        public CastValueOperator(IValueObservable source, ObservableValue<T> operand)
         {
             _operand = operand;
             _subscription = source.Subscribe(
@@ -26,12 +26,12 @@ namespace ObserveThing
         }
     }
 
-    public class CastCollectionObservable<T> : IDisposable
+    public class CastCollectionOperator<T> : IDisposable
     {
         private ObservableCollection<T> _operand;
         private IDisposable _subscription;
 
-        public CastCollectionObservable(ICollectionObservable source, ObservableCollection<T> operand)
+        public CastCollectionOperator(ICollectionObservable source, ObservableCollection<T> operand)
         {
             _operand = operand;
             _subscription = source.SubscribeWithId(
@@ -51,12 +51,12 @@ namespace ObserveThing
         }
     }
 
-    public class CastListObservable<T> : IDisposable
+    public class CastListOperator<T> : IDisposable
     {
         private ObservableList<T> _operand;
         private IDisposable _subscription;
 
-        public CastListObservable(IListObservable source, ObservableList<T> operand)
+        public CastListOperator(IListObservable source, ObservableList<T> operand)
         {
             _operand = operand;
             _subscription = source.Subscribe(
@@ -76,12 +76,12 @@ namespace ObserveThing
         }
     }
 
-    public class CastSetObservable<T> : IDisposable
+    public class CastSetOperator<T> : IDisposable
     {
         private ObservableSet<T> _operand;
         private IDisposable _subscription;
 
-        public CastSetObservable(ISetObservable source, ObservableSet<T> operand)
+        public CastSetOperator(ISetObservable source, ObservableSet<T> operand)
         {
             _operand = operand;
             _subscription = source.Subscribe(
@@ -101,12 +101,12 @@ namespace ObserveThing
         }
     }
 
-    public class CastDictionaryObservable<TKey, TValue> : IDisposable
+    public class CastDictionaryOperator<TKey, TValue> : IDisposable
     {
         private ObservableDictionary<TKey, TValue> _operand;
         private IDisposable _subscription;
 
-        public CastDictionaryObservable(IDictionaryObservable source, ObservableDictionary<TKey, TValue> operand)
+        public CastDictionaryOperator(IDictionaryObservable source, ObservableDictionary<TKey, TValue> operand)
         {
             _operand = operand;
             _subscription = source.Subscribe(

package/Runtime/{Observables/CombineObservable.cs → Operators/CombineOperator.cs}

@@ -3,23 +3,23 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class CombineObservable<T> : IInitializationOperationsProvider<T> where T : IOperation
+    public class CombineOperator<T> : IInitializationOperationsProvider<T>
     {
-        private ISetObservable<IObservable<T>> _source;
-        private Observable<T> _operand;
+        private ISetObservable<IEventStreamObservable<T>> _source;
+        private ObservableEventStream<T> _operand;
         private bool _disposeOnSourceEmpty;
         private uint _elementPriority;
-        private Dictionary<IObservable<T>, IDisposable> _observables = new Dictionary<IObservable<T>, IDisposable>();
+        private Dictionary<IEventStreamObservable<T>, IDisposable> _observables = new Dictionary<IEventStreamObservable<T>, IDisposable>();
         private IDisposable _subscriptions;
         private bool _disposed;
 
-        public CombineObservable(ISetObservable<IObservable<T>> source, Observable<T> operand, bool disposeOnSourceEmpty = false)
+        public CombineOperator(ISetObservable<IEventStreamObservable<T>> source, ObservableEventStream<T> operand, bool disposeOnSourceEmpty = false)
         {
             _source = source;
             _operand = operand;
             _disposeOnSourceEmpty = disposeOnSourceEmpty;
             _elementPriority = _source.context.AllocateObserverPriority();
-            _subscriptions = _source.Subscribe(new SetObserver<IObservable<T>>(
+            _subscriptions = _source.Subscribe(new SetObserver<IEventStreamObservable<T>>(
                 onAdd: HandleElementAdded,
                 onRemove: HandleElementRemoved,
                 onError: _operand.OnError,
@@ -33,7 +33,7 @@ namespace ObserveThing
 
             foreach (var element in _observables.Keys)
             {
-                var subscription = element.Subscribe(new Observer<T>(x => initOps.Add(x)));
+                var subscription = element.Subscribe(new EventStreamObserver<T>(x => initOps.Add(x)));
                 subscription.Dispose();
             }
 
@@ -41,11 +41,11 @@ namespace ObserveThing
                 yield return op;
         }
 
-        private void HandleElementAdded(uint _, IObservable<T> observable)
+        private void HandleElementAdded(uint _, IEventStreamObservable<T> observable)
         {
             _observables.Add(
                 observable,
-                observable.Subscribe(new Observer<T>(
+                observable.Subscribe(new EventStreamObserver<T>(
                     onNext: HandleElementChanged,
                     onError: _operand.OnError,
                     onDispose: () =>
@@ -59,7 +59,7 @@ namespace ObserveThing
             );
         }
 
-        private void HandleElementRemoved(uint _, IObservable<T> observable)
+        private void HandleElementRemoved(uint _, IEventStreamObservable<T> observable)
         {
             if (!_observables.TryGetValue(observable, out var subscription))
                 return;

package/Runtime/{Observables/CombineValueObservable.cs → Operators/CombineValueOperator.cs}

@@ -2,12 +2,12 @@ using System;
 
 namespace ObserveThing
 {
-    public class CombineValueObservable<T1, T2> : IDisposable
+    public class CombineValueOperator<T1, T2> : IDisposable
     {
         private ObservableValue<(T1, T2)> _operand;
         private IDisposable _subscriptions;
 
-        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, ObservableValue<(T1, T2)> operand)
+        public CombineValueOperator(IValueObservable<T1> source1, IValueObservable<T2> source2, ObservableValue<(T1, T2)> operand)
         {
             _operand = operand;
             _subscriptions = new ComposedDisposable(
@@ -37,12 +37,12 @@ namespace ObserveThing
         }
     }
 
-    public class CombineValueObservable<T1, T2, T3> : IDisposable
+    public class CombineValueOperator<T1, T2, T3> : IDisposable
     {
         private ObservableValue<(T1, T2, T3)> _operand;
         private IDisposable _subscriptions;
 
-        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, ObservableValue<(T1, T2, T3)> operand)
+        public CombineValueOperator(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, ObservableValue<(T1, T2, T3)> operand)
         {
             _operand = operand;
             _subscriptions = new ComposedDisposable(
@@ -79,12 +79,12 @@ namespace ObserveThing
         }
     }
 
-    public class CombineValueObservable<T1, T2, T3, T4> : IDisposable
+    public class CombineValueOperator<T1, T2, T3, T4> : IDisposable
     {
         private ObservableValue<(T1, T2, T3, T4)> _operand;
         private IDisposable _subscriptions;
 
-        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, ObservableValue<(T1, T2, T3, T4)> operand)
+        public CombineValueOperator(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, ObservableValue<(T1, T2, T3, T4)> operand)
         {
             _operand = operand;
             _subscriptions = new ComposedDisposable(
@@ -128,12 +128,12 @@ namespace ObserveThing
         }
     }
 
-    public class CombineValueObservable<T1, T2, T3, T4, T5> : IDisposable
+    public class CombineValueOperator<T1, T2, T3, T4, T5> : IDisposable
     {
         private ObservableValue<(T1, T2, T3, T4, T5)> _operand;
         private IDisposable _subscriptions;
 
-        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, ObservableValue<(T1, T2, T3, T4, T5)> operand)
+        public CombineValueOperator(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, ObservableValue<(T1, T2, T3, T4, T5)> operand)
         {
             _operand = operand;
             _subscriptions = new ComposedDisposable(
@@ -184,12 +184,12 @@ namespace ObserveThing
         }
     }
 
-    public class CombineValueObservable<T1, T2, T3, T4, T5, T6> : IDisposable
+    public class CombineValueOperator<T1, T2, T3, T4, T5, T6> : IDisposable
     {
         private ObservableValue<(T1, T2, T3, T4, T5, T6)> _operand;
         private IDisposable _subscriptions;
 
-        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, IValueObservable<T6> source6, ObservableValue<(T1, T2, T3, T4, T5, T6)> operand)
+        public CombineValueOperator(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, IValueObservable<T6> source6, ObservableValue<(T1, T2, T3, T4, T5, T6)> operand)
         {
             _operand = operand;
             _subscriptions = new ComposedDisposable(
@@ -247,12 +247,12 @@ namespace ObserveThing
         }
     }
 
-    public class CombineValueObservable<T1, T2, T3, T4, T5, T6, T7> : IDisposable
+    public class CombineValueOperator<T1, T2, T3, T4, T5, T6, T7> : IDisposable
     {
         private ObservableValue<(T1, T2, T3, T4, T5, T6, T7)> _operand;
         private IDisposable _subscriptions;
 
-        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, IValueObservable<T6> source6, IValueObservable<T7> source7, ObservableValue<(T1, T2, T3, T4, T5, T6, T7)> operand)
+        public CombineValueOperator(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, IValueObservable<T6> source6, IValueObservable<T7> source7, ObservableValue<(T1, T2, T3, T4, T5, T6, T7)> operand)
         {
             _operand = operand;
             _subscriptions = new ComposedDisposable(

package/Runtime/{Observables/ConcatObservable.cs → Operators/ConcatOperator.cs}

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class ConcatObservable<T> : IDisposable
+    public class ConcatOperator<T> : IDisposable
     {
         private ObservableCollection<T> _operand;
         private CollectionIdProvider _idProvider;
@@ -12,7 +12,7 @@ namespace ObserveThing
 
         private IDisposable _subscription;
 
-        public ConcatObservable(ICollectionObservable<T> source1, ICollectionObservable<T> source2, ObservableCollection<T> operand)
+        public ConcatOperator(ICollectionObservable<T> source1, ICollectionObservable<T> source2, ObservableCollection<T> operand)
         {
             _idProvider = new CollectionIdProvider(x => !_source1IdMap.ContainsValue(x) && !_source2IdMap.ContainsValue(x));
             _operand = operand;

package/Runtime/{Observables/ContainsObservable.cs → Operators/ContainsOperator.cs}

@@ -3,14 +3,14 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class ContainsObservable<T> : IDisposable
+    public class ContainsOperator<T> : IDisposable
     {
         private ObservableValue<bool> _operand;
         private List<T> _list = new List<T>();
         private T _latest = default;
         private IDisposable _subscriptions;
 
-        public ContainsObservable(ICollectionObservable<T> source, IValueObservable<T> value, ObservableValue<bool> operand)
+        public ContainsOperator(ICollectionObservable<T> source, IValueObservable<T> value, ObservableValue<bool> operand)
         {
             _operand = operand;
             _subscriptions = new ComposedDisposable(

package/Runtime/Operators/ContainsOperator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 615c00bc7abd3b1409f4ad93b93ae25a

package/Runtime/{Observables/CountObservable.cs → Operators/CountOperator.cs}

@@ -2,12 +2,12 @@ using System;
 
 namespace ObserveThing
 {
-    public class CountObservable<T> : IDisposable
+    public class CountOperator<T> : IDisposable
     {
         private ObservableValue<int> _operand;
         private IDisposable _subscriptions;
 
-        public CountObservable(ICollectionObservable<T> source, ObservableValue<int> operand)
+        public CountOperator(ICollectionObservable<T> source, ObservableValue<int> operand)
         {
             _operand = operand;
             _subscriptions = source.Subscribe(

package/Runtime/{Observables/DistinctObservable.cs → Operators/DistinctOperator.cs}

@@ -3,13 +3,13 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class DistinctObservable<T> : IDisposable
+    public class DistinctOperator<T> : IDisposable
     {
         private ObservableSet<T> _operand;
         private Dictionary<T, int> _countByElement = new Dictionary<T, int>();
         private IDisposable _subscriptions;
 
-        public DistinctObservable(ICollectionObservable<T> source, ObservableSet<T> operand)
+        public DistinctOperator(ICollectionObservable<T> source, ObservableSet<T> operand)
         {
             _operand = operand;
             _subscriptions = source.Subscribe(

package/Runtime/Operators/{CollectionOperator.cs → Factories/CollectionOperatorFactory.cs}

@@ -2,9 +2,9 @@ using System;
 
 namespace ObserveThing
 {
-    public class CollectionOperator<T> : Operator<ObservableCollection<T>>, ICollectionObservable<T>
+    public class CollectionOperatorFactory<T> : OperatorFactory<ObservableCollection<T>>, ICollectionObservable<T>
     {
-        public CollectionOperator(ObservationContext context, Func<ObservableCollection<T>, IDisposable> generateOperator) : base(context, generateOperator) { }
+        public CollectionOperatorFactory(ObservationContext context, Func<ObservableCollection<T>, IDisposable> factory) : base(context, factory) { }
 
         public IDisposable Subscribe(ICollectionObserver<T> observer, bool immediate = false, uint? priority = null)
         {
@@ -19,12 +19,5 @@ namespace ObserveThing
             var subscription = ((ICollectionObservable)_observable).Subscribe(observer, immediate, priority);
             return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
         }
-
-        public IDisposable Subscribe(IObserver<IOperation> observer, bool immediate = false, uint? priority = null)
-        {
-            AddObserver(observer);
-            var subscription = ((IObservable<IOperation>)_observable).Subscribe(observer, immediate, priority);
-            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
-        }
     }
 }

package/Runtime/Operators/{DictionaryOperator.cs → Factories/DictionaryOperatorFactory.cs}

@@ -3,9 +3,9 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class DictionaryOperator<TKey, TValue> : Operator<ObservableDictionary<TKey, TValue>>, IDictionaryObservable<TKey, TValue>
+    public class DictionaryOperatorFactory<TKey, TValue> : OperatorFactory<ObservableDictionary<TKey, TValue>>, IDictionaryObservable<TKey, TValue>
     {
-        public DictionaryOperator(ObservationContext context, Func<ObservableDictionary<TKey, TValue>, IDisposable> generateOperator) : base(context, generateOperator) { }
+        public DictionaryOperatorFactory(ObservationContext context, Func<ObservableDictionary<TKey, TValue>, IDisposable> factory) : base(context, factory) { }
 
         public IDisposable Subscribe(IDictionaryObserver<TKey, TValue> observer, bool immediate = false, uint? priority = null)
         {
@@ -34,12 +34,5 @@ namespace ObserveThing
             var subscription = ((ICollectionObservable)_observable).Subscribe(observer, immediate, priority);
             return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
         }
-
-        public IDisposable Subscribe(IObserver<IOperation> observer, bool immediate = false, uint? priority = null)
-        {
-            AddObserver(observer);
-            var subscription = ((IObservable<IOperation>)_observable).Subscribe(observer, immediate, priority);
-            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
-        }
     }
 }

package/Runtime/Operators/{ObservableOperator.cs → Factories/EventStreamOperatorFactory.cs}

@@ -3,21 +3,21 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class ObservableOperator<T> : IObservable<T>, IInitializationOperationsProvider<T> where T : IOperation
+    public class EventStreamOperatorFactory<T> : IEventStreamObservable<T>, IInitializationOperationsProvider<T>
     {
         public ObservationContext context { get; }
 
-        private Func<Observable<T>, IInitializationOperationsProvider<T>> _generateOperator;
-        protected Observable<T> _observable { get; private set; }
+        private Func<ObservableEventStream<T>, IInitializationOperationsProvider<T>> _generateOperator;
+        protected ObservableEventStream<T> _observable { get; private set; }
         private IInitializationOperationsProvider<T> _operator;
         private bool _active = false;
-        private List<IObserverBase> _observers = new List<IObserverBase>();
+        private List<IObserver> _observers = new List<IObserver>();
         private bool _disposed;
 
-        public ObservableOperator(ObservationContext context, Func<Observable<T>, IInitializationOperationsProvider<T>> generateOperator)
+        public EventStreamOperatorFactory(ObservationContext context, Func<ObservableEventStream<T>, IInitializationOperationsProvider<T>> factory)
         {
             this.context = context;
-            _generateOperator = generateOperator;
+            _generateOperator = factory;
         }
 
         public void Dispose()
@@ -34,7 +34,7 @@ namespace ObserveThing
             _observable = default;
         }
 
-        protected void AddObserver(IObserverBase observer)
+        protected void AddObserver(IObserver observer)
         {
             _observers.Add(observer);
 
@@ -42,11 +42,11 @@ namespace ObserveThing
                 return;
 
             _active = true;
-            _observable = new Observable<T>(context, this);
+            _observable = new ObservableEventStream<T>(context, this);
             _operator = _generateOperator(_observable);
         }
 
-        protected void RemoveObserver(IObserverBase observer)
+        protected void RemoveObserver(IObserver observer)
         {
             _observers.Remove(observer);
 
@@ -62,13 +62,20 @@ namespace ObserveThing
             }
         }
 
-        public IDisposable Subscribe(IObserver<T> observer, bool immediate = false, uint? priority = null)
+        public IDisposable Subscribe(IEventStreamObserver<T> observer, bool immediate = false, uint? priority = null)
         {
             AddObserver(observer);
             var subscription = _observable.Subscribe(observer, immediate, priority);
             return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
         }
 
+        public IDisposable Subscribe(IEventStreamObserver observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((IEventStreamObservable)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
         public IEnumerable<T> GetInitializationOperations()
             => _operator.GetInitializationOperations();
     }

package/Runtime/Operators/{ListOperator.cs → Factories/ListOperatorFactory.cs}

@@ -2,9 +2,9 @@ using System;
 
 namespace ObserveThing
 {
-    public class ListOperator<T> : Operator<ObservableList<T>>, IListObservable<T>
+    public class ListOperatorFactory<T> : OperatorFactory<ObservableList<T>>, IListObservable<T>
     {
-        public ListOperator(ObservationContext context, Func<ObservableList<T>, IDisposable> generateOperator) : base(context, generateOperator) { }
+        public ListOperatorFactory(ObservationContext context, Func<ObservableList<T>, IDisposable> factory) : base(context, factory) { }
 
         public IDisposable Subscribe(IListObserver<T> observer, bool immediate = false, uint? priority = null)
         {
@@ -33,12 +33,5 @@ namespace ObserveThing
             var subscription = ((ICollectionObservable)_observable).Subscribe(observer, immediate, priority);
             return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
         }
-
-        public IDisposable Subscribe(IObserver<IOperation> observer, bool immediate = false, uint? priority = null)
-        {
-            AddObserver(observer);
-            var subscription = ((IObservable<IOperation>)_observable).Subscribe(observer, immediate, priority);
-            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
-        }
     }
 }

package/Runtime/Operators/{Operator.cs → Factories/OperatorFactory.cs}

@@ -3,21 +3,21 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class Operator<T> where T : class, IDisposable, new()
+    public class OperatorFactory<T> where T : class, IDisposable, new()
     {
         public ObservationContext context { get; }
 
-        private Func<T, IDisposable> _generateOperator;
+        private Func<T, IDisposable> _factory;
         protected T _observable { get; private set; }
         private IDisposable _operator;
         private bool _active = false;
-        private List<IObserverBase> _observers = new List<IObserverBase>();
+        private List<IObserver> _observers = new List<IObserver>();
         private bool _disposed;
 
-        public Operator(ObservationContext context, Func<T, IDisposable> generateOperator)
+        public OperatorFactory(ObservationContext context, Func<T, IDisposable> factory)
         {
             this.context = context;
-            _generateOperator = generateOperator;
+            _factory = factory;
         }
 
         public void Dispose()
@@ -34,7 +34,7 @@ namespace ObserveThing
             _observable = default;
         }
 
-        protected void AddObserver(IObserverBase observer)
+        protected void AddObserver(IObserver observer)
         {
             _observers.Add(observer);
 
@@ -43,10 +43,10 @@ namespace ObserveThing
 
             _active = true;
             _observable = new T();
-            _operator = _generateOperator(_observable);
+            _operator = _factory(_observable);
         }
 
-        protected void RemoveObserver(IObserverBase observer)
+        protected void RemoveObserver(IObserver observer)
         {
             _observers.Remove(observer);
 

package/Runtime/Operators/{SetOperator.cs → Factories/SetOperatorFactory.cs}

@@ -2,9 +2,9 @@ using System;
 
 namespace ObserveThing
 {
-    public class SetOperator<T> : Operator<ObservableSet<T>>, ISetObservable<T>
+    public class SetOperatorFactory<T> : OperatorFactory<ObservableSet<T>>, ISetObservable<T>
     {
-        public SetOperator(ObservationContext context, Func<ObservableSet<T>, IDisposable> generateOperator) : base(context, generateOperator) { }
+        public SetOperatorFactory(ObservationContext context, Func<ObservableSet<T>, IDisposable> factory) : base(context, factory) { }
 
         public IDisposable Subscribe(ISetObserver<T> observer, bool immediate = false, uint? priority = null)
         {
@@ -33,12 +33,5 @@ namespace ObserveThing
             var subscription = ((ICollectionObservable)_observable).Subscribe(observer, immediate, priority);
             return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
         }
-
-        public IDisposable Subscribe(IObserver<IOperation> observer, bool immediate = false, uint? priority = null)
-        {
-            AddObserver(observer);
-            var subscription = ((IObservable<IOperation>)_observable).Subscribe(observer, immediate, priority);
-            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
-        }
     }
 }