Selaa lähdekoodia

Merge pull request #378 from Reactive-Extensions/FixXmlDocs

Fixing XML doc comments
Bart J.F. De Smet 8 vuotta sitten
vanhempi
sitoutus
ae1ce3bbf5

+ 108 - 108
Rx.NET/Source/src/System.Reactive/Linq/Observable.Aggregates.cs

@@ -147,9 +147,9 @@ namespace System.Reactive.Linq
         #region + Average +
 
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Double" /> values.
+        /// Computes the average of an observable sequence of <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Double" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of <see cref="double" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
@@ -163,9 +163,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Single" /> values.
+        /// Computes the average of an observable sequence of <see cref="float" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Single" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of <see cref="float" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
@@ -196,9 +196,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Int32" /> values.
+        /// Computes the average of an observable sequence of <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int32" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of <see cref="int" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
@@ -213,9 +213,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Int64" /> values.
+        /// Computes the average of an observable sequence of <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int64" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of <see cref="long" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
@@ -230,9 +230,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Double" /> values.
+        /// Computes the average of an observable sequence of nullable <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Double" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of nullable <see cref="double" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
@@ -246,9 +246,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Single" /> values.
+        /// Computes the average of an observable sequence of nullable <see cref="float" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Single" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of nullable <see cref="float" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
@@ -279,9 +279,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Int32" /> values.
+        /// Computes the average of an observable sequence of nullable <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int32" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of nullable <see cref="int" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
@@ -296,9 +296,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Int64" /> values.
+        /// Computes the average of an observable sequence of nullable <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int64" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of nullable <see cref="long" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
@@ -334,7 +334,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Double" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -354,7 +354,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Single" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of <see cref="float" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -374,7 +374,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Int32" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of <see cref="int" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -395,7 +395,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Int64" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -437,7 +437,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Double" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of nullable <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -457,7 +457,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Single" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of nullable <see cref="float" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -477,7 +477,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Int32" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of nullable <see cref="int" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -498,7 +498,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Int64" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of nullable <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -564,7 +564,7 @@ namespace System.Reactive.Linq
         #region + Count +
 
         /// <summary>
-        /// Returns an observable sequence containing an <see cref="Int32" /> that represents the total number of elements in an observable sequence.
+        /// Returns an observable sequence containing an <see cref="int" /> that represents the total number of elements in an observable sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">An observable sequence that contains elements to be counted.</param>
@@ -581,7 +581,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns an observable sequence containing an <see cref="Int32" /> that represents how many elements in the specified observable sequence satisfy a condition.
+        /// Returns an observable sequence containing an <see cref="int" /> that represents how many elements in the specified observable sequence satisfy a condition.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">An observable sequence that contains elements to be counted.</param>
@@ -822,7 +822,7 @@ namespace System.Reactive.Linq
         #region + LongCount +
 
         /// <summary>
-        /// Returns an observable sequence containing an <see cref="Int64" /> that represents the total number of elements in an observable sequence.
+        /// Returns an observable sequence containing an <see cref="long" /> that represents the total number of elements in an observable sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">An observable sequence that contains elements to be counted.</param>
@@ -839,7 +839,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns an observable sequence containing an <see cref="Int64" /> that represents how many elements in the specified observable sequence satisfy a condition.
+        /// Returns an observable sequence containing an <see cref="long" /> that represents how many elements in the specified observable sequence satisfy a condition.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">An observable sequence that contains elements to be counted.</param>
@@ -897,9 +897,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the maximum value in an observable sequence of <see cref="Double" /> values.
+        /// Returns the maximum value in an observable sequence of <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Double" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of <see cref="double" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -912,9 +912,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the maximum value in an observable sequence of <see cref="Single" /> values.
+        /// Returns the maximum value in an observable sequence of <see cref="float" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Single" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of <see cref="float" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -942,9 +942,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the maximum value in an observable sequence of <see cref="Int32" /> values.
+        /// Returns the maximum value in an observable sequence of <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int32" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of <see cref="int" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -957,9 +957,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the maximum value in an observable sequence of <see cref="Int64" /> values.
+        /// Returns the maximum value in an observable sequence of <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int64" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of <see cref="long" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -972,9 +972,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the maximum value in an observable sequence of nullable <see cref="Double" /> values.
+        /// Returns the maximum value in an observable sequence of nullable <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Double" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="double" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -987,9 +987,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the maximum value in an observable sequence of nullable <see cref="Single" /> values.
+        /// Returns the maximum value in an observable sequence of nullable <see cref="float" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Single" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="float" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1017,9 +1017,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the maximum value in an observable sequence of nullable <see cref="Int32" /> values.
+        /// Returns the maximum value in an observable sequence of nullable <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int32" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="int" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1032,9 +1032,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the maximum value in an observable sequence of nullable <see cref="Int64" /> values.
+        /// Returns the maximum value in an observable sequence of nullable <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int64" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="long" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1090,12 +1090,12 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="Double" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="double" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Double" /> that corresponds to the maximum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="double" /> that corresponds to the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         public static IObservable<double> Max<TSource>(this IObservable<TSource> source, Func<TSource, double> selector)
@@ -1109,12 +1109,12 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="Single" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="float" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Single" /> that corresponds to the maximum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="float" /> that corresponds to the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         public static IObservable<float> Max<TSource>(this IObservable<TSource> source, Func<TSource, float> selector)
@@ -1147,12 +1147,12 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="Int32" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="int" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Int32" /> that corresponds to the maximum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="int" /> that corresponds to the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         public static IObservable<int> Max<TSource>(this IObservable<TSource> source, Func<TSource, int> selector)
@@ -1166,12 +1166,12 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="Int64" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="long" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Int64" /> that corresponds to the maximum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="long" /> that corresponds to the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         public static IObservable<long> Max<TSource>(this IObservable<TSource> source, Func<TSource, long> selector)
@@ -1185,7 +1185,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="Double" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="double" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
@@ -1204,7 +1204,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="Single" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="float" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
@@ -1242,7 +1242,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="Int32" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="int" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
@@ -1261,7 +1261,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="Int64" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="long" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
@@ -1366,9 +1366,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the minimum value in an observable sequence of <see cref="Double" /> values.
+        /// Returns the minimum value in an observable sequence of <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Double" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of <see cref="double" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1381,9 +1381,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the minimum value in an observable sequence of <see cref="Single" /> values.
+        /// Returns the minimum value in an observable sequence of <see cref="float" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Single" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of <see cref="float" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1411,9 +1411,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the minimum value in an observable sequence of <see cref="Int32" /> values.
+        /// Returns the minimum value in an observable sequence of <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int32" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of <see cref="int" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1426,9 +1426,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the minimum value in an observable sequence of <see cref="Int64" /> values.
+        /// Returns the minimum value in an observable sequence of <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int64" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of <see cref="long" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1441,9 +1441,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the minimum value in an observable sequence of nullable <see cref="Double" /> values.
+        /// Returns the minimum value in an observable sequence of nullable <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Double" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="double" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1456,9 +1456,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the minimum value in an observable sequence of nullable <see cref="Single" /> values.
+        /// Returns the minimum value in an observable sequence of nullable <see cref="float" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Single" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="float" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1486,9 +1486,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the minimum value in an observable sequence of nullable <see cref="Int32" /> values.
+        /// Returns the minimum value in an observable sequence of nullable <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int32" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="int" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1501,9 +1501,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Returns the minimum value in an observable sequence of nullable <see cref="Int64" /> values.
+        /// Returns the minimum value in an observable sequence of nullable <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int64" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="long" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1559,12 +1559,12 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="Double" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="double" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Double" /> that corresponds to the minimum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="double" /> that corresponds to the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         public static IObservable<double> Min<TSource>(this IObservable<TSource> source, Func<TSource, double> selector)
@@ -1578,12 +1578,12 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="Single" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="float" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Single" /> that corresponds to the minimum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="float" /> that corresponds to the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         public static IObservable<float> Min<TSource>(this IObservable<TSource> source, Func<TSource, float> selector)
@@ -1616,12 +1616,12 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="Int32" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="int" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Int32" /> that corresponds to the minimum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="int" /> that corresponds to the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         public static IObservable<int> Min<TSource>(this IObservable<TSource> source, Func<TSource, int> selector)
@@ -1635,12 +1635,12 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="Int64" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="long" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Int64" /> that corresponds to the minimum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="long" /> that corresponds to the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         public static IObservable<long> Min<TSource>(this IObservable<TSource> source, Func<TSource, long> selector)
@@ -1654,7 +1654,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="Double" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="double" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
@@ -1673,7 +1673,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="Single" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="float" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
@@ -1711,7 +1711,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="Int32" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="int" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
@@ -1730,7 +1730,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="Int64" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="long" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
@@ -1964,9 +1964,9 @@ namespace System.Reactive.Linq
         #region + Sum +
 
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Double" /> values.
+        /// Computes the sum of a sequence of <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Double" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of <see cref="double" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -1979,9 +1979,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Single" /> values.
+        /// Computes the sum of a sequence of <see cref="float" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Single" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of <see cref="float" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -2010,9 +2010,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Int32" /> values.
+        /// Computes the sum of a sequence of <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int32" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of <see cref="int" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="OverflowException">(Asynchronous) The sum of the elements in the source sequence is larger than <see cref="Int32.MaxValue"/>.</exception>
@@ -2026,9 +2026,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Int64" /> values.
+        /// Computes the sum of a sequence of <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int64" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of <see cref="long" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="OverflowException">(Asynchronous) The sum of the elements in the source sequence is larger than <see cref="Int64.MaxValue"/>.</exception>
@@ -2042,9 +2042,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Double" /> values.
+        /// Computes the sum of a sequence of nullable <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Double" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of nullable <see cref="double" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -2057,9 +2057,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Single" /> values.
+        /// Computes the sum of a sequence of nullable <see cref="float" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Single" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of nullable <see cref="float" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -2088,9 +2088,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Int32" /> values.
+        /// Computes the sum of a sequence of nullable <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int32" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of nullable <see cref="int" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="OverflowException">(Asynchronous) The sum of the elements in the source sequence is larger than <see cref="Int32.MaxValue"/>.</exception>
@@ -2104,9 +2104,9 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Int64" /> values.
+        /// Computes the sum of a sequence of nullable <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int64" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of nullable <see cref="long" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         /// <exception cref="OverflowException">(Asynchronous) The sum of the elements in the source sequence is larger than <see cref="Int64.MaxValue"/>.</exception>
@@ -2120,7 +2120,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Double" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -2139,7 +2139,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Single" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of <see cref="float" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -2178,7 +2178,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Int32" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of <see cref="int" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -2198,7 +2198,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Int64" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -2218,7 +2218,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Double" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of nullable <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -2237,7 +2237,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Single" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of nullable <see cref="float" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -2276,7 +2276,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Int32" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of nullable <see cref="int" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -2296,7 +2296,7 @@ namespace System.Reactive.Linq
         }
 
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Int64" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of nullable <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>

+ 129 - 129
Rx.NET/Source/src/System.Reactive/Linq/Qbservable.Generated.cs

@@ -61,7 +61,7 @@ namespace System.Reactive.Linq
 
         /// <summary>
         /// Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value.
-        /// For aggregation behavior with incremental intermediate results, see <see cref="Observable.Scan{TSource, TAccumulate}(IObservable{TAccumulate},TAccumulate,Func{TAccumulate,TSource,TAccumulate})" />.
+        /// For aggregation behavior with incremental intermediate results, see <see cref="Observable.Scan{TSource, TAccumulate}(IObservable{TSource}, TAccumulate, Func{TAccumulate, TSource, TAccumulate})" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TAccumulate">The type of the result of the aggregation.</typeparam>
@@ -342,9 +342,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Double" /> values.
+        /// Computes the average of an observable sequence of <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Double" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of <see cref="double" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -369,9 +369,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Int32" /> values.
+        /// Computes the average of an observable sequence of <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int32" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of <see cref="int" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -397,9 +397,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Int64" /> values.
+        /// Computes the average of an observable sequence of <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int64" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of <see cref="long" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -453,9 +453,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Double" /> values.
+        /// Computes the average of an observable sequence of nullable <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Double" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of nullable <see cref="double" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -480,9 +480,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Int32" /> values.
+        /// Computes the average of an observable sequence of nullable <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int32" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of nullable <see cref="int" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -508,9 +508,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Int64" /> values.
+        /// Computes the average of an observable sequence of nullable <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int64" /> values to calculate the average of.</param>
+        /// <param name="source">A sequence of nullable <see cref="long" /> values to calculate the average of.</param>
         /// <returns>An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -623,7 +623,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Double" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -687,7 +687,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Int32" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of <see cref="int" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -720,7 +720,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of <see cref="Int64" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -786,7 +786,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Double" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of nullable <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -850,7 +850,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Int32" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of nullable <see cref="int" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -883,7 +883,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the average of an observable sequence of nullable <see cref="Int64" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an observable sequence of nullable <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -3051,7 +3051,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns an observable sequence containing an <see cref="Int32" /> that represents the total number of elements in an observable sequence.
+        /// Returns an observable sequence containing an <see cref="int" /> that represents the total number of elements in an observable sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">An observable sequence that contains elements to be counted.</param>
@@ -3079,7 +3079,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns an observable sequence containing an <see cref="Int32" /> that represents how many elements in the specified observable sequence satisfy a condition.
+        /// Returns an observable sequence containing an <see cref="int" /> that represents how many elements in the specified observable sequence satisfy a condition.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">An observable sequence that contains elements to be counted.</param>
@@ -3108,7 +3108,7 @@ namespace System.Reactive.Linq
                 )
             );
         }
-        
+
         /// <summary>
         /// Creates an observable sequence from a specified Subscribe method implementation.
         /// </summary>
@@ -3121,7 +3121,7 @@ namespace System.Reactive.Linq
         /// <remarks>
         /// Use of this operator is preferred over manual implementation of the <see cref="IObservable{T}"/> interface. In case
         /// you need a type implementing <see cref="IObservable{T}"/> rather than an anonymous implementation, consider using
-        /// the <see cref="Reactive.ObservableBase`1" /> abstract base class.
+        /// the <see cref="Reactive.ObservableBase{TResult}" /> abstract base class.
         /// </remarks>
         public static IQbservable<TResult> Create<TResult>(this IQbservableProvider provider, Expression<Func<IObserver<TResult>, IDisposable>> subscribe)
         {
@@ -3143,7 +3143,7 @@ namespace System.Reactive.Linq
                 )
             );
         }
-        
+
         /// <summary>
         /// Creates an observable sequence from a specified Subscribe method implementation.
         /// </summary>
@@ -3156,7 +3156,7 @@ namespace System.Reactive.Linq
         /// <remarks>
         /// Use of this operator is preferred over manual implementation of the <see cref="IObservable{T}"/> interface. In case
         /// you need a type implementing <see cref="IObservable{T}"/> rather than an anonymous implementation, consider using
-        /// the <see cref="Reactive.ObservableBase`1" /> abstract base class.
+        /// the <see cref="Reactive.ObservableBase{TResult}" /> abstract base class.
         /// </remarks>
         public static IQbservable<TResult> Create<TResult>(this IQbservableProvider provider, Expression<Func<IObserver<TResult>, Action>> subscribe)
         {
@@ -5023,7 +5023,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEvent, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEvent, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -5133,7 +5133,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEvent, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEvent, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -5246,7 +5246,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEvent, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEvent, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -5364,7 +5364,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEvent, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEvent, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -5474,7 +5474,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -5586,7 +5586,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -5700,7 +5700,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -5814,7 +5814,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -5908,9 +5908,9 @@ namespace System.Reactive.Linq
                 )
             );
         }
-        
+
         /// <summary>
-        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler`1" />, to an observable sequence.
+        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler{TEventArgs}" />, to an observable sequence.
         /// Each event invocation is surfaced through an OnNext message in the resulting sequence.
         /// For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.
         /// </summary>
@@ -5929,7 +5929,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -5971,7 +5971,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler`1" />, to an observable sequence.
+        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler{TEventArgs}" />, to an observable sequence.
         /// Each event invocation is surfaced through an OnNext message in the resulting sequence.
         /// For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.
         /// </summary>
@@ -6051,7 +6051,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -6148,7 +6148,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler`1" />, to an observable sequence.
+        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler{TEventArgs}" />, to an observable sequence.
         /// Each event invocation is surfaced through an OnNext message in the resulting sequence.
         /// For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.
         /// </summary>
@@ -6163,7 +6163,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -6202,7 +6202,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler`1" />, to an observable sequence.
+        /// Converts a .NET event, conforming to the standard .NET event pattern based on <see cref="EventHandler{TEventArgs}" />, to an observable sequence.
         /// Each event invocation is surfaced through an OnNext message in the resulting sequence.
         /// For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead.
         /// </summary>
@@ -6275,7 +6275,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -6391,7 +6391,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -6508,7 +6508,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -6626,7 +6626,7 @@ namespace System.Reactive.Linq
         /// As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting.
         /// </para>
         /// <para>
-        /// The current <see cref="Threading.SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
+        /// The current <see cref="SynchronizationContext" /> is captured during the call to FromEventPattern, and is used to post add and remove handler invocations.
         /// This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks.
         /// </para>
         /// <para>
@@ -8147,7 +8147,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns an observable sequence containing an <see cref="Int64" /> that represents the total number of elements in an observable sequence.
+        /// Returns an observable sequence containing an <see cref="long" /> that represents the total number of elements in an observable sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">An observable sequence that contains elements to be counted.</param>
@@ -8175,7 +8175,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns an observable sequence containing an <see cref="Int64" /> that represents how many elements in the specified observable sequence satisfy a condition.
+        /// Returns an observable sequence containing an <see cref="long" /> that represents how many elements in the specified observable sequence satisfy a condition.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">An observable sequence that contains elements to be counted.</param>
@@ -8258,9 +8258,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the maximum value in an observable sequence of <see cref="Double" /> values.
+        /// Returns the maximum value in an observable sequence of <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Double" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of <see cref="double" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -8284,9 +8284,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the maximum value in an observable sequence of <see cref="Int32" /> values.
+        /// Returns the maximum value in an observable sequence of <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int32" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of <see cref="int" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -8310,9 +8310,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the maximum value in an observable sequence of <see cref="Int64" /> values.
+        /// Returns the maximum value in an observable sequence of <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int64" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of <see cref="long" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -8362,9 +8362,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the maximum value in an observable sequence of nullable <see cref="Double" /> values.
+        /// Returns the maximum value in an observable sequence of nullable <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Double" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="double" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -8388,9 +8388,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the maximum value in an observable sequence of nullable <see cref="Int32" /> values.
+        /// Returns the maximum value in an observable sequence of nullable <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int32" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="int" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -8414,9 +8414,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the maximum value in an observable sequence of nullable <see cref="Int64" /> values.
+        /// Returns the maximum value in an observable sequence of nullable <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int64" /> values to determine the maximum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="long" /> values to determine the maximum value of.</param>
         /// <returns>An observable sequence containing a single element with the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -8581,12 +8581,12 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="Int32" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="int" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Int32" /> that corresponds to the maximum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="int" /> that corresponds to the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -8612,12 +8612,12 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="Int64" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="long" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Int64" /> that corresponds to the maximum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="long" /> that corresponds to the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -8643,7 +8643,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="Double" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="double" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
@@ -8736,7 +8736,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="Int32" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="int" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
@@ -8767,7 +8767,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="Int64" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum nullable <see cref="long" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
@@ -8798,12 +8798,12 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="Double" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the maximum <see cref="double" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the maximum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Double" /> that corresponds to the maximum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="double" /> that corresponds to the maximum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -9369,9 +9369,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the minimum value in an observable sequence of <see cref="Double" /> values.
+        /// Returns the minimum value in an observable sequence of <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Double" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of <see cref="double" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -9395,9 +9395,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the minimum value in an observable sequence of <see cref="Int32" /> values.
+        /// Returns the minimum value in an observable sequence of <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int32" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of <see cref="int" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -9421,9 +9421,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the minimum value in an observable sequence of <see cref="Int64" /> values.
+        /// Returns the minimum value in an observable sequence of <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int64" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of <see cref="long" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -9473,9 +9473,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the minimum value in an observable sequence of nullable <see cref="Double" /> values.
+        /// Returns the minimum value in an observable sequence of nullable <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Double" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="double" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -9499,9 +9499,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the minimum value in an observable sequence of nullable <see cref="Int32" /> values.
+        /// Returns the minimum value in an observable sequence of nullable <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int32" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="int" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -9525,9 +9525,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Returns the minimum value in an observable sequence of nullable <see cref="Int64" /> values.
+        /// Returns the minimum value in an observable sequence of nullable <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int64" /> values to determine the minimum value of.</param>
+        /// <param name="source">A sequence of nullable <see cref="long" /> values to determine the minimum value of.</param>
         /// <returns>An observable sequence containing a single element with the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -9661,12 +9661,12 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="Double" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="double" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Double" /> that corresponds to the minimum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="double" /> that corresponds to the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -9754,12 +9754,12 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="Int32" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="int" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Int32" /> that corresponds to the minimum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="int" /> that corresponds to the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -9785,12 +9785,12 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="Int64" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum <see cref="long" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
-        /// <returns>An observable sequence containing a single element with the value of type <see cref="Int64" /> that corresponds to the minimum value in the source sequence.</returns>
+        /// <returns>An observable sequence containing a single element with the value of type <see cref="long" /> that corresponds to the minimum value in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
@@ -9816,7 +9816,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="Double" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="double" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
@@ -9909,7 +9909,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="Int32" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="int" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
@@ -9940,7 +9940,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="Int64" /> value.
+        /// Invokes a transform function on each element of a sequence and returns the minimum nullable <see cref="long" /> value.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to determine the minimum value of.</param>
@@ -10438,7 +10438,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence.
-        /// This operator is a specialization of Multicast using a regular <see cref="Reactive.Subjects.Subject`1" />.
+        /// This operator is a specialization of Multicast using a regular <see cref="Reactive.Subjects.Subject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -10447,7 +10447,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
-        /// <seealso cref="Reactive.Subjects.Subject`1" />
+        /// <seealso cref="Reactive.Subjects.Subject{TResult}" />
         public static IQbservable<TResult> Publish<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector)
         {
             if (source == null)
@@ -10471,7 +10471,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
-        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.BehaviorSubject`1" />.
+        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.BehaviorSubject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -10481,7 +10481,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
-        /// <seealso cref="Reactive.Subjects.BehaviorSubject`1" />
+        /// <seealso cref="Reactive.Subjects.BehaviorSubject{TResult}" />
         public static IQbservable<TResult> Publish<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector, TSource initialValue)
         {
             if (source == null)
@@ -10506,7 +10506,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification.
-        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.AsyncSubject`1" />.
+        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.AsyncSubject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -10515,7 +10515,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
-        /// <seealso cref="Reactive.Subjects.AsyncSubject`1" />
+        /// <seealso cref="Reactive.Subjects.AsyncSubject{TResult}" />
         public static IQbservable<TResult> PublishLast<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector)
         {
             if (source == null)
@@ -10813,7 +10813,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications.
-        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject`1" />.
+        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -10822,7 +10822,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
-        /// <seealso cref="Reactive.Subjects.ReplaySubject`1" />
+        /// <seealso cref="Reactive.Subjects.ReplaySubject{TResult}" />
         public static IQbservable<TResult> Replay<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector)
         {
             if (source == null)
@@ -10846,7 +10846,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject`1" />.
+        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -10858,7 +10858,7 @@ namespace System.Reactive.Linq
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException">
         /// <paramref name="bufferSize" /> is less than zero.</exception>
-        /// <seealso cref="Reactive.Subjects.ReplaySubject`1" />
+        /// <seealso cref="Reactive.Subjects.ReplaySubject{TResult}" />
         public static IQbservable<TResult> Replay<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector, int bufferSize)
         {
             if (source == null)
@@ -10883,7 +10883,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject`1" />.
+        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -10896,7 +10896,7 @@ namespace System.Reactive.Linq
         /// <paramref name="source" /> or <paramref name="selector" /> or <paramref name="scheduler" /> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException">
         /// <paramref name="bufferSize" /> is less than zero.</exception>
-        /// <seealso cref="Reactive.Subjects.ReplaySubject`1" />
+        /// <seealso cref="Reactive.Subjects.ReplaySubject{TResult}" />
         public static IQbservable<TResult> Replay<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector, int bufferSize, IScheduler scheduler)
         {
             if (source == null)
@@ -10924,7 +10924,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject`1" />.
+        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -10939,7 +10939,7 @@ namespace System.Reactive.Linq
         /// <paramref name="bufferSize" /> is less than zero.</exception>
         /// <exception cref="ArgumentOutOfRangeException">
         /// <paramref name="window" /> is less than TimeSpan.Zero.</exception>
-        /// <seealso cref="Reactive.Subjects.ReplaySubject`1" />
+        /// <seealso cref="Reactive.Subjects.ReplaySubject{TResult}" />
         public static IQbservable<TResult> Replay<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector, int bufferSize, TimeSpan window)
         {
             if (source == null)
@@ -10965,7 +10965,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject`1" />.
+        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -10981,7 +10981,7 @@ namespace System.Reactive.Linq
         /// <paramref name="bufferSize" /> is less than zero.</exception>
         /// <exception cref="ArgumentOutOfRangeException">
         /// <paramref name="window" /> is less than TimeSpan.Zero.</exception>
-        /// <seealso cref="Reactive.Subjects.ReplaySubject`1" />
+        /// <seealso cref="Reactive.Subjects.ReplaySubject{TResult}" />
         public static IQbservable<TResult> Replay<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector, int bufferSize, TimeSpan window, IScheduler scheduler)
         {
             if (source == null)
@@ -11010,7 +11010,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications.
-        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject`1" />.
+        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -11020,7 +11020,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> or <paramref name="scheduler" /> is null.</exception>
-        /// <seealso cref="Reactive.Subjects.ReplaySubject`1" />
+        /// <seealso cref="Reactive.Subjects.ReplaySubject{TResult}" />
         public static IQbservable<TResult> Replay<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector, IScheduler scheduler)
         {
             if (source == null)
@@ -11047,7 +11047,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject`1" />.
+        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -11059,7 +11059,7 @@ namespace System.Reactive.Linq
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException">
         /// <paramref name="window" /> is less than TimeSpan.Zero.</exception>
-        /// <seealso cref="Reactive.Subjects.ReplaySubject`1" />
+        /// <seealso cref="Reactive.Subjects.ReplaySubject{TResult}" />
         public static IQbservable<TResult> Replay<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector, TimeSpan window)
         {
             if (source == null)
@@ -11084,7 +11084,7 @@ namespace System.Reactive.Linq
         
         /// <summary>
         /// Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
-        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject`1" />.
+        /// This operator is a specialization of Multicast using a <see cref="Reactive.Subjects.ReplaySubject{TResult}" />.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
@@ -11097,7 +11097,7 @@ namespace System.Reactive.Linq
         /// <paramref name="source" /> or <paramref name="selector" /> or <paramref name="scheduler" /> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException">
         /// <paramref name="window" /> is less than TimeSpan.Zero.</exception>
-        /// <seealso cref="Reactive.Subjects.ReplaySubject`1" />
+        /// <seealso cref="Reactive.Subjects.ReplaySubject{TResult}" />
         public static IQbservable<TResult> Replay<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<IObservable<TSource>, IObservable<TResult>>> selector, TimeSpan window, IScheduler scheduler)
         {
             if (source == null)
@@ -13519,9 +13519,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Double" /> values.
+        /// Computes the sum of a sequence of <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Double" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of <see cref="double" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -13545,9 +13545,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Int32" /> values.
+        /// Computes the sum of a sequence of <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int32" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of <see cref="int" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -13572,9 +13572,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Int64" /> values.
+        /// Computes the sum of a sequence of <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of <see cref="Int64" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of <see cref="long" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -13626,9 +13626,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Double" /> values.
+        /// Computes the sum of a sequence of nullable <see cref="double" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Double" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of nullable <see cref="double" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -13652,9 +13652,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Int32" /> values.
+        /// Computes the sum of a sequence of nullable <see cref="int" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int32" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of nullable <see cref="int" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -13679,9 +13679,9 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Int64" /> values.
+        /// Computes the sum of a sequence of nullable <see cref="long" /> values.
         /// </summary>
-        /// <param name="source">A sequence of nullable <see cref="Int64" /> values to calculate the sum of.</param>
+        /// <param name="source">A sequence of nullable <see cref="long" /> values to calculate the sum of.</param>
         /// <returns>An observable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -13758,7 +13758,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Double" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of nullable <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -13852,7 +13852,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Int32" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of nullable <see cref="int" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -13884,7 +13884,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of nullable <see cref="Int64" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of nullable <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -13916,7 +13916,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Double" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -14010,7 +14010,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Int32" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of <see cref="int" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>
@@ -14042,7 +14042,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Computes the sum of a sequence of <see cref="Int64" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the sum of a sequence of <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values that are used to calculate a sum.</param>