Remove Default values from WhenAny dependents (#3967)

<!-- Please be sure to read the
[Contribute](https://github.com/reactiveui/reactiveui#contribute)
section of the README -->

**What kind of change does this PR introduce?**
<!-- Bug fix, feature, docs update, ... -->

update

**What is the current behavior?**
<!-- You can also link to an open issue here. -->

Default values are used which can lead to incorrect runtime operation

**What is the new behavior?**
<!-- If this is a feature change -->

Default Default values from ObservableForProperty
Remove Default values from SubscribeToExpressionChain

**What might this PR break?**

BREAKING CHANGE - ObservableForProperty and SubscribeToExpressionChain
no longer use default values
Any named default values will need to be removed, then an appropriate
overload selected

**Please check if the PR fulfills these requirements**
- [ ] Tests for the changes have been added (for bug fixes / features)
- [ ] Docs have been added / updated (for bug fixes / features)

**Other information**:

Author: ChrisPulman

src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.DotNet8_0.verified.txt

@@ -197,7 +197,7 @@ public void OFPNamedPropertyTestNoSkipInitial() =>
             {
                 IsOnlyOneWord = "Pre"
             };
-            fixture.ObservableForProperty(x => x.IsOnlyOneWord, skipInitial: false)
+            fixture.ObservableForProperty(x => x.IsOnlyOneWord, false, false)
                    .ToObservableChangeSet(ImmediateScheduler.Instance)
                    .Bind(out var changes)
                    .Subscribe();

src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.DotNet9_0.verified.txt

@@ -23,6 +23,75 @@ public static class ReactiveNotifyPropertyChangedMixin
 
     static ReactiveNotifyPropertyChangedMixin() => RxApp.EnsureInitialized();
 
+    /// <summary>
+    /// ObservableForProperty returns an Observable representing the
+    /// property change notifications for a specific property on a
+    /// ReactiveObject. This method (unlike other Observables that return
+    /// IObservedChange) guarantees that the Value property of
+    /// the IObservedChange is set.
+    /// </summary>
+    /// <typeparam name="TSender">The sender type.</typeparam>
+    /// <typeparam name="TValue">The value type.</typeparam>
+    /// <param name="item">The source object to observe properties of.</param>
+    /// <param name="property">An Expression representing the property (i.e.
+    /// 'x =&gt; x.SomeProperty.SomeOtherProperty'.</param>
+    /// <returns>
+    /// An Observable representing the property change
+    /// notifications for the given property.
+    /// </returns>
+    public static IObservable<IObservedChange<TSender, TValue>> ObservableForProperty<TSender, TValue>(
+        this TSender? item,
+        Expression<Func<TSender, TValue>> property) => ObservableForProperty(item, property, false, true, true);
+
+    /// <summary>
+    /// ObservableForProperty returns an Observable representing the
+    /// property change notifications for a specific property on a
+    /// ReactiveObject. This method (unlike other Observables that return
+    /// IObservedChange) guarantees that the Value property of
+    /// the IObservedChange is set.
+    /// </summary>
+    /// <typeparam name="TSender">The sender type.</typeparam>
+    /// <typeparam name="TValue">The value type.</typeparam>
+    /// <param name="item">The source object to observe properties of.</param>
+    /// <param name="property">An Expression representing the property (i.e.
+    /// 'x =&gt; x.SomeProperty.SomeOtherProperty'.</param>
+    /// <param name="beforeChange">If True, the Observable will notify
+    /// immediately before a property is going to change.</param>
+    /// <returns>
+    /// An Observable representing the property change
+    /// notifications for the given property.
+    /// </returns>
+    public static IObservable<IObservedChange<TSender, TValue>> ObservableForProperty<TSender, TValue>(
+        this TSender? item,
+        Expression<Func<TSender, TValue>> property,
+        bool beforeChange) => ObservableForProperty(item, property, beforeChange, true, true);
+
+    /// <summary>
+    /// ObservableForProperty returns an Observable representing the
+    /// property change notifications for a specific property on a
+    /// ReactiveObject. This method (unlike other Observables that return
+    /// IObservedChange) guarantees that the Value property of
+    /// the IObservedChange is set.
+    /// </summary>
+    /// <typeparam name="TSender">The sender type.</typeparam>
+    /// <typeparam name="TValue">The value type.</typeparam>
+    /// <param name="item">The source object to observe properties of.</param>
+    /// <param name="property">An Expression representing the property (i.e.
+    /// 'x =&gt; x.SomeProperty.SomeOtherProperty'.</param>
+    /// <param name="beforeChange">If True, the Observable will notify
+    /// immediately before a property is going to change.</param>
+    /// <param name="skipInitial">If true, the Observable will not notify
+    /// with the initial value.</param>
+    /// <returns>
+    /// An Observable representing the property change
+    /// notifications for the given property.
+    /// </returns>
+    public static IObservable<IObservedChange<TSender, TValue>> ObservableForProperty<TSender, TValue>(
+        this TSender? item,
+        Expression<Func<TSender, TValue>> property,
+        bool beforeChange,
+        bool skipInitial) => ObservableForProperty(item, property, beforeChange, skipInitial, true);
+
     /// <summary>
     /// ObservableForProperty returns an Observable representing the
     /// property change notifications for a specific property on a
@@ -47,9 +116,9 @@ public static class ReactiveNotifyPropertyChangedMixin
     public static IObservable<IObservedChange<TSender, TValue>> ObservableForProperty<TSender, TValue>(
         this TSender? item,
         Expression<Func<TSender, TValue>> property,
-        bool beforeChange = false,
-        bool skipInitial = true,
-        bool isDistinct = true)
+        bool beforeChange,
+        bool skipInitial,
+        bool isDistinct)
     {
         property.ArgumentNullExceptionThrowIfNull(nameof(property));
 
@@ -76,6 +145,34 @@ public static IObservable<IObservedChange<TSender, TValue>> ObservableForPropert
                                                            isDistinct);
     }
 
+    /// <summary>
+    /// ObservableForProperty returns an Observable representing the
+    /// property change notifications for a specific property on a
+    /// ReactiveObject, running the IObservedChange through a Selector
+    /// function.
+    /// </summary>
+    /// <typeparam name="TSender">The sender type.</typeparam>
+    /// <typeparam name="TValue">The value type.</typeparam>
+    /// <typeparam name="TRet">The return value type.</typeparam>
+    /// <param name="item">The source object to observe properties of.</param>
+    /// <param name="property">An Expression representing the property (i.e.
+    /// 'x => x.SomeProperty'.</param>
+    /// <param name="selector">A Select function that will be run on each
+    /// item.</param>
+    /// <returns>An Observable representing the property change
+    /// notifications for the given property.</returns>
+    public static IObservable<TRet> ObservableForProperty<TSender, TValue, TRet>(
+        this TSender? item,
+        Expression<Func<TSender, TValue>> property,
+        Func<TValue?, TRet> selector) // TODO: Create Test
+        where TSender : class
+    {
+        property.ArgumentNullExceptionThrowIfNull(nameof(property));
+        selector.ArgumentNullExceptionThrowIfNull(nameof(selector));
+
+        return item.ObservableForProperty(property, false).Select(x => selector(x.Value));
+    }
+
     /// <summary>
     /// ObservableForProperty returns an Observable representing the
     /// property change notifications for a specific property on a
@@ -98,7 +195,7 @@ public static IObservable<TRet> ObservableForProperty<TSender, TValue, TRet>(
         this TSender? item,
         Expression<Func<TSender, TValue>> property,
         Func<TValue?, TRet> selector,
-        bool beforeChange = false) // TODO: Create Test
+        bool beforeChange) // TODO: Create Test
         where TSender : class
     {
         property.ArgumentNullExceptionThrowIfNull(nameof(property));
@@ -107,6 +204,90 @@ public static IObservable<TRet> ObservableForProperty<TSender, TValue, TRet>(
         return item.ObservableForProperty(property, beforeChange).Select(x => selector(x.Value));
     }
 
+    /// <summary>
+    /// Creates a observable which will subscribe to the each property and sub property
+    /// specified in the Expression. eg It will subscribe to x =&gt; x.Property1.Property2.Property3
+    /// each property in the lambda expression. It will then provide updates to the last value in the chain.
+    /// </summary>
+    /// <typeparam name="TSender">The type of the origin of the expression chain.</typeparam>
+    /// <typeparam name="TValue">The end value we want to subscribe to.</typeparam>
+    /// <param name="source">The object where we start the chain.</param>
+    /// <param name="expression">A expression which will point towards the property.</param>
+    /// <returns>
+    /// A observable which notifies about observed changes.
+    /// </returns>
+    /// <exception cref="InvalidCastException">If we cannot cast from the target value from the specified last property.</exception>
+    public static IObservable<IObservedChange<TSender, TValue>> SubscribeToExpressionChain<TSender, TValue>(
+        this TSender? source,
+        Expression? expression) // TODO: Create Test
+            => SubscribeToExpressionChain<TSender, TValue>(source, expression, false, true, false, true);
+
+    /// <summary>
+    /// Creates a observable which will subscribe to the each property and sub property
+    /// specified in the Expression. eg It will subscribe to x =&gt; x.Property1.Property2.Property3
+    /// each property in the lambda expression. It will then provide updates to the last value in the chain.
+    /// </summary>
+    /// <typeparam name="TSender">The type of the origin of the expression chain.</typeparam>
+    /// <typeparam name="TValue">The end value we want to subscribe to.</typeparam>
+    /// <param name="source">The object where we start the chain.</param>
+    /// <param name="expression">A expression which will point towards the property.</param>
+    /// <param name="beforeChange">If we are interested in notifications before the property value is changed.</param>
+    /// <returns>
+    /// A observable which notifies about observed changes.
+    /// </returns>
+    /// <exception cref="InvalidCastException">If we cannot cast from the target value from the specified last property.</exception>
+    public static IObservable<IObservedChange<TSender, TValue>> SubscribeToExpressionChain<TSender, TValue>(
+        this TSender? source,
+        Expression? expression,
+        bool beforeChange) // TODO: Create Test
+            => SubscribeToExpressionChain<TSender, TValue>(source, expression, beforeChange, true, false, true);
+
+    /// <summary>
+    /// Creates a observable which will subscribe to the each property and sub property
+    /// specified in the Expression. eg It will subscribe to x =&gt; x.Property1.Property2.Property3
+    /// each property in the lambda expression. It will then provide updates to the last value in the chain.
+    /// </summary>
+    /// <typeparam name="TSender">The type of the origin of the expression chain.</typeparam>
+    /// <typeparam name="TValue">The end value we want to subscribe to.</typeparam>
+    /// <param name="source">The object where we start the chain.</param>
+    /// <param name="expression">A expression which will point towards the property.</param>
+    /// <param name="beforeChange">If we are interested in notifications before the property value is changed.</param>
+    /// <param name="skipInitial">If we don't want to get a notification about the default value of the property.</param>
+    /// <returns>
+    /// A observable which notifies about observed changes.
+    /// </returns>
+    /// <exception cref="InvalidCastException">If we cannot cast from the target value from the specified last property.</exception>
+    public static IObservable<IObservedChange<TSender, TValue>> SubscribeToExpressionChain<TSender, TValue>(
+        this TSender? source,
+        Expression? expression,
+        bool beforeChange,
+        bool skipInitial) // TODO: Create Test
+            => SubscribeToExpressionChain<TSender, TValue>(source, expression, beforeChange, skipInitial, false, true);
+
+    /// <summary>
+    /// Creates a observable which will subscribe to the each property and sub property
+    /// specified in the Expression. eg It will subscribe to x =&gt; x.Property1.Property2.Property3
+    /// each property in the lambda expression. It will then provide updates to the last value in the chain.
+    /// </summary>
+    /// <typeparam name="TSender">The type of the origin of the expression chain.</typeparam>
+    /// <typeparam name="TValue">The end value we want to subscribe to.</typeparam>
+    /// <param name="source">The object where we start the chain.</param>
+    /// <param name="expression">A expression which will point towards the property.</param>
+    /// <param name="beforeChange">If we are interested in notifications before the property value is changed.</param>
+    /// <param name="skipInitial">If we don't want to get a notification about the default value of the property.</param>
+    /// <param name="suppressWarnings">If true, no warnings should be logged.</param>
+    /// <returns>
+    /// A observable which notifies about observed changes.
+    /// </returns>
+    /// <exception cref="InvalidCastException">If we cannot cast from the target value from the specified last property.</exception>
+    public static IObservable<IObservedChange<TSender, TValue>> SubscribeToExpressionChain<TSender, TValue>(
+        this TSender? source,
+        Expression? expression,
+        bool beforeChange,
+        bool skipInitial,
+        bool suppressWarnings) // TODO: Create Test
+            => SubscribeToExpressionChain<TSender, TValue>(source, expression, beforeChange, skipInitial, suppressWarnings, true);
+
     /// <summary>
     /// Creates a observable which will subscribe to the each property and sub property
     /// specified in the Expression. eg It will subscribe to x =&gt; x.Property1.Property2.Property3
@@ -127,10 +308,10 @@ public static IObservable<TRet> ObservableForProperty<TSender, TValue, TRet>(
     public static IObservable<IObservedChange<TSender, TValue>> SubscribeToExpressionChain<TSender, TValue>(
         this TSender? source,
         Expression? expression,
-        bool beforeChange = false,
-        bool skipInitial = true,
-        bool suppressWarnings = false,
-        bool isDistinct = true) // TODO: Create Test
+        bool beforeChange,
+        bool skipInitial,
+        bool suppressWarnings,
+        bool isDistinct) // TODO: Create Test
     {
         IObservable<IObservedChange<object?, object?>> notifier =
             Observable.Return(new ObservedChange<object?, object?>(null, null, source));