Computed<T>

// System.Reactive.Computed — System.Core (decompiled from Larva HIR)

into namespace System.Reactive
{
	/// A value computed from reactive ones, kept until one of them changes: what `computed T P => e;` makes.
	public final class Computed<T>
	{
		func : T compute;
		T value;
		Source source;
		Effect tracker;

		Refresh()
		{
			value = compute();
		}

		public:
			new(func : T compute)
			{
				source = new Source();
				this.compute = compute;
				tracker = new Effect(() => { Refresh(); });
				tracker.Lazy = true;
				tracker.Stale = true;
				tracker.Dependents = source;
			}

			/// Stops tracking: it keeps its last value and no Source invalidates it again.
			Dispose()
			{
				tracker.Dispose();
			}

			/// The value (computed now when stale); reading it inside an effect makes the effect depend on it.
			T Value
			{
				get
				{
					source.Track();
					if (tracker.Stale || tracker.Pending)
						Reactive.Refresh(tracker);
					return value;
				}
			}

			/// Whether the next read computes it again.
			bool Stale
			{
				get => tracker.Stale;
			}
	}
}