interface IOperator<TSource, TResult> : IObserver<TSource>, IObservable<TResult>
{ }

struct SelectOperator<TSource, TResult, TContinuation> : IOperator<TSource, TResult>
    where TContinuation : IObserver<TResult>
{ }

struct WhereOperator<TSource, TContinuation> : IOperator<TSource, TSource>
    where TContinuation : IObserver<TSource>
{ }

struct PublishOperator<TSource> : IOperator<TSource, TSource>
{ }

new SelectOperator<TSource, TResult, WhereOperator<TResult, PublishOperator<TResult>>>(
    new WhereOperator<TResult, PublishOperator<TResult>>(
        new PublishOperator<TResult>())):

public interface IOperatorFactory<TSource, TResult>
{
    IDisposable ApplyOperator<TContinuation>(TContinuation continuation)
        where TContinuation : IOperator<TSource, TResult>;
}

public struct SelectOperatorFactory<TSource, TResult, TPrevious>
    where TPrevious : IOperatorFactory<TSource>
{
    public Func<TSource, TResult> Select { get; init; }
    public TPrevious Previous { get; init; }

    public IDisposable ApplyOperator<TSource, TContinuation>(TContinuation continuation)
        where TContinuation : IOperator<TSource, TResult>
    {
        return Previous.ApplyOperator<SelectOperator<TSource, TResult, TContinuation>>(
            new(continuation, Select);
    }
}

public static class ObserverExtensions
{
    public static SelectOperatorFactory<TSource, TResult, TPrevious> Select(this TPrevious source, Func<TSource, TResult> select)
        where TPrevious : IOperatorFactory<TSource>
    {
        return new()
        {
            Previous = previous,
            Select = select,
        };
    }
}

new List<int>().M(); // error CS0411: The type arguments for method 'C.M<X, Y>(X)' cannot be inferred from the usage. Try specifying the type arguments explicitly.

public static class C {
    public static void M<X, Y>(this X x)
        where X : IEnumerable<Y> {
    }
}

public abstract class Operator<TResult>
{
}

public abstract class Operator<TSource, TResult> : Operator<TResult>
{
    protected Operator<TSource> Source { get; }

    protected Operator(Operator<TSource> source)
    {
        Source = source;
    }
}

public interface IStateMachine<T> : IObserver<T>, IDisposable
{
}

public interface IStateMachineBoxFactory<TBox>
{
    TBox Create<TSource, TStateMachine>(in TStateMachine stateMachine)
        where TStateMachine : struct, IStateMachine<TSource>;
}

public abstract class Operator<TResult>
{
    public abstract TBox Build<TBox, TBoxFactory, TContinuation>(in TBoxFactory boxFactory, in TContinuation continuation)
        where TBoxFactory : struct, IStateMachineBoxFactory<TBox>
        where TContinuation : struct, IStateMachine<TResult>;
}

internal sealed class SelectOperator<TSource, TResult> : Operator<TSource, TResult>
{
    private readonly Func<TSource, TResult> _selector;

    public SelectOperator(Operator<TSource> source) :
        base(source)
    {
        _selector = selector;
    }

    public override TBox Build<TBox, TBoxFactory, TContinuation>(in TBoxFactory boxFactory, in TContinuation continuation) =>
        Source.Build<TBox, TBoxFactory, StateMachine<TContinuation>>(boxFactory, new(continuation, _selector));

    private struct StateMachine<TContinuation> : IStateMachine<TSource>
        where TContinuation: struct, IStateMachine<TResult>
    {
        private TContinuation _continuation;
        private readonly Func<TSource, TResult> _selector;

        public StateMachine(in TContinuation continuation, Func<TSource, TResult> selector)
        {
            _continuation = continuation;
            _selector = selector;
        }

        public void OnNext(TSource value) =>
            _continuation.OnNext(_selector(value));

        public void OnError(Exception error) =>
            _continuation.OnError(error);

        public void OnCompleted(TSource value) =>
            _continuation.OnCompleted();
    }
}

internal sealed class BoxOperator<TSource> : Operator<TSource>
{
    private readonly IObservable<TSource> _source;

    public BoxOperator(IObservable<TSource> source) =>
        _source = source;

    public override TBox Build<TBox, TBoxFactory, TContinuation>(in TBoxFactory boxFactory, in TContinuation continuation)
    {
        var box = boxFactory.Create<TSource, Continuation>(boxFactory, new(continuation, _selector));

        // Actually, it's more complicated as not every box
        // can be an observable and we don't restrict that.
        _observable.Subscribe((IObserver<TSource>) box);

        return box;
    }
}

public static class OperatorExtensions
{
    public static Operator<TResult> Select<TSource, TResult>(this Operator<TSource> source, Func<TSource, TResult> selector) =>
        new SelectOperator<TSource, TResult>(source, selector);

    public static Operator<TResult> Select<TSource, TResult>(this IObservable<TSource> source, Func<TSource, TResult> selector) =>
        new BoxOperator<TSource>(source).Select(selector);
}

[MemoryDiagnoser]
public class HandleChainBenchmarks
{
    private PublishSubject<int> _lightweight = new();
    private PublishSubject<int> _reactive = new();

    [Params(1, 2, 3, 4, 5, 10)]
    public int ChainLength { get; set; }

    [GlobalSetup]
    public void Setup()
    {
        var lightweight = _lightweight.ToOperator();
        var reactive = _reactive as IObservable<int>;

        for (var index = 0; index < ChainLength; index += 1)
        {
            lightweight = lightweight.Select(x => x * 2);
            reactive = System.Reactive.Linq.Observable.Select(reactive, x => x * 2);
        }

        _ = lightweight.ToObservable();
    }

    [Benchmark]
    public void Lightweight() =>
        _lightweight.OnNext(42);

    [Benchmark]
    public void Reactive() =>
        _reactive.OnNext(42);
}

[GlobalSetup]
public void Setup()
{
    var lightweight = _lightweight.ToOperator();
    var reactive = _reactive as IObservable<int>;

    for (var index = 0; index < ChainLength; index += 1)
    {
        lightweight = lightweight.Select(x => x * 2);
        reactive = System.Reactive.Linq.Observable.Select(reactive, x => x * 2);
    }

    _ = lightweight.ToObservable();
    _ = reactive.Subscribe(NoOp<int>.Instance); // 👈 that's what we need
}

[MemoryDiagnoser]
public class CreateChainBenchmarks
{
    private PublishSubject<int> _observable = new();

    [Params(1, 2, 3, 4, 5, 10)]
    public int ChainLength { get; set; }

    [Benchmark]
    public IObservable<int> Lightweight()
    {
        var op = _observable.ToOperator();
        for (int index = 0; index < ChainLength; index += 1)
            op = op.Select(x => x);
        return op.ToObservable();
    }

    [Benchmark]
    public IDisposable Reactive()
    {
        var op = _observable as IObservable<int>;
        for (int index = 0; index < ChainLength; index += 1)
            op = System.Reactive.Linq.Observable.Select(op, x => x);
        return op.Subscribe(NoOp<int>.Instance);  // 👈 remember about it
    }
}

public sealed class NoOp<T> : IObserver<T>
{
    public static readonly NoOp<T> Instance = new();

    public void OnCompleted() { }

    public void OnError(Exception error) { }

    public void OnNext(T value) { }
}

public interface IOperator<T>
{
    TBox Box<TBox, TBoxFactory, TStateMachine>(in TBoxFactory boxFactory, in TStateMachine stateMachine)
        where TBoxFactory : struct, IStateMachineBoxFactory<TBox>
        where TStateMachine : struct, IStateMachine<T>;
}

public readonly struct Select<TObservable, TSource, TResult> : IOperator<TResult>
    where TObservable : IOperator<TSource>
{
    private readonly TObservable _observable;
    private readonly Func<TSource, TResult> _selector;

    public SelectOp(TObservable observable, Func<TSource, TResult> selector)
    {
        _observable = observable;
        _selector = selector;
    }

    public TBox Box<TBox, TBoxFactory, TStateMachine>(in TBoxFactory boxFactory, in TStateMachine stateMachine)
        where TBoxFactory : struct, IStateMachineBoxFactory<TBox>
        where TStateMachine : struct, IStateMachine<TResult>
    {
        return _observable.Box<TBox, TBoxFactory, SelectStateMachine<TSource, TResult, TStateMachine>>(
            boxFactory, new(stateMachine, _selector));
    }
}

internal struct SelectStateMachine<TSource, TResult, TContinuation> : IStateMachine<TSource>
    where TContinuation : struct, IStateMachine<TResult>
{
    // as usual and nothing interesting to show again
}

public readonly struct Observer<TOperator, T>
    where TOperator : IOperator<T>
{
    private readonly TOperator _op;

    public Observer(TOperator op) =>
        _op = op;

    //     👇 return a wrapper instead of the real operator
    public Operator<Select<TOperator, T, TResult>, TResult> Select<TResult>(Func<T, TResult> selector) =>
        new(new(_op, selector));

    // turns the chain into a state machine and boxes it 📦
    public IObservable<T> ToObservable() =>
        ObservableFactory<T>.Create(_op);
}

public readonly struct Observer<TOperator, T> : IOperator<T>
{
    public TBox Box<TBox, TBoxFactory, TStateMachine>(in TBoxFactory boxFactory, in TStateMachine stateMachine)
        where TBoxFactory : struct, IStateMachineBoxFactory<TBox>
        where TStateMachine : struct, IStateMachine<TResult>
    {
        return _op.Box<TBox, TBoxFactory, TStateMachine>(
            boxFactory, stateMachine);
    }
}

public static class OperatorExtensions
{
    public Operator<Select<IOperator<T>, T, TResult>, TResult> Select<T, TResult>(this IOperator<T> source, Func<T, TResult> selector) =>
        new(new(source, selector));

    public IObservable<T> ToObservable<T>(this IOperator<T> source) =>
        ObservableFactory<T>.Create(source);
}

public static class OperatorExtensions
{
    public Operator<Select<Observe<T>, T, TResult>, TResult> Select<T, TResult>(this IObservable<T> source, Func<T, TResult> selector) =>
        new(new(new(source), selector));
}

[Benchmark]
public IObservable<int> CreateChain_1()
{
    return _subject
        .Select(x => x)
        .ToObservable();
}

[Benchmark]
public IObservable<int> CreateChain_2()
{
    return _subject
        .Select(x => x)
        .Select(x => x)
        .ToObservable();
}

// and so on for chains of 3, 4, 5, and 10 operators...

public readonly record struct StronglyTypedKey<T>(T Value);

[RankColumn]
[MemoryDiagnoser]
[DisassemblyDiagnoser]
[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByParams, BenchmarkLogicalGroupRule.ByCategory)]
public class Benchmark
{
  // ...
}

public class BaseImplementation<T> where T : notnull
{
  private readonly T _toLookup;
  private readonly StronglyTypedKey<T> _toLookupStronglyTyped;
 
  private readonly Dictionary<T, string> _traditional;
  private readonly Dictionary<StronglyTypedKey<T>, string> _traditionalWithStronglyTypedKey;
  private readonly Dictionary<StronglyTypedKey<T>, string> _traditionalWithStronglyTypedKeyWithCustomComparer;

  private readonly FrozenDictionary<T, string> _frozen;
  private readonly FrozenDictionary<StronglyTypedKey<T>, string> _frozenWithStronglyTypedKey;
  private readonly FrozenDictionary<StronglyTypedKey<T>, string> _frozenWithStronglyTypedKeyWithCustomComparer;

  public BaseImplementation(int n, IEqualityComparer<StronglyTypedKey<T>> equalityComparer, Func<int, T> factory)
  {
    var contents = Enumerable.Range(0, n).Select(factory).ToArray();

    _toLookup = contents.Last();
    _toLookupStronglyTyped = new StronglyTypedKey<T>(_toLookup);

    _traditional = contents.ToDictionary(x => x, x => x.ToString()!);
    _traditionalWithStronglyTypedKey = contents.ToDictionary(x => new StronglyTypedKey<T>(x), x => x.ToString()!);
    _traditionalWithStronglyTypedKeyWithCustomComparer = contents.ToDictionary(x => new StronglyTypedKey<T>(x), x => x.ToString()!, equalityComparer);

    _frozen = _traditional.ToFrozenDictionary();
    _frozenWithStronglyTypedKey = _traditionalWithStronglyTypedKey.ToFrozenDictionary();
    _frozenWithStronglyTypedKeyWithCustomComparer = _traditionalWithStronglyTypedKey.ToFrozenDictionary(equalityComparer);
  }

  public string LookupTraditional() =>
    _traditional[_toLookup];

  public string LookupTraditionalWithStronglyTypedKey() =>
    _traditionalWithStronglyTypedKey[_toLookupStronglyTyped];

  public string LookupTraditionalWithStronglyTypedKeyWithCustomComparer() =>
    _traditionalWithStronglyTypedKeyWithCustomComparer[_toLookupStronglyTyped];

  public string LookupFrozen() =>
    _frozen[_toLookup];

  public string LookupFrozenWithStronglyTypedKey() =>
    _frozenWithStronglyTypedKey[_toLookupStronglyTyped];

  public string LookupFrozenWithStronglyTypedKeyWithCustomComparer() =>
    _frozenWithStronglyTypedKeyWithCustomComparer[_toLookupStronglyTyped];
}

internal ref TValue FindValue(TKey key)
{
  ref Entry entry = ref Unsafe.NullRef<Entry>();
  if (_buckets != null)
  {
    Debug.Assert(_entries != null, "expected entries to be != null");
    IEqualityComparer<TKey>? comparer = _comparer;
    if (typeof(TKey).IsValueType && // comparer can only be null for value types; enable JIT to eliminate entire if block for ref types
      comparer == null)
    {
      uint hashCode = (uint)key.GetHashCode();
      int i = GetBucket(hashCode);
      Entry[]? entries = _entries;
      uint collisionCount = 0;

      // ValueType: Devirtualize with EqualityComparer<TKey>.Default intrinsic
      i--; // Value in _buckets is 1-based; subtract 1 from i. We do it here so it fuses with the following conditional.
      do
      {
        // Test in if to drop range check for following array access
        if ((uint)i >= (uint)entries.Length)
        {
          goto ReturnNotFound;
        }

        entry = ref entries[i];
        if (entry.hashCode == hashCode && EqualityComparer<TKey>.Default.Equals(entry.key, key))
        {
          goto ReturnFound;
        }

        i = entry.next;

        collisionCount++;
      } while (collisionCount <= (uint)entries.Length);
    }
    else
    {
      // ...
    }
  }

  goto ReturnNotFound;

ReturnFound:
  ref TValue value = ref entry.value;
Return:
  return ref value;
ReturnNotFound:
  value = ref Unsafe.NullRef<TValue>();
  goto Return;
}

public Dictionary(int capacity, IEqualityComparer<TKey>? comparer)
{
  if (capacity < 0)
  {
    ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
  }

  if (capacity > 0)
  {
    Initialize(capacity);
  }

  // For reference types, we always want to store a comparer instance, either
  // the one provided, or if one wasn't provided, the default (accessing
  // EqualityComparer<TKey>.Default with shared generics on every dictionary
  // access can add measurable overhead). For value types, if no comparer is
  // provided, or if the default is provided, we'd prefer to use
  // EqualityComparer<TKey>.Default.Equals on every use, enabling the JIT to
  // devirtualize and possibly inline the operation.
  if (!typeof(TKey).IsValueType)
  {
    _comparer = comparer ?? EqualityComparer<TKey>.Default;

    // Special-case EqualityComparer<string>.Default, StringComparer.Ordinal, and StringComparer.OrdinalIgnoreCase.
    // We use a non-randomized comparer for improved perf, falling back to a randomized comparer if the
    // hash buckets become unbalanced.
    if (typeof(TKey) == typeof(string) &&
      NonRandomizedStringEqualityComparer.GetStringComparer(_comparer!) is IEqualityComparer<string> stringComparer)
    {
      _comparer = (IEqualityComparer<TKey>)stringComparer;
    }
  }
  else if (comparer is not null && // first check for null to avoid forcing default comparer instantiation unnecessarily
       comparer != EqualityComparer<TKey>.Default)
  {
    _comparer = comparer;
  }
}

internal ref TValue FindValue(TKey key)
{
  // ...

  ref Entry entry = ref Unsafe.NullRef<Entry>();
  if (_buckets != null)
  {
    Debug.Assert(_entries != null, "expected entries to be != null");
    IEqualityComparer<TKey>? comparer = _comparer;
    if (typeof(TKey).IsValueType && // comparer can only be null for value types; enable JIT to eliminate entire if block for ref types
      comparer == null)
    {
      // ..
      do
      {
        // ..
        // Resolution of the default equality comparer 👇
        if (entry.hashCode == hashCode && EqualityComparer<TKey>.Default.Equals(entry.key, key))
        {
          goto ReturnFound;
        }

        // ..
      } while (collisionCount <= (uint)entries.Length);
    }
    else
    {
      Debug.Assert(comparer is not null);
      // ..
      do
      {
        // ..
        // Just a virtual call, nothing else 👇
        if (entry.hashCode == hashCode && comparer.Equals(entry.key, key))
        {
          goto ReturnFound;
        }

        // ..
      } while (collisionCount <= (uint)entries.Length);
    }
  // ..
}

public Dictionary(int capacity, IEqualityComparer<TKey>? comparer)
{
  // ..

  if (!typeof(TKey).IsValueType)
  {
    _comparer = comparer ?? EqualityComparer<TKey>.Default;

    // Special-case EqualityComparer<string>.Default, StringComparer.Ordinal, and StringComparer.OrdinalIgnoreCase.
    // We use a non-randomized comparer for improved perf, falling back to a randomized comparer if the
    // hash buckets become unbalanced.
    if (typeof(TKey) == typeof(string) &&
      NonRandomizedStringEqualityComparer.GetStringComparer(_comparer!) is IEqualityComparer<string> stringComparer)
    {
      _comparer = (IEqualityComparer<TKey>)stringComparer;
    }

    //..
  }
}

private bool TryInsert(TKey key, TValue value, InsertionBehavior behavior)
{
  // ...
  // Value types never rehash
  if (!typeof(TKey).IsValueType && collisionCount > HashHelpers.HashCollisionThreshold && comparer is NonRandomizedStringEqualityComparer)
  {
    // If we hit the collision threshold we'll need to switch to the comparer which uses randomized string hashing
    // i.e. EqualityComparer<string>.Default.
    Resize(entries.Length, true);
  }
  // ...
}

private void Resize(int newSize, bool forceNewHashCodes)
{
  // Value types never rehash
  Debug.Assert(!forceNewHashCodes || !typeof(TKey).IsValueType);
  Debug.Assert(_entries != null, "_entries should be non-null");
  Debug.Assert(newSize >= _entries.Length);

  Entry[] entries = new Entry[newSize];

  int count = _count;
  Array.Copy(_entries, entries, count);

  if (!typeof(TKey).IsValueType && forceNewHashCodes)
  {
    Debug.Assert(_comparer is NonRandomizedStringEqualityComparer);
    IEqualityComparer<TKey> comparer = _comparer = (IEqualityComparer<TKey>)((NonRandomizedStringEqualityComparer)_comparer).GetRandomizedEqualityComparer();

    for (int i = 0; i < count; i++)
    {
      if (entries[i].next >= -1)
      {
        entries[i].hashCode = (uint)comparer.GetHashCode(entries[i].key);
      }
    }
  }
  // ..
}

public readonly record struct SerialNumber(string Value);

private Dictionary<SerialNumber, string> _serialNumbers = null!;
private SerialNumber _serialNumberToLookup;

private Dictionary<string, string> _strings = null!;
private string _stringToLookup = null!;

[GlobalSetup]
public void Setup()
{
  var data = Enumerable.Range(0, N).Select(x => x.ToString());

  _serialNumbers = data.ToDictionary(x => new SerialNumber(x));
  _serialNumberToLookup = _serialNumbers.Last().Key;

  _strings = data.ToDictionary(x => x);
  _stringToLookup = _strings.Last().Key;
}

[Params(1, 10, 100, 1_000, 10_000)]
public int N { get; set; }

[Benchmark]
public string LookupSerialNumber() =>
  _serialNumbers[_serialNumberToLookup];

[Benchmark]
public string LookupString() =>
  _strings[_stringToLookup];

public interface IReactiveObject : INotifyPropertyChanged, INotifyPropertyChanging, IEnableLogger
{
    void RaisePropertyChanging(PropertyChangingEventArgs args);

    void RaisePropertyChanged(PropertyChangedEventArgs args);
}

class Person : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;

    private string? _firstName;
    public string? FirstName
    {
        get => _firstName;
        set => Set(ref _firstName, value);
    }

    private string? _lastName;
    public string? LastName
    {
        get => _lastName;
        set => Set(ref _lastName, value);
    }

    private void Set<T>(ref T? field, T? value, [CallerMemberName] string propertyName = "")
    {
        if (EqualityComparer<T>.Default.Equals(field, value))
        {
            // No event should be fired due to the value being the same
        }
        else
        {
            field = value;

            // Call handlers only if they are present
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

ublic class ReactiveObject : IReactiveNotifyPropertyChanged<IReactiveObject>, IHandleObservableErrors, IReactiveObject
{
    private readonly Lazy<Unit> _propertyChangedEventsSubscribed;
    
    public ReactiveObject()
    {
        _propertyChangingEventsSubscribed = new Lazy<Unit>(
            () =>
            {
               this.SubscribePropertyChangingEvents();
               return Unit.Default;
            },
            LazyThreadSafetyMode.PublicationOnly);
    }

    public event PropertyChangedEventHandler? PropertyChanged
    {
        add
        {
            _ = _propertyChangedEventsSubscribed.Value;
            PropertyChangedHandler += value;
        }
        remove => PropertyChangedHandler -= value;
    }

    private event PropertyChangedEventHandler? PropertyChangedHandler;

    void IReactiveObject.RaisePropertyChanged(PropertyChangedEventArgs args) =>
        PropertyChangedHandler?.Invoke(this, args);
}

public static class IReactiveObjectExtensions
{
    private static readonly ConditionalWeakTable<IReactiveObject, IExtensionState<IReactiveObject>> state = new();

    private interface IExtensionState<out TSender>
        where TSender : IReactiveObject
    {
        IObservable<IReactivePropertyChangedEventArgs<TSender>> Changed { get; }

        void SubscribePropertyChangedEvents();

        void RaisePropertyChanged(string propertyName);
    }

    public static void SubscribePropertyChangedEvents<TSender>(this TSender reactiveObject)
        where TSender : IReactiveObject
    {
        var s = state.GetValue(reactiveObject, _ => (IExtensionState<IReactiveObject>)new ExtensionState<TSender>(reactiveObject));

        s.SubscribePropertyChangedEvents();
    }

    private class ExtensionState<TSender> : IExtensionState<TSender>
        where TSender : IReactiveObject
    {
        private readonly TSender _sender;
        private readonly Lazy<(ISubject<IReactivePropertyChangedEventArgs<TSender>> subject, IObservable<IReactivePropertyChangedEventArgs<TSender>> observable)> _changed;
        private readonly Lazy<ISubject<ReactivePropertyChangedEventArgs<TSender>>> _propertyChanged;

        public ExtensionState(TSender sender)
        {
            _sender = sender;
            _changed = CreateLazyDelayableSubjectAndObservable();
            _propertyChanged = CreateLazyDelayableEventSubject<ReactivePropertyChangedEventArgs<TSender>>(_sender.RaisePropertyChanged);
        }

        public IObservable<IReactivePropertyChangedEventArgs<TSender>> Changed => _changed.Value.observable;

        public void SubscribePropertyChangedEvents() => _ = _propertyChanged.Value;

        public void RaisePropertyChanged(string propertyName)
        {
            if (!AreChangeNotificationsEnabled())
            {
                return;
            }

            var changed = new ReactivePropertyChangedEventArgs<TSender>(_sender, propertyName);
            if (_propertyChanged.IsValueCreated)
            {
                // Do not use NotifyObservable because event exceptions shouldn't be put in ThrownExceptions
                _propertyChanged.Value.OnNext(changed);
            }

            if (_changed.IsValueCreated)
            {
                NotifyObservable(_sender, changed, _changed.Value.subject);
            }
        }

        private void NotifyObservable<T>(TSender rxObj, T item, ISubject<T>? subject)
        {
            try
            {
                subject?.OnNext(item);
            }
            catch (Exception ex)
            {
                rxObj.Log().Error(ex, "ReactiveObject Subscriber threw exception");
                if (!_thrownExceptions.IsValueCreated)
                {
                    throw;
                }

                _thrownExceptions.Value.OnNext(ex);
            }
        }
    }
}

public static class IReactiveObjectExtensions
{
    public static TRet RaiseAndSetIfChanged<TObj, TRet>(
        this TObj reactiveObject,
        ref TRet backingField,
        TRet newValue,
        [CallerMemberName] string? propertyName = null)
        where TObj : IReactiveObject
    {
        if (propertyName is null)
        {
            throw new ArgumentNullException(nameof(propertyName));
        }

        if (EqualityComparer<TRet>.Default.Equals(backingField, newValue))
        {
            return newValue;
        }

        reactiveObject.RaisingPropertyChanging(propertyName);
        backingField = newValue;
        reactiveObject.RaisingPropertyChanged(propertyName);
        return newValue;
    }

    internal static void RaisingPropertyChanged<TSender>(this TSender reactiveObject, string propertyName)
        where TSender : IReactiveObject
    {
        if (propertyName is null)
        {
            throw new ArgumentNullException(nameof(propertyName));
        }

        var s = state.GetValue(reactiveObject, _ => (IExtensionState<IReactiveObject>)new ExtensionState<TSender>(reactiveObject));

        s.RaisePropertyChanged(propertyName);
    }
}

public partial class Visual : StyledElement
{
    public static readonly DirectProperty<Visual, Rect> BoundsProperty =
        AvaloniaProperty.RegisterDirect<Visual, Rect>(nameof(Bounds), o => o.Bounds);

    public Rect Bounds
    {
        get { return _bounds; }
        protected set { SetAndRaise(BoundsProperty, ref _bounds, value); }
    }
}

public class AvaloniaObject : IAvaloniaObjectDebug, INotifyPropertyChanged
{
    private PropertyChangedEventHandler? _inpcChanged;
    private EventHandler<AvaloniaPropertyChangedEventArgs>? _propertyChanged;

    public event EventHandler<AvaloniaPropertyChangedEventArgs>? PropertyChanged
    {
        add { _propertyChanged += value; }
        remove { _propertyChanged -= value; }
    }

    event PropertyChangedEventHandler? INotifyPropertyChanged.PropertyChanged
    {
        add { _inpcChanged += value; }
        remove { _inpcChanged -= value; }
    }

    internal void RaisePropertyChanged<T>(
        AvaloniaProperty<T> property,
        Optional<T> oldValue,
        BindingValue<T> newValue,
        BindingPriority priority,
        bool isEffectiveValue)
    {
        var e = new AvaloniaPropertyChangedEventArgs<T>(
            this,
            property,
            oldValue,
            newValue,
            priority,
            isEffectiveValue);

        OnPropertyChangedCore(e);

        if (isEffectiveValue)
        {
            property.NotifyChanged(e);
            _propertyChanged?.Invoke(this, e);
            _inpcChanged?.Invoke(this, new PropertyChangedEventArgs(property.Name));
        }
    }
}

public static class AvaloniaObjectExtensions
{
    public static IObservable<T> GetObservable<T>(this AvaloniaObject o, AvaloniaProperty<T> property);

    ublic static IObservable<TResult> GetObservable<TSource, TResult>(this AvaloniaObject o, AvaloniaProperty<TSource> property, Func<TSource, TResult> converter);

    public static IObservable<TResult> GetObservable<TResult>(this AvaloniaObject o, AvaloniaProperty property, Func<object?, TResult> converter);

    public static IObservable<AvaloniaPropertyChangedEventArgs> GetPropertyChangedObservable(
            this AvaloniaObject o,
            AvaloniaProperty property)
}

public abstract class AvaloniaProperty<TValue> : AvaloniaProperty
{
    public new IObservable<AvaloniaPropertyChangedEventArgs<TValue>> Changed { get; }
}

public struct Property<T>
{
    public T Get();
    public void Set(T value);

    public IObserveable<T> Changed { get; }
}

var person = new Person();

person.FirstName.Set("Alan");
person.LastName.Set("Turing");

var first = person.FirstName.Get();
var last = person.LastName.Get();

public class Person
{
    public Property<string?> FirstName { get; }
    public Property<string?> LastName { get; }
}

public class Person
{
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
}

// Prints "System.Action`1[System.String]"
Console.WriteLine(new Person().SetName);

public class Person
{
    private string? _name;

    public string? GetName() => _name;
    public void SetName(string? value) => _name = value;
}

// Prints "Property`1[System.String]"
Console.WriteLine(new Person().Name);

public class Person
{
    public Property<string?> Name { get; }
}

public struct Property<T>
{
    private T _value;

    public T Get() => _value;
    public void Set(T value) { /* set _value and notify observers */ }

    public IObserveable<T> Changed { get; }
}

public ref struct Property<T>
{
    private ref T _field;

    public T Get() => _field;
    public void Set(T value) { /* set _field and notify observers */ }

    public IObserveable<T> Changed { get; }
}

public abstract class ObservableObject
{
    private List<PropertyObservable> _observables = new();

    internal PropertyObservable<T> GetObservable<T>(ref T field)
    {
        var offset = Unsafe.ByteOffset(
            ref Unsafe.As<List<PropertyObservable>, IntPtr>(ref _observables),
            ref Unsafe.As<T, IntPtr>(ref field))
    
        foreach (var observable in _observables)
        {
            if (observable.Offset == offset)
                return observable;
        }

        var result = new PropertyObservable<T> { Offset = offset };

        _observables.Add(result);

        return result;
    }

    protected Property<T> Property<T>(ref T field) => new(this, ref field);
}

public ref struct Property<T>
{
    private readonly ObservableObject _owner;
    private ref T _field;

    internal Property(ObservableObject owner, ref T field)
    {
        _owner = owner;
        _field = ref field;
    }

    public T Get() => _field;

    public void Set(T value)
    {
        if (EqualityComparer<T>.Default.Equals(_field, value))
        {
            _field = value;
        }

        _field = value;
        _owner.GetObservable(ref _field).Changed(value);
    }

    public IObserveable<T> Changed => _owner.GetObservable(ref _field);
}

internal abstract class PropertyObservable
{
    public IntPtr Offset { get; required init; }
}

internal sealed class PropertyObservable<T> : PropertyObservable, IObservable<T>
{
    public void Changed(T value);

    public IDisposable Subscribe(IObserver<T> observer);
}

public class Person : ObservableObject
{
    private string? _name;

    public string? Name => Property(ref _name);
}

var person = new Person();

person.Name.Set("Duffy");

var name = person.Name.Get();
var changes = person.Name.Changed.Subscribe(v => Console.WriteLine(v));

public readonly struct Property<T>
{
    private readonly ObservableObject _owner;
    private readonly IntPtr _offset;

    internal Property(ObservableObject owner, IntPtr offset)
    {
        _owner = owner;
        _offset = offset;
    }

    public T Get() => _ownerOwner.Get<T>(_offset);

    public void Set(T value) => _owner.Set(_offset, value);

    public IObservable<T> Changed => _owner.GetObservable<T>(_offset);
}

private protected IntPtr GetOffsetOf<T>(ref T field)
{
    return Unsafe.ByteOffset(
        ref /* wait, we cannot get an instance address easily */,
        ref Unsafe.As<T, IntPtr>(ref field));
}

private protected IntPtr GetOffsetOf<T>(ref T field)
{
    return Unsafe.ByteOffset(
        ref GetReference(),
        ref Unsafe.As<T, IntPtr>(ref field));
}

private ref IntPtr GetReference() =>
    ref Unsafe.As<PropertyObservable?, IntPtr>(ref _observables);

private ref T GetReference<T>(IntPtr offset)
{
    ref var baseRef = ref GetReference();
    ref var valueRef = ref Unsafe.AddByteOffset(ref baseRef, offset);
    return ref Unsafe.As<IntPtr, T>(ref valueRef);
}

internal T Get<T>(IntPtr offset) =>
    GetReference<T>(offset);

internal void Set<T>(IntPtr offset, T value)
{
    if (EqualityComparer<T>.Default.Equals(value, Get<T>(offset)))
    {
        return;
    }

    GetReference<T>(offset) = value;
    GetObservable(ref _field).Changed(value);
}