ManualObservableSource experiments (see #21)

playground/Playground.cs

@@ -5,31 +5,29 @@
 
 class Playground
 {
-    static async Task Main()
+	class MutableObject
+	{
+		public string Field = "initial";
+	}
+
+    static void Main()
     {
-        var stateA = Observable.State("hello");
-        var stateB = Observable.State("world");
+	    var mutableObject = new MutableObject();
 
-        var o = Observable.Auto(async () =>
-        {
-            Console.WriteLine("computing");
-            var a = stateA.Value;
-            await Task.Delay(1000);
-            var b = stateB.Value;
-            return a + " " + b;
-        });
+	    var mutableObjectSource = Observable.Manual(mutableObject);
 
-        o.Bind(result => Console.WriteLine(result.Status switch
-        {
-            AsyncComputeStatus.Loading => "Loading...",
-            AsyncComputeStatus.Done => "Done: " + result.Result,
-            AsyncComputeStatus.Failed => "Failed: " + result.Exception,
-        }));
+	    void Mutate(string newFieldValue)
+	    {
+		    mutableObject.Field = newFieldValue;
+		    mutableObjectSource.Invalidate();
+	    }
 
-        await Task.Delay(1500);
+	    var mutableObjectObservable = mutableObjectSource.Observe();
+	    mutableObjectObservable.Bind(o => Console.WriteLine(o.Field));
 
-        stateB.Value = "Dan";
+	    var auto = Observable.Auto(() => mutableObjectObservable.Value.Field.ToUpperInvariant());
+	    auto.Bind(v => Console.WriteLine(v));
 
-        Process.GetCurrentProcess().WaitForExit();
+	    Mutate("Hello");
     }
 }

src/TinkState/Runtime/Internal/ManualObservableSource.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+
+namespace TinkState.Internal
+{
+	class ManualObservableSource<T> : Dispatcher, Observable<T>, TinkState.ManualObservableSource<T>, DispatchingObservable<T>
+	{
+		T value;
+
+		public ManualObservableSource(T initialValue)
+		{
+			value = initialValue;
+		}
+
+		public T Value => AutoObservable.Track(this);
+
+		public Observable<T> Observe()
+		{
+			return this;
+		}
+
+		public void Invalidate()
+		{
+			Fire();
+		}
+
+		public void Update(T newValue)
+		{
+			value = newValue;
+			Fire();
+		}
+
+		public IDisposable Bind(Action<T> callback, IEqualityComparer<T> comparer = null, Scheduler scheduler = null)
+		{
+			return new Binding<T>(this, callback, comparer, scheduler);
+		}
+
+		public Observable<TOut> Map<TOut>(Func<T, TOut> transform, IEqualityComparer<TOut> comparer = null)
+		{
+			return new TransformObservable<T, TOut>(this, transform, comparer);
+		}
+
+		public IEqualityComparer<T> GetComparer()
+		{
+			return NeverEqualityComparer<T>.Instance;
+		}
+
+		public long GetRevision()
+		{
+			return revision;
+		}
+
+		public T GetCurrentValue()
+		{
+			return value;
+		}
+	}
+}

src/TinkState/Runtime/ManualObservableSource.cs

@@ -0,0 +1,9 @@
+namespace TinkState
+{
+	public interface ManualObservableSource<T>
+	{
+		Observable<T> Observe();
+		void Invalidate();
+		void Update(T newValue);
+	}
+}

src/TinkState/Runtime/Observable.cs

@@ -212,6 +212,11 @@ public static ObservableDictionary<TKey, TValue> Dictionary<TKey, TValue>()
 
 		// TODO: Dictionary with initial value
 
+		public static ManualObservableSource<T> Manual<T>(T initialValue)
+		{
+			return new Internal.ManualObservableSource<T>(initialValue);
+		}
+
 		/// <summary>
 		/// Default scheduler used for bindings.
 		/// </summary>