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

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

@@ -3,97 +3,132 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public static class Observables
+    public static class Operators
     {
         public static IValueObservable<T> ObservableCast<T>(this IValueObservable source)
-            => new ValueOperator<T>(source.context, operand => new CastValueObservable<T>(source, operand));
+            => new ValueOperatorFactory<T>(source.context, operand => new CastValueOperator<T>(source, operand));
 
         public static ICollectionObservable<T> ObservableCast<T>(this ICollectionObservable source)
-            => new CollectionOperator<T>(source.context, operand => new CastCollectionObservable<T>(source, operand));
+            => new CollectionOperatorFactory<T>(source.context, operand => new CastCollectionOperator<T>(source, operand));
 
         public static IListObservable<T> ObservableCast<T>(this IListObservable source)
-            => new ListOperator<T>(source.context, operand => new CastListObservable<T>(source, operand));
+            => new ListOperatorFactory<T>(source.context, operand => new CastListOperator<T>(source, operand));
 
         public static ISetObservable<T> ObservableCast<T>(this ISetObservable source)
-            => new SetOperator<T>(source.context, operand => new CastSetObservable<T>(source, operand));
+            => new SetOperatorFactory<T>(source.context, operand => new CastSetOperator<T>(source, operand));
 
         public static IDictionaryObservable<TKey, TValue> ObservableCast<TKey, TValue>(this IDictionaryObservable source)
-            => new DictionaryOperator<TKey, TValue>(source.context, operand => new CastDictionaryObservable<TKey, TValue>(source, operand));
+            => new DictionaryOperatorFactory<TKey, TValue>(source.context, operand => new CastDictionaryOperator<TKey, TValue>(source, operand));
 
-        public static IObservable<ValueOp<T>> ObservableOperationStream<T>(this IValueObservable<T> source)
-            => new ObservableOperator<ValueOp<T>>(source.context, operand => new ValueOperationStreamObservable<T>(source, operand));
+        public static IEventStreamObservable<TOperation> ObservableEventStream<T, TOperation>(this IValueObservable<T> source, Func<T, TOperation> constructOperation)
+            => new EventStreamOperatorFactory<TOperation>(source.context, operand => new ValueEventStreamOperator<T, TOperation>(source, constructOperation, operand));
 
-        public static IObservable<CollectionOp<T>> ObservableOperationStream<T>(this ICollectionObservable<T> source)
-            => new ObservableOperator<CollectionOp<T>>(source.context, operand => new CollectionOperationStreamObservable<T>(source, operand));
+        public static IEventStreamObservable<ValueOp<T>> ObservableEventStream<T>(this IValueObservable<T> source)
+            => source.ObservableEventStream(x => new ValueOp<T>() { source = source, value = x });
 
-        public static IObservable<ListOp<T>> ObservableOperationStream<T>(this IListObservable<T> source)
-            => new ObservableOperator<ListOp<T>>(source.context, operand => new ListOperationStreamObservable<T>(source, operand));
+        public static IEventStreamObservable<TOperation> ObservableEventStream<T, TOperation>(this ICollectionObservable<T> source, Func<uint, T, TOperation> constructAddOperation, Func<uint, T, TOperation> constructRemoveOperation)
+            => new EventStreamOperatorFactory<TOperation>(source.context, operand => new CollectionEventStreamOperator<T, TOperation>(source, constructAddOperation, constructRemoveOperation, operand));
 
-        public static IObservable<DictionaryOp<TKey, TValue>> ObservableOperationStream<TKey, TValue>(this IDictionaryObservable<TKey, TValue> source)
-            => new ObservableOperator<DictionaryOp<TKey, TValue>>(source.context, operand => new DictionaryOperationStreamObservable<TKey, TValue>(source, operand));
+        public static IEventStreamObservable<CollectionOp<T>> ObservableEventStream<T>(this ICollectionObservable<T> source)
+            => new EventStreamOperatorFactory<CollectionOp<T>>(source.context, operand => new CollectionEventStreamOperator<T, CollectionOp<T>>(
+                source,
+                (id, element) => new() { source = source, elementId = id, element = element, isRemove = false },
+                (id, element) => new() { source = source, elementId = id, element = element, isRemove = true },
+                operand
+            ));
 
-        public static IObservable<SetOp<T>> ObservableOperationStream<T>(this ISetObservable<T> source)
-            => new ObservableOperator<SetOp<T>>(source.context, operand => new SetOperationStreamObservable<T>(source, operand));
+        public static IEventStreamObservable<TOperation> ObservableEventStream<T, TOperation>(this IListObservable<T> source, Func<uint, int, T, TOperation> constructAddOperation, Func<uint, int, T, TOperation> constructRemoveOperation)
+            => new EventStreamOperatorFactory<TOperation>(source.context, operand => new ListEventStreamOperator<T, TOperation>(source, constructAddOperation, constructRemoveOperation, operand));
 
-        public static IObservable<BatchOp<ValueOp<T>>> ObservableBatch<T>(this IValueObservable<T> source)
-            => source.ObservableOperationStream().ObservableBatch();
+        public static IEventStreamObservable<ListOp<T>> ObservableEventStream<T>(this IListObservable<T> source)
+            => new EventStreamOperatorFactory<ListOp<T>>(source.context, operand => new ListEventStreamOperator<T, ListOp<T>>(
+                source,
+                (id, index, element) => new() { source = source, elementId = id, index = index, element = element, isRemove = false },
+                (id, index, element) => new() { source = source, elementId = id, index = index, element = element, isRemove = true },
+                operand
+            ));
 
-        public static IObservable<BatchOp<CollectionOp<T>>> ObservableBatch<T>(this ICollectionObservable<T> source)
-            => source.ObservableOperationStream().ObservableBatch();
+        public static IEventStreamObservable<TOperation> ObservableEventStream<TKey, TValue, TOperation>(this IDictionaryObservable<TKey, TValue> source, Func<uint, KeyValuePair<TKey, TValue>, TOperation> constructAddOperation, Func<uint, KeyValuePair<TKey, TValue>, TOperation> constructRemoveOperation)
+            => new EventStreamOperatorFactory<TOperation>(source.context, operand => new DictionaryEventStreamOperator<TKey, TValue, TOperation>(source, constructAddOperation, constructRemoveOperation, operand));
 
-        public static IObservable<BatchOp<ListOp<T>>> ObservableBatch<T>(this IListObservable<T> source)
-            => source.ObservableOperationStream().ObservableBatch();
+        public static IEventStreamObservable<DictionaryOp<TKey, TValue>> ObservableEventStream<TKey, TValue>(this IDictionaryObservable<TKey, TValue> source)
+            => new EventStreamOperatorFactory<DictionaryOp<TKey, TValue>>(source.context, operand => new DictionaryEventStreamOperator<TKey, TValue, DictionaryOp<TKey, TValue>>(
+                source,
+                (id, kvp) => new() { source = source, elementId = id, key = kvp.Key, value = kvp.Value, isRemove = false },
+                (id, kvp) => new() { source = source, elementId = id, key = kvp.Key, value = kvp.Value, isRemove = true },
+                operand
+            ));
 
-        public static IObservable<BatchOp<DictionaryOp<TKey, TValue>>> ObservableBatch<TKey, TValue>(this IDictionaryObservable<TKey, TValue> source)
-            => source.ObservableOperationStream().ObservableBatch();
+        public static IEventStreamObservable<TOperation> ObservableEventStream<T, TOperation>(this ISetObservable<T> source, Func<uint, T, TOperation> constructAddOperation, Func<uint, T, TOperation> constructRemoveOperation)
+            => new EventStreamOperatorFactory<TOperation>(source.context, operand => new SetEventStreamOperator<T, TOperation>(source, constructAddOperation, constructRemoveOperation, operand));
 
-        public static IObservable<BatchOp<SetOp<T>>> ObservableBatch<T>(this ISetObservable<T> source)
-            => source.ObservableOperationStream().ObservableBatch();
+        public static IEventStreamObservable<SetOp<T>> ObservableEventStream<T>(this ISetObservable<T> source)
+            => new EventStreamOperatorFactory<SetOp<T>>(source.context, operand => new SetEventStreamOperator<T, SetOp<T>>(
+                source,
+                (id, element) => new() { source = source, elementId = id, element = element, isRemove = false },
+                (id, element) => new() { source = source, elementId = id, element = element, isRemove = true },
+                operand
+            ));
 
-        public static IObservable<BatchOp<T>> ObservableBatch<T>(this IObservable<T> source) where T : IOperation
-            => new ObservableOperator<BatchOp<T>>(source.context, operand => new BatchObservable<T>(source, operand));
+        public static IEventStreamObservable<IReadOnlyList<ValueOp<T>>> ObservableBatch<T>(this IValueObservable<T> source)
+            => source.ObservableEventStream().ObservableBatch();
 
-        public static IObservable<T> ObservableCombine<T>(this ISetObservable<IObservable<T>> source, bool disposeOnSourceEmpty = true) where T : IOperation
-            => new ObservableOperator<T>(source.context, operand => new CombineObservable<T>(source, operand, disposeOnSourceEmpty));
+        public static IEventStreamObservable<IReadOnlyList<CollectionOp<T>>> ObservableBatch<T>(this ICollectionObservable<T> source)
+            => source.ObservableEventStream().ObservableBatch();
 
-        public static IObservable<T> ObservableCombine<T>(params IObservable<T>[] observables) where T : IOperation
-            => new ObservableSet<IObservable<T>>(observables[0].context, observables).ObservableCombine(disposeOnSourceEmpty: true);
+        public static IEventStreamObservable<IReadOnlyList<ListOp<T>>> ObservableBatch<T>(this IListObservable<T> source)
+            => source.ObservableEventStream().ObservableBatch();
 
-        public static IObservable<T> ObservableCombine<T>(bool disposeOnSourceEmpty, params IObservable<T>[] observables) where T : IOperation
-            => new ObservableSet<IObservable<T>>(observables[0].context, observables).ObservableCombine(disposeOnSourceEmpty: disposeOnSourceEmpty);
+        public static IEventStreamObservable<IReadOnlyList<DictionaryOp<TKey, TValue>>> ObservableBatch<TKey, TValue>(this IDictionaryObservable<TKey, TValue> source)
+            => source.ObservableEventStream().ObservableBatch();
+
+        public static IEventStreamObservable<IReadOnlyList<SetOp<T>>> ObservableBatch<T>(this ISetObservable<T> source)
+            => source.ObservableEventStream().ObservableBatch();
+
+        public static IEventStreamObservable<IReadOnlyList<T>> ObservableBatch<T>(this IEventStreamObservable<T> source)
+            => new EventStreamOperatorFactory<IReadOnlyList<T>>(source.context, operand => new BatchOperator<T>(source, operand));
+
+        public static IEventStreamObservable<T> ObservableCombine<T>(this ISetObservable<IEventStreamObservable<T>> source, bool disposeOnSourceEmpty = true)
+            => new EventStreamOperatorFactory<T>(source.context, operand => new CombineOperator<T>(source, operand, disposeOnSourceEmpty));
+
+        public static IEventStreamObservable<T> ObservableCombine<T>(params IEventStreamObservable<T>[] observables)
+            => new ObservableSet<IEventStreamObservable<T>>(observables[0].context, observables).ObservableCombine(disposeOnSourceEmpty: true);
+
+        public static IEventStreamObservable<T> ObservableCombine<T>(bool disposeOnSourceEmpty, params IEventStreamObservable<T>[] observables)
+            => new ObservableSet<IEventStreamObservable<T>>(observables[0].context, observables).ObservableCombine(disposeOnSourceEmpty: disposeOnSourceEmpty);
 
         public static IValueObservable<T> ObservableThen<T>(this IValueObservable<T> source, IValueObserver<T> thenObserver)
-            => new ValueOperator<T>(source.context, operand => new ThenValueObservable<T>(source, thenObserver, operand));
+            => new ValueOperatorFactory<T>(source.context, operand => new ThenValueOperator<T>(source, thenObserver, operand));
 
         public static IValueObservable<T> ObservableThen<T>(this IValueObservable<T> source, Action<T> onNext = default, Action onDispose = default, Action<Exception> onError = default)
             => source.ObservableThen(new ValueObserver<T>(onNext, onDispose, onError));
 
         public static ICollectionObservable<T> ObservableThen<T>(this ICollectionObservable<T> source, ICollectionObserver<T> thenObserver)
-            => new CollectionOperator<T>(source.context, operand => new ThenCollectionObservable<T>(source, thenObserver, operand));
+            => new CollectionOperatorFactory<T>(source.context, operand => new ThenCollectionObservable<T>(source, thenObserver, operand));
 
         public static ICollectionObservable<T> ObservableThen<T>(this ICollectionObservable<T> source, Action<T> onAdd = default, Action<T> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
             => source.ObservableThen(new CollectionObserver<T>((id, x) => onAdd?.Invoke(x), (id, x) => onRemove?.Invoke(x), onDispose, onError));
 
         public static IListObservable<T> ObservableThen<T>(this IListObservable<T> source, IListObserver<T> thenObserver)
-            => new ListOperator<T>(source.context, operand => new ThenListObservable<T>(source, thenObserver, operand));
+            => new ListOperatorFactory<T>(source.context, operand => new ThenListObservable<T>(source, thenObserver, operand));
 
         public static IListObservable<T> ObservableThen<T>(this IListObservable<T> source, Action<int, T> onAdd = default, Action<int, T> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
             => source.ObservableThen(new ListObserver<T>((id, index, x) => onAdd?.Invoke(index, x), (id, index, x) => onRemove?.Invoke(index, x), onDispose, onError));
 
         public static ISetObservable<T> ObservableThen<T>(this ISetObservable<T> source, ISetObserver<T> thenObserver)
-            => new SetOperator<T>(source.context, operand => new ThenSetObservable<T>(source, thenObserver, operand));
+            => new SetOperatorFactory<T>(source.context, operand => new ThenSetObservable<T>(source, thenObserver, operand));
 
         public static ISetObservable<T> ObservableThen<T>(this ISetObservable<T> source, Action<T> onAdd = default, Action<T> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
             => source.ObservableThen(new SetObserver<T>((id, x) => onAdd?.Invoke(x), (id, x) => onRemove?.Invoke(x), onDispose, onError));
 
         public static IDictionaryObservable<TKey, TValue> ObservableThen<TKey, TValue>(this IDictionaryObservable<TKey, TValue> source, IDictionaryObserver<TKey, TValue> thenObserver)
-            => new DictionaryOperator<TKey, TValue>(source.context, operand => new ThenDictionaryObservable<TKey, TValue>(source, thenObserver, operand));
+            => new DictionaryOperatorFactory<TKey, TValue>(source.context, operand => new ThenDictionaryObservable<TKey, TValue>(source, thenObserver, operand));
 
         public static IDictionaryObservable<TKey, TValue> ObservableThen<TKey, TValue>(this IDictionaryObservable<TKey, TValue> source, Action<KeyValuePair<TKey, TValue>> onAdd = default, Action<KeyValuePair<TKey, TValue>> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
             => source.ObservableThen(new DictionaryObserver<TKey, TValue>((id, x) => onAdd?.Invoke(x), (id, x) => onRemove?.Invoke(x), onDispose, onError));
 
         public static IValueObservable<(T1, T2)> ObservableCombineValues<T1, T2>(IValueObservable<T1> source1, IValueObservable<T2> source2)
-            => new ValueOperator<(T1, T2)>(source1.context, operand => new CombineValueObservable<T1, T2>(source1, source2, operand));
+            => new ValueOperatorFactory<(T1, T2)>(source1.context, operand => new CombineValueOperator<T1, T2>(source1, source2, operand));
 
         public static IValueObservable<TResult> ObservableCombineValues<T1, T2, TResult>(IValueObservable<T1> source1, IValueObservable<T2> source2, Func<T1, T2, IValueObservable<TResult>> select)
             => ObservableCombineValues(source1, source2).ObservableSelect(x => select(x.Item1, x.Item2));
@@ -102,7 +137,7 @@ namespace ObserveThing
             => ObservableCombineValues(source1, source2).ObservableSelect(x => select(x.Item1, x.Item2));
 
         public static IValueObservable<(T1, T2, T3)> ObservableCombineValues<T1, T2, T3>(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3)
-            => new ValueOperator<(T1, T2, T3)>(source1.context, operand => new CombineValueObservable<T1, T2, T3>(source1, source2, source3, operand));
+            => new ValueOperatorFactory<(T1, T2, T3)>(source1.context, operand => new CombineValueOperator<T1, T2, T3>(source1, source2, source3, operand));
 
         public static IValueObservable<TResult> ObservableCombineValues<T1, T2, T3, TResult>(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, Func<T1, T2, T3, IValueObservable<TResult>> select)
             => ObservableCombineValues(source1, source2, source3).ObservableSelect(x => select(x.Item1, x.Item2, x.Item3));
@@ -111,7 +146,7 @@ namespace ObserveThing
             => ObservableCombineValues(source1, source2, source3).ObservableSelect(x => select(x.Item1, x.Item2, x.Item3));
 
         public static IValueObservable<(T1, T2, T3, T4)> ObservableCombineValues<T1, T2, T3, T4>(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4)
-            => new ValueOperator<(T1, T2, T3, T4)>(source1.context, operand => new CombineValueObservable<T1, T2, T3, T4>(source1, source2, source3, source4, operand));
+            => new ValueOperatorFactory<(T1, T2, T3, T4)>(source1.context, operand => new CombineValueOperator<T1, T2, T3, T4>(source1, source2, source3, source4, operand));
 
         public static IValueObservable<TResult> ObservableCombineValues<T1, T2, T3, T4, TResult>(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, Func<T1, T2, T3, T4, IValueObservable<TResult>> select)
             => ObservableCombineValues(source1, source2, source3, source4).ObservableSelect(x => select(x.Item1, x.Item2, x.Item3, x.Item4));
@@ -120,7 +155,7 @@ namespace ObserveThing
             => ObservableCombineValues(source1, source2, source3, source4).ObservableSelect(x => select(x.Item1, x.Item2, x.Item3, x.Item4));
 
         public static IValueObservable<(T1, T2, T3, T4, T5)> ObservableCombineValues<T1, T2, T3, T4, T5>(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5)
-            => new ValueOperator<(T1, T2, T3, T4, T5)>(source1.context, operand => new CombineValueObservable<T1, T2, T3, T4, T5>(source1, source2, source3, source4, source5, operand));
+            => new ValueOperatorFactory<(T1, T2, T3, T4, T5)>(source1.context, operand => new CombineValueOperator<T1, T2, T3, T4, T5>(source1, source2, source3, source4, source5, operand));
 
         public static IValueObservable<TResult> ObservableCombineValues<T1, T2, T3, T4, T5, TResult>(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, Func<T1, T2, T3, T4, T5, IValueObservable<TResult>> select)
             => ObservableCombineValues(source1, source2, source3, source4, source5).ObservableSelect(x => select(x.Item1, x.Item2, x.Item3, x.Item4, x.Item5));
@@ -129,7 +164,7 @@ namespace ObserveThing
             => ObservableCombineValues(source1, source2, source3, source4, source5).ObservableSelect(x => select(x.Item1, x.Item2, x.Item3, x.Item4, x.Item5));
 
         public static IValueObservable<(T1, T2, T3, T4, T5, T6)> ObservableCombineValues<T1, T2, T3, T4, T5, T6>(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, IValueObservable<T6> source6)
-            => new ValueOperator<(T1, T2, T3, T4, T5, T6)>(source1.context, operand => new CombineValueObservable<T1, T2, T3, T4, T5, T6>(source1, source2, source3, source4, source5, source6, operand));
+            => new ValueOperatorFactory<(T1, T2, T3, T4, T5, T6)>(source1.context, operand => new CombineValueOperator<T1, T2, T3, T4, T5, T6>(source1, source2, source3, source4, source5, source6, operand));
 
         public static IValueObservable<TResult> ObservableCombineValues<T1, T2, T3, T4, T5, T6, TResult>(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, IValueObservable<T6> source6, Func<T1, T2, T3, T4, T5, T6, IValueObservable<TResult>> select)
             => ObservableCombineValues(source1, source2, source3, source4, source5, source6).ObservableSelect(x => select(x.Item1, x.Item2, x.Item3, x.Item4, x.Item5, x.Item6));
@@ -138,7 +173,7 @@ namespace ObserveThing
             => ObservableCombineValues(source1, source2, source3, source4, source5, source6).ObservableSelect(x => select(x.Item1, x.Item2, x.Item3, x.Item4, x.Item5, x.Item6));
 
         public static IValueObservable<(T1, T2, T3, T4, T5, T6, T7)> ObservableCombineValues<T1, T2, T3, T4, T5, T6, T7>(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, IValueObservable<T6> source6, IValueObservable<T7> source7)
-            => new ValueOperator<(T1, T2, T3, T4, T5, T6, T7)>(source1.context, operand => new CombineValueObservable<T1, T2, T3, T4, T5, T6, T7>(source1, source2, source3, source4, source5, source6, source7, operand));
+            => new ValueOperatorFactory<(T1, T2, T3, T4, T5, T6, T7)>(source1.context, operand => new CombineValueOperator<T1, T2, T3, T4, T5, T6, T7>(source1, source2, source3, source4, source5, source6, source7, operand));
 
         public static IValueObservable<TResult> ObservableCombineValues<T1, T2, T3, T4, T5, T6, T7, TResult>(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, IValueObservable<T6> source6, IValueObservable<T7> source7, Func<T1, T2, T3, T4, T5, T6, T7, IValueObservable<TResult>> select)
             => ObservableCombineValues(source1, source2, source3, source4, source5, source6, source7).ObservableSelect(x => select(x.Item1, x.Item2, x.Item3, x.Item4, x.Item5, x.Item6, x.Item7));
@@ -147,70 +182,70 @@ namespace ObserveThing
             => ObservableCombineValues(source1, source2, source3, source4, source5, source6, source7).ObservableSelect(x => select(x.Item1, x.Item2, x.Item3, x.Item4, x.Item5, x.Item6, x.Item7));
 
         public static IValueObservable<T> ObservableUnwrap<T>(this IValueObservable<IValueObservable<T>> source)
-            => new ValueOperator<T>(source.context, operand => new UnwrapValueObservable<T>(source, operand));
+            => new ValueOperatorFactory<T>(source.context, operand => new UnwrapValueOperator<T>(source, operand));
 
         public static IValueObservable<U> ObservableSelect<T, U>(this IValueObservable<T> source, Func<T, U> select)
-            => new ValueOperator<U>(source.context, operand => new SelectValueOperator<T, U>(source, select, operand));
+            => new ValueOperatorFactory<U>(source.context, operand => new SelectValueOperator<T, U>(source, select, operand));
 
         public static IValueObservable<U> ObservableSelect<T, U>(this IValueObservable<T> source, Func<T, IValueObservable<U>> select)
             => source.ObservableSelect<T, IValueObservable<U>>(select).ObservableUnwrap();
 
         public static IValueObservable<(T current, T previous)> ObservableWithPrevious<T>(this IValueObservable<T> source)
-            => new ValueOperator<(T current, T previous)>(source.context, operand => new WithPreviousObservable<T>(source, operand));
+            => new ValueOperatorFactory<(T current, T previous)>(source.context, operand => new WithPreviousOperator<T>(source, operand));
 
         public static IValueObservable<T> ObservableSkipWhile<T>(this IValueObservable<T> source, Func<bool> skipWhile)
-            => new ValueOperator<T>(source.context, operand => new SkipWhileObservable<T>(source, skipWhile, operand));
+            => new ValueOperatorFactory<T>(source.context, operand => new SkipWhileOperator<T>(source, skipWhile, operand));
 
         public static ICollectionObservable<T> ObservableUnwrap<T>(this ICollectionObservable<IValueObservable<T>> source)
-            => new CollectionOperator<T>(source.context, operand => new UnwrapCollectionObservable<T>(source, operand));
+            => new CollectionOperatorFactory<T>(source.context, operand => new UnwrapCollectionOperator<T>(source, operand));
 
         public static ICollectionObservable<U> ObservableSelect<T, U>(this ICollectionObservable<T> source, Func<T, IValueObservable<U>> select)
             => source.ObservableSelect<T, IValueObservable<U>>(select).ObservableUnwrap();
 
         public static ICollectionObservable<U> ObservableSelect<T, U>(this ICollectionObservable<T> source, Func<T, U> select)
-            => new CollectionOperator<U>(source.context, operand => new SelectCollectionObservable<T, U>(source, select, operand));
+            => new CollectionOperatorFactory<U>(source.context, operand => new SelectCollectionOperator<T, U>(source, select, operand));
 
         public static ISetObservable<T> ObservableDistinct<T>(this ICollectionObservable<T> source)
-            => new SetOperator<T>(source.context, operand => new DistinctObservable<T>(source, operand));
+            => new SetOperatorFactory<T>(source.context, operand => new DistinctOperator<T>(source, operand));
 
         public static ICollectionObservable<T> ObservableWhere<T>(this ICollectionObservable<T> source, Func<T, bool> where)
             => source.ObservableWhere(x => new ObservableValue<bool>(source.context, where(x)));
 
         public static ICollectionObservable<T> ObservableWhere<T>(this ICollectionObservable<T> source, Func<T, IValueObservable<bool>> where)
-            => new CollectionOperator<T>(source.context, operand => new WhereObservable<T>(source, where, operand));
+            => new CollectionOperatorFactory<T>(source.context, operand => new WhereOperator<T>(source, where, operand));
 
         public static ICollectionObservable<T> ObservableConcat<T>(this ICollectionObservable<T> source1, IEnumerable<T> source2)
             => source1.ObservableConcat((ICollectionObservable<T>)new ObservableCollection<T>(source1.context, source2));
 
         public static ICollectionObservable<T> ObservableConcat<T>(this ICollectionObservable<T> source1, ICollectionObservable<T> source2)
-            => new CollectionOperator<T>(source1.context, operand => new ConcatObservable<T>(source1, source2, operand));
+            => new CollectionOperatorFactory<T>(source1.context, operand => new ConcatOperator<T>(source1, source2, operand));
 
         public static ICollectionObservable<U> ObservableSelectMany<T, U>(this ICollectionObservable<T> source, Func<T, IEnumerable<U>> selectMany)
             => source.ObservableSelectMany(x => (ICollectionObservable<U>)new ObservableCollection<U>(source.context, selectMany(x)));
 
         public static ICollectionObservable<U> ObservableSelectMany<T, U>(this ICollectionObservable<T> source, Func<T, ICollectionObservable<U>> selectMany)
-            => new CollectionOperator<U>(source.context, operand => new SelectManyObservable<T, U>(source, selectMany, operand));
+            => new CollectionOperatorFactory<U>(source.context, operand => new SelectManyOperator<T, U>(source, selectMany, operand));
 
         public static IListObservable<T> ObservableOrderBy<T, U>(this ICollectionObservable<T> source, Func<T, U> orderBy)
             => source.ObservableOrderBy<T, U>(x => new ObservableValue<U>(source.context, orderBy(x)));
 
         public static IListObservable<T> ObservableOrderBy<T, U>(this ICollectionObservable<T> source, Func<T, IValueObservable<U>> orderBy)
-            => new ListOperator<T>(source.context, operand => new OrderByObservable<T, U>(source, orderBy, false, operand));
+            => new ListOperatorFactory<T>(source.context, operand => new OrderByOperator<T, U>(source, orderBy, false, operand));
 
         public static IListObservable<T> ObservableOrderByDescending<T, U>(this ICollectionObservable<T> source, Func<T, U> orderBy)
             => source.ObservableOrderByDescending<T, U>(x => new ObservableValue<U>(source.context, orderBy(x)));
 
         public static IListObservable<T> ObservableOrderByDescending<T, U>(this ICollectionObservable<T> source, Func<T, IValueObservable<U>> orderBy)
-            => new ListOperator<T>(source.context, operand => new OrderByObservable<T, U>(source, orderBy, true, operand));
+            => new ListOperatorFactory<T>(source.context, operand => new OrderByOperator<T, U>(source, orderBy, true, operand));
 
         public static IValueObservable<int> ObservableCount<T>(this ICollectionObservable<T> source)
-            => new ValueOperator<int>(source.context, operand => new CountObservable<T>(source, operand));
+            => new ValueOperatorFactory<int>(source.context, operand => new CountOperator<T>(source, operand));
 
         public static IValueObservable<bool> ObservableContains<T>(this ICollectionObservable<T> source, T contains)
             => source.ObservableContains(new ObservableValue<T>(source.context, contains));
 
         public static IValueObservable<bool> ObservableContains<T>(this ICollectionObservable<T> source, IValueObservable<T> contains)
-            => new ValueOperator<bool>(source.context, operand => new ContainsObservable<T>(source, contains, operand));
+            => new ValueOperatorFactory<bool>(source.context, operand => new ContainsOperator<T>(source, contains, operand));
 
         public static IValueObservable<T> ObservableFirstOrDefault<T>(this ICollectionObservable<T> source, Func<T, bool> validate)
             => source.ObservableFirstOrDefault(x => new ObservableValue<bool>(source.context, validate(x)));
@@ -222,22 +257,22 @@ namespace ObserveThing
             => source.ObservableFirst(x => new ObservableValue<bool>(source.context, validate(x)));
 
         public static IValueObservable<(bool found, T value)> ObservableFirst<T>(this ICollectionObservable<T> source, Func<T, IValueObservable<bool>> validate)
-            => new ValueOperator<(bool found, T value)>(source.context, operand => new FirstObservable<T>(source, validate, operand));
+            => new ValueOperatorFactory<(bool found, T value)>(source.context, operand => new FirstOperator<T>(source, validate, operand));
 
         public static IValueObservable<(bool keyPresent, TValue value)> ObservableTrack<TKey, TValue>(this IDictionaryObservable<TKey, TValue> source, TKey key)
             => source.ObservableTrack(new ObservableValue<TKey>(source.context, key));
 
         public static IValueObservable<(bool keyPresent, TValue value)> ObservableTrack<TKey, TValue>(this IDictionaryObservable<TKey, TValue> source, IValueObservable<TKey> key)
-            => new ValueOperator<(bool keyPresent, TValue value)>(source.context, operand => new TrackObservable<TKey, TValue>(source, key, operand));
+            => new ValueOperatorFactory<(bool keyPresent, TValue value)>(source.context, operand => new TrackOperator<TKey, TValue>(source, key, operand));
 
         public static ICollectionObservable<TValue> ObservableTrack<TKey, TValue>(this IDictionaryObservable<TKey, TValue> source, ICollectionObservable<TKey> keys)
             => keys.ObservableSelect(x => source.ObservableTrack(x)).ObservableWhere(x => x.keyPresent).ObservableSelect(((bool keyPresent, TValue value) x) => x.value);
 
         public static IListObservable<T> ObservableUnwrap<T>(this IListObservable<IValueObservable<T>> source)
-            => new ListOperator<T>(source.context, operand => new UnwrapListObservable<T>(source, operand));
+            => new ListOperatorFactory<T>(source.context, operand => new UnwrapListOperator<T>(source, operand));
 
         public static IListObservable<U> ObservableSelect<T, U>(this IListObservable<T> source, Func<T, U> select)
-            => new ListOperator<U>(source.context, operand => new SelectListObservable<T, U>(source, select, operand));
+            => new ListOperatorFactory<U>(source.context, operand => new SelectListOperator<T, U>(source, select, operand));
 
         public static IListObservable<U> ObservableSelect<T, U>(this IListObservable<T> source, Func<T, IValueObservable<U>> select)
             => source.ObservableSelect<T, IValueObservable<U>>(select).ObservableUnwrap();
@@ -246,19 +281,19 @@ namespace ObserveThing
             => source.ObservableIndexOf(new ObservableValue<T>(source.context, value));
 
         public static IValueObservable<(bool found, int index)> ObservableIndexOf<T>(this IListObservable<T> source, IValueObservable<T> value)
-            => new ValueOperator<(bool found, int index)>(source.context, operand => new IndexOfObservable<T>(source, value, operand));
+            => new ValueOperatorFactory<(bool found, int index)>(source.context, operand => new IndexOfOperator<T>(source, value, operand));
 
         public static IDictionaryObservable<TKey, TValue> ObservableToDictionary<T, TKey, TValue>(this ICollectionObservable<T> source, Func<T, IValueObservable<TKey>> selectKey, Func<T, IValueObservable<TValue>> selectValue)
-            => new DictionaryOperator<TKey, TValue>(source.context, operand => new ToDictionaryObservable<T, TKey, TValue>(source, selectKey, selectValue, operand));
+            => new DictionaryOperatorFactory<TKey, TValue>(source.context, operand => new ToDictionaryOperator<T, TKey, TValue>(source, selectKey, selectValue, operand));
 
         public static IDictionaryObservable<TKey, TValue> ObservableToDictionary<T, TKey, TValue>(this ICollectionObservable<T> source, Func<T, TKey> selectKey, Func<T, IValueObservable<TValue>> selectValue)
-            => new DictionaryOperator<TKey, TValue>(source.context, operand => new ToDictionaryObservable<T, TKey, TValue>(source, x => new ObservableValue<TKey>(source.context, selectKey(x)), selectValue, operand));
+            => new DictionaryOperatorFactory<TKey, TValue>(source.context, operand => new ToDictionaryOperator<T, TKey, TValue>(source, x => new ObservableValue<TKey>(source.context, selectKey(x)), selectValue, operand));
 
         public static IDictionaryObservable<TKey, TValue> ObservableToDictionary<T, TKey, TValue>(this ICollectionObservable<T> source, Func<T, IValueObservable<TKey>> selectKey, Func<T, TValue> selectValue)
-            => new DictionaryOperator<TKey, TValue>(source.context, operand => new ToDictionaryObservable<T, TKey, TValue>(source, selectKey, x => new ObservableValue<TValue>(source.context, selectValue(x)), operand));
+            => new DictionaryOperatorFactory<TKey, TValue>(source.context, operand => new ToDictionaryOperator<T, TKey, TValue>(source, selectKey, x => new ObservableValue<TValue>(source.context, selectValue(x)), operand));
 
         public static IDictionaryObservable<TKey, TValue> ObservableToDictionary<T, TKey, TValue>(this ICollectionObservable<T> source, Func<T, TKey> selectKey, Func<T, TValue> selectValue)
-            => new DictionaryOperator<TKey, TValue>(source.context, operand => new ToDictionaryObservable<T, TKey, TValue>(source, x => new ObservableValue<TKey>(source.context, selectKey(x)), x => new ObservableValue<TValue>(source.context, selectValue(x)), operand));
+            => new DictionaryOperatorFactory<TKey, TValue>(source.context, operand => new ToDictionaryOperator<T, TKey, TValue>(source, x => new ObservableValue<TKey>(source.context, selectKey(x)), x => new ObservableValue<TValue>(source.context, selectValue(x)), operand));
 
         public static IValueObservable<T> AsObservable<T>(this IValueObservable<T> observable)
             => observable;
@@ -282,8 +317,8 @@ namespace ObserveThing
             return result;
         }
 
-        public static IDisposable Subscribe<T>(this IObservable<T> source, Action<T> onNext = default, Action<Exception> onError = default, Action onDispose = default, bool immediate = default, uint? priority = default) where T : IOperation
-            => source.Subscribe(new Observer<T>(onNext, onDispose, onError), immediate, priority);
+        public static IDisposable Subscribe<T>(this IEventStreamObservable<T> source, Action<T> onNext = default, Action<Exception> onError = default, Action onDispose = default, bool immediate = default, uint? priority = default)
+            => source.Subscribe(new EventStreamObserver<T>(onNext, onDispose, onError), immediate, priority);
 
         public static IDisposable Subscribe(this IValueObservable source, Action<object> onNext = default, Action<Exception> onError = default, Action onDispose = default, bool immediate = default, uint? priority = default)
             => source.Subscribe(new ValueObserver(onNext, onDispose, onError), immediate, priority);
@@ -291,9 +326,6 @@ namespace ObserveThing
         public static IDisposable Subscribe<T>(this IValueObservable<T> source, Action<T> onNext = default, Action<Exception> onError = default, Action onDispose = default, bool immediate = default, uint? priority = default)
             => source.Subscribe(new ValueObserver<T>(onNext, onDispose, onError), immediate, priority);
 
-        public static IDisposable Subscribe<T>(this IObservable<BatchOp<T>> source, Action<IReadOnlyList<T>> onNext = default, Action<Exception> onError = default, Action onDispose = default, bool immediate = default, uint? priority = default) where T : IOperation
-            => source.Subscribe(new Observer<BatchOp<T>>(onNext: x => onNext?.Invoke(x.operations), onDispose, onError), immediate, priority);
-
         public static IDisposable Subscribe(this IDictionaryObservable source, Action<KeyValuePair<object, object>> onAdd = default, Action<KeyValuePair<object, object>> onRemove = default, Action<Exception> onError = default, Action onDispose = default, bool immediate = default, uint? priority = default)
             => source.Subscribe(new DictionaryObserver(
                 onAdd: onAdd == null ? null : (_, kvp) => onAdd?.Invoke(kvp),

package/Runtime/{Observables/OrderByObservable.cs → Operators/OrderByOperator.cs}

@@ -4,7 +4,7 @@ using System.Linq;
 
 namespace ObserveThing
 {
-    public class OrderByObservable<T, U> : IDisposable
+    public class OrderByOperator<T, U> : IDisposable
     {
         private ObservableList<T> _operand;
         private Func<T, IValueObservable<U>> _orderBy;
@@ -21,7 +21,7 @@ namespace ObserveThing
             public IDisposable subscription;
         }
 
-        public OrderByObservable(ICollectionObservable<T> source, Func<T, IValueObservable<U>> orderBy, bool descending, ObservableList<T> operand)
+        public OrderByOperator(ICollectionObservable<T> source, Func<T, IValueObservable<U>> orderBy, bool descending, ObservableList<T> operand)
         {
             _orderBy = orderBy;
             _compare = descending ? DescendingCompare : AscendingCompare;

package/Runtime/{Observables/SelectCollectionObservable.cs → Operators/SelectCollectionOperator.cs}

@@ -2,12 +2,12 @@ using System;
 
 namespace ObserveThing
 {
-    public class SelectCollectionObservable<T, U> : IDisposable
+    public class SelectCollectionOperator<T, U> : IDisposable
     {
         private ObservableCollection<U> _operand;
         private IDisposable _subscriptions;
 
-        public SelectCollectionObservable(ICollectionObservable<T> source, Func<T, U> select, ObservableCollection<U> operand)
+        public SelectCollectionOperator(ICollectionObservable<T> source, Func<T, U> select, ObservableCollection<U> operand)
         {
             _operand = operand;
             _subscriptions = source.SubscribeWithId(

package/Runtime/{Observables/SelectListObservable.cs → Operators/SelectListOperator.cs}

@@ -2,12 +2,12 @@ using System;
 
 namespace ObserveThing
 {
-    public class SelectListObservable<T, U> : IDisposable
+    public class SelectListOperator<T, U> : IDisposable
     {
         private ObservableList<U> _operand;
         private IDisposable _subscriptions;
 
-        public SelectListObservable(IListObservable<T> source, Func<T, U> select, ObservableList<U> operand)
+        public SelectListOperator(IListObservable<T> source, Func<T, U> select, ObservableList<U> operand)
         {
             _operand = operand;
             _subscriptions = source.Subscribe(

package/Runtime/{Observables/SelectManyObservable.cs → Operators/SelectManyOperator.cs}

@@ -4,7 +4,7 @@ using System.Linq;
 
 namespace ObserveThing
 {
-    public class SelectManyObservable<T, U> : IDisposable
+    public class SelectManyOperator<T, U> : IDisposable
     {
         private class ElementData
         {
@@ -18,7 +18,7 @@ namespace ObserveThing
         private CollectionIdProvider _idProvider;
         private IDisposable _subscriptions;
 
-        public SelectManyObservable(ICollectionObservable<T> source, Func<T, ICollectionObservable<U>> select, ObservableCollection<U> operand)
+        public SelectManyOperator(ICollectionObservable<T> source, Func<T, ICollectionObservable<U>> select, ObservableCollection<U> operand)
         {
             _select = select;
             _operand = operand;

package/Runtime/{Observables/SkipWhileObservable.cs → Operators/SkipWhileOperator.cs}

@@ -2,12 +2,12 @@ using System;
 
 namespace ObserveThing
 {
-    public class SkipWhileObservable<T> : IDisposable
+    public class SkipWhileOperator<T> : IDisposable
     {
         private ObservableValue<T> _operand;
         private IDisposable _subscriptions;
 
-        public SkipWhileObservable(IValueObservable<T> source, Func<bool> skipWhile, ObservableValue<T> operand)
+        public SkipWhileOperator(IValueObservable<T> source, Func<bool> skipWhile, ObservableValue<T> operand)
         {
             _operand = operand;
             _subscriptions = source.Subscribe(

package/Runtime/{Observables/ThenObservable.cs → Operators/ThenOperator.cs}

@@ -2,14 +2,14 @@ using System;
 
 namespace ObserveThing
 {
-    public class ThenValueObservable<T> : IDisposable
+    public class ThenValueOperator<T> : IDisposable
     {
         private IValueObservable<T> _source;
         private IValueObserver<T> _then;
         private ObservableValue<T> _operand;
         private IDisposable _subscriptions;
 
-        public ThenValueObservable(IValueObservable<T> source, IValueObserver<T> then, ObservableValue<T> operand)
+        public ThenValueOperator(IValueObservable<T> source, IValueObserver<T> then, ObservableValue<T> operand)
         {
             _source = source;
             _then = then;

package/Runtime/{Observables/ToDictionaryObservable.cs → Operators/ToDictionaryOperator.cs}

@@ -3,16 +3,16 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class ToDictionaryObservable<T, TKey, TValue> : IDisposable
+    public class ToDictionaryOperator<T, TKey, TValue> : IDisposable
     {
         private IDisposable _subscription;
         private ObservableDictionary<TKey, TValue> _operand;
 
-        public ToDictionaryObservable(ICollectionObservable<T> source, Func<T, IValueObservable<TKey>> selectKey, Func<T, IValueObservable<TValue>> selectValue, ObservableDictionary<TKey, TValue> operand)
+        public ToDictionaryOperator(ICollectionObservable<T> source, Func<T, IValueObservable<TKey>> selectKey, Func<T, IValueObservable<TValue>> selectValue, ObservableDictionary<TKey, TValue> operand)
         {
             _operand = operand;
             _subscription = source.ObservableSelect(
-                x => Observables.ObservableCombineValues(
+                x => Operators.ObservableCombineValues(
                     selectKey(x),
                     selectValue(x),
                     (key, value) => new KeyValuePair<TKey, TValue>(key, value)

package/Runtime/{Observables/TrackObservable.cs → Operators/TrackOperator.cs}

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class TrackObservable<TKey, TValue> : IDisposable
+    public class TrackOperator<TKey, TValue> : IDisposable
     {
         private ObservableValue<(bool keyPresent, TValue value)> _operand;
         private Dictionary<TKey, TValue> _dict = new Dictionary<TKey, TValue>();
@@ -12,7 +12,7 @@ namespace ObserveThing
 
         private IDisposable _subscriptions;
 
-        public TrackObservable(IDictionaryObservable<TKey, TValue> source, IValueObservable<TKey> key, ObservableValue<(bool keyPresent, TValue value)> operand)
+        public TrackOperator(IDictionaryObservable<TKey, TValue> source, IValueObservable<TKey> key, ObservableValue<(bool keyPresent, TValue value)> operand)
         {
             _operand = operand;
             _subscriptions = new ComposedDisposable(

package/Runtime/{Observables/UnwrapCollectionObservable.cs → Operators/UnwrapCollectionOperator.cs}

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class UnwrapCollectionObservable<T> : IDisposable
+    public class UnwrapCollectionOperator<T> : IDisposable
     {
         private ObservableCollection<T> _operand;
         private Dictionary<uint, EntryData> _dataById = new Dictionary<uint, EntryData>();
@@ -15,7 +15,7 @@ namespace ObserveThing
             public bool initialized;
         }
 
-        public UnwrapCollectionObservable(ICollectionObservable<IValueObservable<T>> source, ObservableCollection<T> operand)
+        public UnwrapCollectionOperator(ICollectionObservable<IValueObservable<T>> source, ObservableCollection<T> operand)
         {
             _operand = operand;
             _subscriptions = source.Subscribe(new CollectionObserver<IValueObservable<T>>(

package/Runtime/{Observables/UnwrapListObservable.cs → Operators/UnwrapListOperator.cs}

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class UnwrapListObservable<T> : IDisposable
+    public class UnwrapListOperator<T> : IDisposable
     {
         private ObservableList<T> _operand;
         private List<EntryData> _data = new List<EntryData>();
@@ -15,7 +15,7 @@ namespace ObserveThing
             public bool initialized;
         }
 
-        public UnwrapListObservable(IListObservable<IValueObservable<T>> source, ObservableList<T> operand)
+        public UnwrapListOperator(IListObservable<IValueObservable<T>> source, ObservableList<T> operand)
         {
             _operand = operand;
             _subscriptions = source.Subscribe(

package/Runtime/{Observables/UnwrapValueObservable.cs → Operators/UnwrapValueOperator.cs}

@@ -2,14 +2,14 @@ using System;
 
 namespace ObserveThing
 {
-    public class UnwrapValueObservable<T> : IDisposable
+    public class UnwrapValueOperator<T> : IDisposable
     {
         private ObservableValue<T> _operand;
         private ValueObserver<T> _nestedObserver;
         private IDisposable _nestedSubscription;
         private IDisposable _subscriptions;
 
-        public UnwrapValueObservable(IValueObservable<IValueObservable<T>> source, ObservableValue<T> operand)
+        public UnwrapValueOperator(IValueObservable<IValueObservable<T>> source, ObservableValue<T> operand)
         {
             _operand = operand;