4.x: Fix XML document spelling errors (#543)

Rx.NET/Source/src/System.Reactive/Concurrency/Scheduler.Services.Emulation.cs

@@ -115,7 +115,7 @@ namespace System.Reactive.Concurrency
             // stopwatch facility, or go with a stopwatch based on "scheduler.Now", which has
             // the drawback of potentially going back in time:
             //
-            //   - Using the CAL's stopwatch facility causes us to abondon the scheduler's
+            //   - Using the CAL's stopwatch facility causes us to abandon the scheduler's
             //     potentially virtualized notion of time, always going for the local system
             //     time instead.
             //
@@ -129,7 +129,7 @@ namespace System.Reactive.Concurrency
             // non-monotonic points somehow), so we pick the latter option as the lesser of
             // two evils (also because it should occur rarely).
             //
-            // Users of the stopwatch retrieved by this method could detect non-sensical data
+            // Users of the stopwatch retrieved by this method could detect nonsensical data
             // revealing a jump back in time, or implement custom fallback logic like the one
             // shown below.
             //
@@ -439,7 +439,7 @@ namespace System.Reactive.Concurrency
                 //
                 // The host is telling us we're about to be suspended. At this point, time
                 // computations will still be in a valid range (next <= _period), but after
-                // we're woken up again, Tick would start to go on a crucade to catch up.
+                // we're woken up again, Tick would start to go on a crusade to catch up.
                 //
                 // This has caused problems in the past, where the flood of events caused
                 // batteries to drain etc (see design rationale discussion higher up).

Rx.NET/Source/src/System.Reactive/Concurrency/SchedulerOperation.cs

@@ -113,8 +113,8 @@ namespace System.Reactive.Concurrency
                         // contexts objects at the scheduler level. It's possible to start
                         // async operations by calling Schedule, without a way to observe
                         // their completion. Not interacting with SynchronizationContext
-                        // is a concious design decision as the performance impact was non
-                        // negligable and our schedulers abstract over more constructs.
+                        // is a conscious design decision as the performance impact was non
+                        // negligible and our schedulers abstract over more constructs.
                         //
                         ctx.Post(a => ((Action)a)(), original);
                     };

Rx.NET/Source/src/System.Reactive/Concurrency/SchedulerQueue.cs

@@ -24,7 +24,7 @@ namespace System.Reactive.Concurrency
         }
 
         /// <summary>
-        /// Creats a new scheduler queue with the specified initial capacity.
+        /// Creates a new scheduler queue with the specified initial capacity.
         /// </summary>
         /// <param name="capacity">Initial capacity of the scheduler queue.</param>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="capacity"/> is less than zero.</exception>

Rx.NET/Source/src/System.Reactive/Concurrency/TaskPoolScheduler.cs

@@ -149,7 +149,7 @@ namespace System.Reactive.Concurrency
         }
 
         /// <summary>
-        /// Gets a new stopwatch ob ject.
+        /// Gets a new stopwatch object.
         /// </summary>
         /// <returns>New stopwatch object; started at the time of the request.</returns>
         public override IStopwatch StartStopwatch()

Rx.NET/Source/src/System.Reactive/Disposables/CompositeDisposable.cs

@@ -315,7 +315,7 @@ namespace System.Reactive.Disposables
                 if (arrayIndex + _count > array.Length)
                 {
                     // there is not enough space beyond arrayIndex 
-                    // to accomodate all _count disposables in this composite
+                    // to accommodate all _count disposables in this composite
                     throw new ArgumentOutOfRangeException(nameof(arrayIndex));
                 }
                 var i = arrayIndex;

Rx.NET/Source/src/System.Reactive/Disposables/StableCompositeDisposable.cs

@@ -15,8 +15,8 @@ namespace System.Reactive.Disposables
         /// <summary>
         /// Creates a new group containing two disposable resources that are disposed together.
         /// </summary>
-        /// <param name="disposable1">The first disposable resoruce to add to the group.</param>
-        /// <param name="disposable2">The second disposable resoruce to add to the group.</param>
+        /// <param name="disposable1">The first disposable resource to add to the group.</param>
+        /// <param name="disposable2">The second disposable resource to add to the group.</param>
         /// <returns>Group of disposable resources that are disposed together.</returns>
         public static ICancelable Create(IDisposable disposable1, IDisposable disposable2)
         {

Rx.NET/Source/src/System.Reactive/Internal/CurrentPlatformEnlightenmentProvider.cs

@@ -20,7 +20,7 @@ namespace System.Reactive.PlatformServices
     public class CurrentPlatformEnlightenmentProvider : IPlatformEnlightenmentProvider
     {
         /// <summary>
-        /// (Infastructure) Tries to gets the specified service.
+        /// (Infrastructure) Tries to gets the specified service.
         /// </summary>
         /// <typeparam name="T">Service type.</typeparam>
         /// <param name="args">Optional set of arguments.</param>

Rx.NET/Source/src/System.Reactive/Internal/PlatformEnlightenmentProvider.cs

@@ -17,7 +17,7 @@ namespace System.Reactive.PlatformServices
     public interface IPlatformEnlightenmentProvider
     {
         /// <summary>
-        /// (Infastructure) Tries to gets the specified service.
+        /// (Infrastructure) Tries to gets the specified service.
         /// </summary>
         /// <typeparam name="T">Service type.</typeparam>
         /// <param name="args">Optional set of arguments.</param>

Rx.NET/Source/src/System.Reactive/Internal/ScheduledObserver.cs

@@ -509,7 +509,7 @@ namespace System.Reactive
         /// <summary>
         /// Executes a drain step by checking the disposed state,
         /// checking for the terminated state and for an
-        /// empty queue, issuing the approrpiate signals to the
+        /// empty queue, issuing the appropriate signals to the
         /// given downstream.
         /// </summary>
         /// <param name="q">The queue to use.</param>

Rx.NET/Source/src/System.Reactive/Joins/QueryablePattern.cs

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information. 
 
@@ -15,7 +15,7 @@ namespace System.Reactive.Joins
     public abstract class QueryablePattern
     {
         /// <summary>
-        /// Creates a new join pattern object using the specified expression tree represention.
+        /// Creates a new join pattern object using the specified expression tree representation.
         /// </summary>
         /// <param name="expression">Expression tree representing the join pattern.</param>
         protected QueryablePattern(Expression expression)
@@ -1047,4 +1047,4 @@ namespace System.Reactive.Joins
     #endregion
 }
 
-#pragma warning restore 1591
+#pragma warning restore 1591

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

@@ -1051,7 +1051,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the objects derived from the elements in the source sequence to determine the maximum of.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element 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 that corresponds to the maximum element in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
@@ -1071,7 +1071,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the objects derived from the elements in the source sequence to determine the maximum of.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <param name="comparer">Comparer used to compare elements.</param>
         /// <returns>An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence.</returns>
@@ -1334,7 +1334,7 @@ namespace System.Reactive.Linq
         /// Returns the minimum element in an observable sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element of.</param>
         /// <returns>An observable sequence containing a single element with the minimum element 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>
@@ -1350,7 +1350,7 @@ namespace System.Reactive.Linq
         /// Returns the minimum element in an observable sequence according to the specified comparer.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element of.</param>
         /// <param name="comparer">Comparer used to compare elements.</param>
         /// <returns>An observable sequence containing a single element with the minimum element in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="comparer"/> is null.</exception>
@@ -1520,7 +1520,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the objects derived from the elements in the source sequence to determine the minimum of.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element 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 that corresponds to the minimum element in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
@@ -1540,7 +1540,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the objects derived from the elements in the source sequence to determine the minimum of.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <param name="comparer">Comparer used to compare elements.</param>
         /// <returns>An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>

Rx.NET/Source/src/System.Reactive/Linq/Observable.StandardSequenceOperators.cs

@@ -400,7 +400,7 @@ namespace System.Reactive.Linq
         /// <param name="durationSelector">A function to signal the expiration of a group.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="durationSelector"/> is null.</exception>
         public static IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector)
@@ -431,7 +431,7 @@ namespace System.Reactive.Linq
         /// <param name="comparer">An equality comparer to compare keys with.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="durationSelector"/> or <paramref name="comparer"/> is null.</exception>
         public static IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer)
@@ -461,7 +461,7 @@ namespace System.Reactive.Linq
         /// <param name="durationSelector">A function to signal the expiration of a group.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="durationSelector"/> is null.</exception>
         public static IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(this IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector)
@@ -531,7 +531,7 @@ namespace System.Reactive.Linq
         /// <param name="capacity">The initial number of elements that the underlying dictionary can contain.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="durationSelector"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="capacity"/> is less than 0.</exception>
@@ -566,7 +566,7 @@ namespace System.Reactive.Linq
         /// <param name="comparer">An equality comparer to compare keys with.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="durationSelector"/> or <paramref name="comparer"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="capacity"/> is less than 0.</exception>
@@ -600,7 +600,7 @@ namespace System.Reactive.Linq
         /// <param name="capacity">The initial number of elements that the underlying dictionary can contain.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="durationSelector"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="capacity"/> is less than 0.</exception>
@@ -1091,7 +1091,7 @@ namespace System.Reactive.Linq
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchronously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
         {
             if (source == null)
@@ -1111,7 +1111,7 @@ namespace System.Reactive.Linq
         /// <param name="selector">A transform function to apply to each element; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchronously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
         {
             if (source == null)
@@ -1133,7 +1133,7 @@ namespace System.Reactive.Linq
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="collectionSelector"/> or <paramref name="resultSelector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchronously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IObservable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
         {
             if (source == null)
@@ -1157,7 +1157,7 @@ namespace System.Reactive.Linq
         /// <param name="resultSelector">A transform function to apply to each element of the intermediate sequence; the second parameter of the function represents the index of the source element and the fourth parameter represents the index of the intermediate element.</param>
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="collectionSelector"/> or <paramref name="resultSelector"/> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchronously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})"/> conversion.</remarks>
         public static IObservable<TResult> SelectMany<TSource, TCollection, TResult>(this IObservable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector)
         {
             if (source == null)
@@ -1347,7 +1347,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">An observable sequence whose elements to filter.</param>
-        /// <param name="predicate">A function to test each source element for a conditio; the second parameter of the function represents the index of the source element.</param>
+        /// <param name="predicate">A function to test each source element for a condition; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence that contains elements from the input sequence that satisfy the condition.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
         public static IObservable<TSource> Where<TSource>(this IObservable<TSource> source, Func<TSource, int, bool> predicate)

Rx.NET/Source/src/System.Reactive/Linq/Observable/CombineLatest.Generated.cs

@@ -10,7 +10,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
     /* The following code is generated by a T4 template. */
 
-    #region CombineLatest auto-generated code (4/20/2017 3:38:14 PM)
+    #region CombineLatest auto-generated code (2018.05.28. 16:02:20)
 
     internal sealed class CombineLatest<T1, T2, T3, TResult> : Producer<TResult, CombineLatest<T1, T2, T3, TResult>._>
     {

Rx.NET/Source/src/System.Reactive/Linq/Observable/FromEvent.cs

@@ -143,7 +143,7 @@ using System.Reactive.Subjects;
 //
 // In here, there's already a race between the user hooking up an event handler through the += add
 // operation and the event producer (possibly on a different thread) calling OnBar. It's also worth
-// pointing out that this race condition is migitated by a check in SynchronizationContextScheduler
+// pointing out that this race condition is mitigated by a check in SynchronizationContextScheduler
 // causing synchronous execution in case the caller is already on the target SynchronizationContext.
 // This situation is common when using FromEvent[Pattern] immediately after declaring it, e.g. in
 // the context of a UI event handler.

Rx.NET/Source/src/System.Reactive/Linq/ObservableEx.cs

@@ -97,7 +97,7 @@ namespace System.Reactive.Linq
         #region ForkJoin
 
         /// <summary>
-        /// Runs two observable sequences in parallel and combines their last elemenets.
+        /// Runs two observable sequences in parallel and combines their last elements.
         /// </summary>
         /// <typeparam name="TSource1">The type of the elements in the first source sequence.</typeparam>
         /// <typeparam name="TSource2">The type of the elements in the second source sequence.</typeparam>

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

@@ -7307,7 +7307,7 @@ namespace System.Reactive.Linq
         /// <param name="durationSelector">A function to signal the expiration of a group.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="keySelector" /> or <paramref name="durationSelector" /> is null.</exception>
@@ -7349,7 +7349,7 @@ namespace System.Reactive.Linq
         /// <param name="capacity">The initial number of elements that the underlying dictionary can contain.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="keySelector" /> or <paramref name="durationSelector" /> is null.</exception>
@@ -7395,7 +7395,7 @@ namespace System.Reactive.Linq
         /// <param name="comparer">An equality comparer to compare keys with.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="keySelector" /> or <paramref name="durationSelector" /> or <paramref name="comparer" /> is null.</exception>
@@ -7443,7 +7443,7 @@ namespace System.Reactive.Linq
         /// <param name="comparer">An equality comparer to compare keys with.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="keySelector" /> or <paramref name="durationSelector" /> or <paramref name="comparer" /> is null.</exception>
@@ -7489,7 +7489,7 @@ namespace System.Reactive.Linq
         /// <param name="durationSelector">A function to signal the expiration of a group.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="keySelector" /> or <paramref name="elementSelector" /> or <paramref name="durationSelector" /> is null.</exception>
@@ -7536,7 +7536,7 @@ namespace System.Reactive.Linq
         /// <param name="capacity">The initial number of elements that the underlying dictionary can contain.</param>
         /// <returns>
         /// A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.
-        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered.
+        /// If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered.
         /// </returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="keySelector" /> or <paramref name="elementSelector" /> or <paramref name="durationSelector" /> is null.</exception>
@@ -8861,7 +8861,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the objects derived from the elements in the source sequence to determine the maximum of.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element 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 that corresponds to the maximum element in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
@@ -8893,7 +8893,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the objects derived from the elements in the source sequence to determine the maximum of.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <param name="comparer">Comparer used to compare elements.</param>
         /// <returns>An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence.</returns>
@@ -9603,7 +9603,7 @@ namespace System.Reactive.Linq
         /// Returns the minimum element in an observable sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element of.</param>
         /// <returns>An observable sequence containing a single element with the minimum element in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> is null.</exception>
@@ -9630,7 +9630,7 @@ namespace System.Reactive.Linq
         /// Returns the minimum element in an observable sequence according to the specified comparer.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element of.</param>
         /// <param name="comparer">Comparer used to compare elements.</param>
         /// <returns>An observable sequence containing a single element with the minimum element in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
@@ -9972,7 +9972,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the objects derived from the elements in the source sequence to determine the minimum of.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element 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 that corresponds to the minimum element in the source sequence.</returns>
         /// <exception cref="ArgumentNullException">
@@ -10004,7 +10004,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TResult">The type of the objects derived from the elements in the source sequence to determine the minimum of.</typeparam>
-        /// <param name="source">An observable sequence to determine the mimimum element of.</param>
+        /// <param name="source">An observable sequence to determine the minimum element of.</param>
         /// <param name="selector">A transform function to apply to each element.</param>
         /// <param name="comparer">Comparer used to compare elements.</param>
         /// <returns>An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
@@ -11377,7 +11377,7 @@ namespace System.Reactive.Linq
         }
         
         /// <summary>
-        /// Samples the source observable sequence using a samper observable sequence producing sampling ticks.
+        /// Samples the source observable sequence using a sampler observable sequence producing sampling ticks.
         /// Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
@@ -11547,7 +11547,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="collectionSelector" /> or <paramref name="resultSelector" /> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchronously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
         public static IQbservable<TResult> SelectMany<TSource, TCollection, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector)
         {
             if (source == null)
@@ -11584,7 +11584,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="collectionSelector" /> or <paramref name="resultSelector" /> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchronously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
         public static IQbservable<TResult> SelectMany<TSource, TCollection, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, int, TCollection, int, TResult>> resultSelector)
         {
             if (source == null)
@@ -11800,7 +11800,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchronously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
         public static IQbservable<TResult> SelectMany<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, IEnumerable<TResult>>> selector)
         {
             if (source == null)
@@ -11832,7 +11832,7 @@ namespace System.Reactive.Linq
         /// <returns>An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="selector" /> is null.</exception>
-        /// <remarks>The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
+        /// <remarks>The projected sequences are enumerated synchronously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the <see cref="Observable.ToObservable{TSource}(IEnumerable{TSource})" /> conversion.</remarks>
         public static IQbservable<TResult> SelectMany<TSource, TResult>(this IQbservable<TSource> source, Expression<Func<TSource, int, IEnumerable<TResult>>> selector)
         {
             if (source == null)
@@ -16498,7 +16498,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">An observable sequence whose elements to filter.</param>
-        /// <param name="predicate">A function to test each source element for a conditio; the second parameter of the function represents the index of the source element.</param>
+        /// <param name="predicate">A function to test each source element for a condition; the second parameter of the function represents the index of the source element.</param>
         /// <returns>An observable sequence that contains elements from the input sequence that satisfy the condition.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source" /> or <paramref name="predicate" /> is null.</exception>

Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.Generated.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * WARNING: Auto-generated file (5/1/2015 21:21:20)
  * Run Rx's auto-homoiconizer tool to generate this file (in the HomoIcon directory).
  */
@@ -224,7 +224,7 @@ namespace System.Reactive.Linq
         
 #if !STABLE
         /// <summary>
-        /// Runs two observable sequences in parallel and combines their last elemenets.
+        /// Runs two observable sequences in parallel and combines their last elements.
         /// </summary>
         /// <typeparam name="TSource1">The type of the elements in the first source sequence.</typeparam>
         /// <typeparam name="TSource2">The type of the elements in the second source sequence.</typeparam>

Rx.NET/Source/src/System.Reactive/Observer.Extensions.cs

@@ -259,12 +259,12 @@ namespace System.Reactive
         }
 
         /// <summary>
-        /// Schedules the invocation of observer methods on the given synchonization context.
+        /// Schedules the invocation of observer methods on the given synchronization context.
         /// </summary>
         /// <typeparam name="T">The type of the elements received by the source observer.</typeparam>
         /// <param name="observer">The observer to schedule messages for.</param>
-        /// <param name="context">Synchonization context to schedule observer messages on.</param>
-        /// <returns>Observer whose messages are scheduled on the given synchonization context.</returns>
+        /// <param name="context">Synchronization context to schedule observer messages on.</param>
+        /// <returns>Observer whose messages are scheduled on the given synchronization context.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="observer"/> or <paramref name="context"/> is null.</exception>
         public static IObserver<T> NotifyOn<T>(this IObserver<T> observer, SynchronizationContext context)
         {

Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/ControlObservable.cs

@@ -17,7 +17,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence.</param>
-        /// <param name="control">Windows Forms control whose associated message loop is used to to perform subscription and unsubscription actions on.</param>
+        /// <param name="control">Windows Forms control whose associated message loop is used to perform subscription and unsubscription actions on.</param>
         /// <returns>The source sequence whose subscriptions and unsubscriptions happen on the Windows Forms message loop associated with the specified control.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="control"/> is null.</exception>
         /// <remarks>
@@ -39,7 +39,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence.</param>
-        /// <param name="control">Windows Forms control whose associated message loop is used to to notify observers on.</param>
+        /// <param name="control">Windows Forms control whose associated message loop is used to notify observers on.</param>
         /// <returns>The source sequence whose observations happen on the Windows Forms message loop associated with the specified control.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="control"/> is null.</exception>
         public static IObservable<TSource> ObserveOn<TSource>(this IObservable<TSource> source, Control control)

Rx.NET/Source/src/System.Reactive/Platforms/Desktop/Linq/DispatcherObservable.cs

@@ -21,7 +21,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence.</param>
-        /// <param name="dispatcher">Dispatcher whose associated message loop is used to to notify observers on.</param>
+        /// <param name="dispatcher">Dispatcher whose associated message loop is used to notify observers on.</param>
         /// <returns>The source sequence whose observations happen on the specified dispatcher.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="dispatcher"/> is null.</exception>
         public static IObservable<TSource> ObserveOn<TSource>(this IObservable<TSource> source, Dispatcher dispatcher)
@@ -39,7 +39,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence.</param>
-        /// <param name="dispatcher">Dispatcher whose associated message loop is used to to notify observers on.</param>
+        /// <param name="dispatcher">Dispatcher whose associated message loop is used to notify observers on.</param>
         /// <param name="priority">Priority to schedule work items at.</param>
         /// <returns>The source sequence whose observations happen on the specified dispatcher.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="dispatcher"/> is null.</exception>
@@ -161,7 +161,7 @@ namespace System.Reactive.Linq
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">Source sequence.</param>
-        /// <param name="dispatcher">Dispatcher whose associated message loop is used to to perform subscription and unsubscription actions on.</param>
+        /// <param name="dispatcher">Dispatcher whose associated message loop is used to perform subscription and unsubscription actions on.</param>
         /// <returns>The source sequence whose subscriptions and unsubscriptions happen on the specified dispatcher.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="dispatcher"/> is null.</exception>
         /// <remarks>
@@ -322,4 +322,4 @@ namespace System.Reactive.Linq
         #endregion
     }
 }
-#endif
+#endif

Rx.NET/Source/src/System.Reactive/Platforms/UWP/Foundation/AsyncInfoExtensions.cs

@@ -78,7 +78,7 @@ namespace System.Reactive.Windows.Foundation
 
         /// <summary>
         /// Converts a Windows Runtime asynchronous action to an observable sequence reporting its progress.
-        /// Each observer subscribed to the resulting observable sequence will be notified about the action's succesful or exceptional completion.
+        /// Each observer subscribed to the resulting observable sequence will be notified about the action's successful or exceptional completion.
         /// </summary>
         /// <typeparam name="TProgress">The type of the reported progress objects.</typeparam>
         /// <param name="source">Asynchronous action to convert.</param>
@@ -175,12 +175,12 @@ namespace System.Reactive.Windows.Foundation
 
         /// <summary>
         /// Converts a Windows Runtime asynchronous operation to an observable sequence reporting its progress but ignoring its result value.
-        /// Each observer subscribed to the resulting observable sequence will be notified about the action's succesful or exceptional completion.
+        /// Each observer subscribed to the resulting observable sequence will be notified about the action's successful or exceptional completion.
         /// </summary>
         /// <typeparam name="TResult">The type of the asynchronous operation's result, which gets ignored by this conversion.</typeparam>
         /// <typeparam name="TProgress">The type of the reported progress objects.</typeparam>
         /// <param name="source">Asynchronous action to convert.</param>
-        /// <returns>An observable sequence that produces progress values from the asynchronous operatin and notifies observers about the operations's completion.</returns>
+        /// <returns>An observable sequence that produces progress values from the asynchronous operation and notifies observers about the operations's completion.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         public static IObservable<TProgress> ToObservableProgress<TResult, TProgress>(this IAsyncOperationWithProgress<TResult, TProgress> source)
         {
@@ -197,7 +197,7 @@ namespace System.Reactive.Windows.Foundation
 
         /// <summary>
         /// Converts a Windows Runtime asynchronous operation to an observable sequence by retrieving the operation's results whenever progress is reported and when the operation completes.
-        /// Each observer subscribed to the resulting observable sequence will be notified about the action's succesful or exceptional completion.
+        /// Each observer subscribed to the resulting observable sequence will be notified about the action's successful or exceptional completion.
         /// </summary>
         /// <typeparam name="TResult">The type of the asynchronous operation's result.</typeparam>
         /// <typeparam name="TProgress">The type of the reported progress objects, which are used internally in the conversion but aren't exposed.</typeparam>
@@ -215,7 +215,7 @@ namespace System.Reactive.Windows.Foundation
 
         /// <summary>
         /// Converts a Windows Runtime asynchronous operation to an observable sequence by retrieving the operation's results whenever progress is reported and when the operation completes. The operation's progress is reported through the supplied progress object.
-        /// Each observer subscribed to the resulting observable sequence will be notified about the action's succesful or exceptional completion.
+        /// Each observer subscribed to the resulting observable sequence will be notified about the action's successful or exceptional completion.
         /// </summary>
         /// <typeparam name="TResult">The type of the asynchronous operation's result.</typeparam>
         /// <typeparam name="TProgress">The type of the reported progress objects.</typeparam>
@@ -249,4 +249,4 @@ namespace System.Reactive.Windows.Foundation
         #endregion
     }
 }
-#endif
+#endif

Rx.NET/Source/src/System.Reactive/Strings_Core.Designer.cs

@@ -71,7 +71,7 @@ namespace System.Reactive {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to OnCompleted notification doesn&apos;t have a value..
+        ///   Looks up a localized string similar to OnCompleted notification doesn't have a value..
         /// </summary>
         internal static string COMPLETED_NO_VALUE {
             get {

Rx.NET/Source/src/System.Reactive/Strings_Linq.resx

@@ -152,7 +152,7 @@
   </data>
   <data name="EVENT_WINRT_REMOVE_METHOD_SHOULD_TAKE_ERT" xml:space="preserve">
     <value>Remove method of a WinRT event should take an EventRegistrationToken.</value>
-    <comment>Only onn platforms supporting WinRT.</comment>
+    <comment>Only on platforms supporting WinRT.</comment>
   </data>
   <data name="MORE_THAN_ONE_ELEMENT" xml:space="preserve">
     <value>Sequence contains more than one element.</value>