Remove greek letters (caused problems for some tools)

.gitignore

@@ -1,4 +1,33 @@
-Rx/Layout/*
+Ix.NET/Layout
+Rx.NET/Layout
+
+
+*.pydevproject
+.project
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.classpath
+.settings/
+.loadpath
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# CDT-specific
+.cproject
+
+# PDT-specific
+.buildpath
+
 
 #################
 ## Visual Studio
@@ -35,7 +64,7 @@ Rx/Layout/*
 *.dotCover
 
 ## TODO: If you have NuGet Package Restore enabled, uncomment this
-# packages/
+#packages/
 
 # Visual C++ cache files
 ipch/
@@ -85,6 +114,8 @@ _UpgradeReport_Files/
 Backup*/
 UpgradeLog*.XML
 
+
+
 ############
 ## Windows
 ############
@@ -94,4 +125,40 @@ Thumbs.db
 
 # Folder config file
 Desktop.ini
-Rx/NET/Test/Rx/packages/
+
+
+#############
+## Python
+#############
+
+*.py[co]
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+
+#Translations
+*.mo
+
+#Mr Developer
+.mr.developer.cfg
+
+# Mac crap
+.DS_Store
+Rx.NET/Source/Rx.sln.ide/

Rx.NET/Source/System.Reactive.Core/Reactive/Concurrency/Synchronization.ObserveOn.cs

@@ -35,7 +35,7 @@ namespace System.Reactive.Concurrency
 #if !NO_SYNCCTX
             if (_context != null)
             {
-                var sink = new ς(this, observer, cancel);
+                var sink = new ObserveOnSink(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -49,11 +49,11 @@ namespace System.Reactive.Concurrency
         }
 
 #if !NO_SYNCCTX
-        class ς : Sink<TSource>, IObserver<TSource>
+        class ObserveOnSink : Sink<TSource>, IObserver<TSource>
         {
             private readonly ObserveOn<TSource> _parent;
 
-            public ς(ObserveOn<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public ObserveOnSink(ObserveOn<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/GlobalSuppressions.cs

@@ -15,169 +15,169 @@
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Reactive.Threading.Tasks", Justification = "By design.")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "Taken care of by lab build.")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1016:MarkAssembliesWithAssemblyVersion", Justification = "Taken care of by lab build.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AddRef`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Aggregate`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Aggregate`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.All`1.#Run(System.IObserver`1<System.Boolean>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Amb`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Any`1.#Run(System.IObserver`1<System.Boolean>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AsObservable`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AverageDecimal.#Run(System.IObserver`1<System.Decimal>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AverageDecimalNullable.#Run(System.IObserver`1<System.Nullable`1<System.Decimal>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AverageDouble.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AverageDoubleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AverageInt32.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AverageInt32Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AverageInt64.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AverageInt64Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AverageSingle.#Run(System.IObserver`1<System.Single>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.AverageSingleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Single>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Buffer`2.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Buffer`1.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Cast`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Catch`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Catch`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`17.#Run(System.IObserver`1<!16>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`16.#Run(System.IObserver`1<!15>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`15.#Run(System.IObserver`1<!14>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`14.#Run(System.IObserver`1<!13>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`13.#Run(System.IObserver`1<!12>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`12.#Run(System.IObserver`1<!11>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`11.#Run(System.IObserver`1<!10>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`10.#Run(System.IObserver`1<!9>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`9.#Run(System.IObserver`1<!8>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`8.#Run(System.IObserver`1<!7>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`7.#Run(System.IObserver`1<!6>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`6.#Run(System.IObserver`1<!5>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`5.#Run(System.IObserver`1<!4>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`4.#Run(System.IObserver`1<!3>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`3.#Run(System.IObserver`1<!2>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CombineLatest`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Concat`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Contains`1.#Run(System.IObserver`1<System.Boolean>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.CountObservαble`1.#Run(System.IObserver`1<System.Int32>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.DefaultIfEmpty`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Defer`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Delay`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Delay`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.DelaySubscription`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Scope = "member", Target = "System.Reactive.Linq.Observαble.Dematerialize`1+_.#OnNext(System.Reactive.Notification`1<!0>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Dematerialize`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Distinct`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.DistinctUntilChanged`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Do`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AddRef`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Aggregate`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Aggregate`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.All`1.#Run(System.IObserver`1<System.Boolean>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Amb`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Any`1.#Run(System.IObserver`1<System.Boolean>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AsObservable`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AverageDecimal.#Run(System.IObserver`1<System.Decimal>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AverageDecimalNullable.#Run(System.IObserver`1<System.Nullable`1<System.Decimal>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AverageDouble.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AverageDoubleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AverageInt32.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AverageInt32Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AverageInt64.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AverageInt64Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AverageSingle.#Run(System.IObserver`1<System.Single>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.AverageSingleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Single>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Buffer`2.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Buffer`1.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Cast`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Catch`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Catch`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`17.#Run(System.IObserver`1<!16>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`16.#Run(System.IObserver`1<!15>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`15.#Run(System.IObserver`1<!14>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`14.#Run(System.IObserver`1<!13>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`13.#Run(System.IObserver`1<!12>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`12.#Run(System.IObserver`1<!11>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`11.#Run(System.IObserver`1<!10>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`10.#Run(System.IObserver`1<!9>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`9.#Run(System.IObserver`1<!8>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`8.#Run(System.IObserver`1<!7>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`7.#Run(System.IObserver`1<!6>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`6.#Run(System.IObserver`1<!5>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`5.#Run(System.IObserver`1<!4>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`4.#Run(System.IObserver`1<!3>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`3.#Run(System.IObserver`1<!2>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.CombineLatest`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Concat`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Contains`1.#Run(System.IObserver`1<System.Boolean>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Count`1.#Run(System.IObserver`1<System.Int32>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.DefaultIfEmpty`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Defer`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Delay`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Delay`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.DelaySubscription`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Dematerialize`1+_.#OnNext(System.Reactive.Notification`1<!0>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Dematerialize`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Distinct`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.DistinctUntilChanged`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Do`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Scope = "member", Target = "System.Reactive.Either`2+Left.#Switch(System.Action`1<!0>,System.Action`1<!1>)", Justification = "Producer cannot pass null to setSink parameter.")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Scope = "member", Target = "System.Reactive.Either`2+Left.#Switch`1(System.Func`2<!0,!!0>,System.Func`2<!1,!!0>)", Justification = "Producer cannot pass null to setSink parameter.")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1", Scope = "member", Target = "System.Reactive.Either`2+Right.#Switch(System.Action`1<!0>,System.Action`1<!1>)", Justification = "Producer cannot pass null to setSink parameter.")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1", Scope = "member", Target = "System.Reactive.Either`2+Right.#Switch`1(System.Func`2<!0,!!0>,System.Func`2<!1,!!0>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.ElementAt`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Empty`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Finally`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.FirstAsync`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Generate`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.GroupBy`3.#Run(System.IObserver`1<System.Reactive.Linq.IGroupedObservable`2<!1,!2>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.GroupByUntil`4.#Run(System.IObserver`1<System.Reactive.Linq.IGroupedObservable`2<!1,!2>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.GroupJoin`5.#Run(System.IObserver`1<!4>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.IgnoreElements`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.IsEmpty`1.#Run(System.IObserver`1<System.Boolean>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Join`5.#Run(System.IObserver`1<!4>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.ElementAt`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Empty`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Finally`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.FirstAsync`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Generate`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.GroupBy`3.#Run(System.IObserver`1<System.Reactive.Linq.IGroupedObservable`2<!1,!2>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.GroupByUntil`4.#Run(System.IObserver`1<System.Reactive.Linq.IGroupedObservable`2<!1,!2>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.GroupJoin`5.#Run(System.IObserver`1<!4>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.IgnoreElements`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.IsEmpty`1.#Run(System.IObserver`1<System.Boolean>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Join`5.#Run(System.IObserver`1<!4>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Scope = "member", Target = "System.Reactive.Joins.JoinObserver`1.#OnNextCore(System.Reactive.Notification`1<!0>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.LastAsync`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.LongCountObservαble`1.#Run(System.IObserver`1<System.Int64>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Materialize`1.#Run(System.IObserver`1<System.Reactive.Notification`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Max`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxBy`2.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxDecimal.#Run(System.IObserver`1<System.Decimal>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxDecimalNullable.#Run(System.IObserver`1<System.Nullable`1<System.Decimal>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxDouble.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxDoubleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxInt32.#Run(System.IObserver`1<System.Int32>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxInt32Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int32>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxInt64.#Run(System.IObserver`1<System.Int64>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxInt64Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int64>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxSingle.#Run(System.IObserver`1<System.Single>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MaxSingleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Single>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Merge`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Min`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinBy`2.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinDecimal.#Run(System.IObserver`1<System.Decimal>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinDecimalNullable.#Run(System.IObserver`1<System.Nullable`1<System.Decimal>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinDouble.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinDoubleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinInt32.#Run(System.IObserver`1<System.Int32>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinInt32Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int32>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinInt64.#Run(System.IObserver`1<System.Int64>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinInt64Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int64>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinSingle.#Run(System.IObserver`1<System.Single>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.MinSingleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Single>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Multicast`3.#Run(System.IObserver`1<!2>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.OfType`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.OnErrorResumeNext`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Range.#Run(System.IObserver`1<System.Int32>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.RefCount`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Repeat`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Return`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Sample`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Sample`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Scan`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Scan`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Select`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SelectMany`3.#Run(System.IObserver`1<!2>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SelectMany`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SequenceEqual`1.#Run(System.IObserver`1<System.Boolean>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SingleAsync`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Skip`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SkipLast`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SkipUntil`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SkipUntil`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SkipWhile`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SumDecimal.#Run(System.IObserver`1<System.Decimal>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SumDecimalNullable.#Run(System.IObserver`1<System.Nullable`1<System.Decimal>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SumDouble.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SumDoubleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SumInt32.#Run(System.IObserver`1<System.Int32>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SumInt32Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int32>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SumInt64.#Run(System.IObserver`1<System.Int64>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SumInt64Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int64>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SumSingle.#Run(System.IObserver`1<System.Single>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.SumSingleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Single>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Switch`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Take`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.TakeLast`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.TakeUntil`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.TakeUntil`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.TakeWhile`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Throttle`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Throttle`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Throw`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.TimeInterval`1.#Run(System.IObserver`1<System.Reactive.TimeInterval`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Timeout`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Timeout`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Timer.#Run(System.IObserver`1<System.Int64>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Timestamp`1.#Run(System.IObserver`1<System.Reactive.Timestamped`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.ToArray`1.#Run(System.IObserver`1<!0[]>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.ToDictionary`3.#Run(System.IObserver`1<System.Collections.Generic.IDictionary`2<!1,!2>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.ToList`1.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.ToLookup`3.#Run(System.IObserver`1<System.Linq.ILookup`2<!1,!2>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.ToObservable`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Using`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Where`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Window`2.#Run(System.IObserver`1<System.IObservable`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Window`1.#Run(System.IObserver`1<System.IObservable`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`17.#Run(System.IObserver`1<!16>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`16.#Run(System.IObserver`1<!15>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`15.#Run(System.IObserver`1<!14>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`14.#Run(System.IObserver`1<!13>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`13.#Run(System.IObserver`1<!12>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`12.#Run(System.IObserver`1<!11>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`11.#Run(System.IObserver`1<!10>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`10.#Run(System.IObserver`1<!9>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`9.#Run(System.IObserver`1<!8>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`8.#Run(System.IObserver`1<!7>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`7.#Run(System.IObserver`1<!6>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`6.#Run(System.IObserver`1<!5>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`4.#Run(System.IObserver`1<!3>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`3.#Run(System.IObserver`1<!2>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`1.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.Observαble.Zip`5.#Run(System.IObserver`1<!4>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Scope = "member", Target = "System.Reactive.Linq.Observαble.ElementAt`1+_.#OnCompleted()", Justification = "Asynchronous behavior; no more index parameter in scope.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.LastAsync`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.LongCount`1.#Run(System.IObserver`1<System.Int64>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Materialize`1.#Run(System.IObserver`1<System.Reactive.Notification`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Max`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxBy`2.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxDecimal.#Run(System.IObserver`1<System.Decimal>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxDecimalNullable.#Run(System.IObserver`1<System.Nullable`1<System.Decimal>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxDouble.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxDoubleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxInt32.#Run(System.IObserver`1<System.Int32>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxInt32Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int32>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxInt64.#Run(System.IObserver`1<System.Int64>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxInt64Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int64>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxSingle.#Run(System.IObserver`1<System.Single>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MaxSingleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Single>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Merge`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Min`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinBy`2.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinDecimal.#Run(System.IObserver`1<System.Decimal>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinDecimalNullable.#Run(System.IObserver`1<System.Nullable`1<System.Decimal>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinDouble.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinDoubleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinInt32.#Run(System.IObserver`1<System.Int32>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinInt32Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int32>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinInt64.#Run(System.IObserver`1<System.Int64>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinInt64Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int64>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinSingle.#Run(System.IObserver`1<System.Single>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.MinSingleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Single>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Multicast`3.#Run(System.IObserver`1<!2>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.OfType`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.OnErrorResumeNext`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Range.#Run(System.IObserver`1<System.Int32>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.RefCount`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Repeat`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Return`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Sample`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Sample`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Scan`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Scan`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Select`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SelectMany`3.#Run(System.IObserver`1<!2>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SelectMany`2.#Run(System.IObserver`1<!1>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SequenceEqual`1.#Run(System.IObserver`1<System.Boolean>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SingleAsync`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Skip`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SkipLast`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SkipUntil`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SkipUntil`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SkipWhile`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SumDecimal.#Run(System.IObserver`1<System.Decimal>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SumDecimalNullable.#Run(System.IObserver`1<System.Nullable`1<System.Decimal>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SumDouble.#Run(System.IObserver`1<System.Double>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SumDoubleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Double>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SumInt32.#Run(System.IObserver`1<System.Int32>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SumInt32Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int32>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SumInt64.#Run(System.IObserver`1<System.Int64>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SumInt64Nullable.#Run(System.IObserver`1<System.Nullable`1<System.Int64>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SumSingle.#Run(System.IObserver`1<System.Single>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.SumSingleNullable.#Run(System.IObserver`1<System.Nullable`1<System.Single>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Switch`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Take`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.TakeLast`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.TakeUntil`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.TakeUntil`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.TakeWhile`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Throttle`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Throttle`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Throw`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.TimeInterval`1.#Run(System.IObserver`1<System.Reactive.TimeInterval`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Timeout`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Timeout`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Timer.#Run(System.IObserver`1<System.Int64>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Timestamp`1.#Run(System.IObserver`1<System.Reactive.Timestamped`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.ToArray`1.#Run(System.IObserver`1<!0[]>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.ToDictionary`3.#Run(System.IObserver`1<System.Collections.Generic.IDictionary`2<!1,!2>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.ToList`1.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.ToLookup`3.#Run(System.IObserver`1<System.Linq.ILookup`2<!1,!2>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.ToObservable`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Using`2.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Where`1.#Run(System.IObserver`1<!0>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Window`2.#Run(System.IObserver`1<System.IObservable`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Window`1.#Run(System.IObserver`1<System.IObservable`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`17.#Run(System.IObserver`1<!16>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`16.#Run(System.IObserver`1<!15>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`15.#Run(System.IObserver`1<!14>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`14.#Run(System.IObserver`1<!13>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`13.#Run(System.IObserver`1<!12>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`12.#Run(System.IObserver`1<!11>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`11.#Run(System.IObserver`1<!10>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`10.#Run(System.IObserver`1<!9>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`9.#Run(System.IObserver`1<!8>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`8.#Run(System.IObserver`1<!7>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`7.#Run(System.IObserver`1<!6>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`6.#Run(System.IObserver`1<!5>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`4.#Run(System.IObserver`1<!3>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`3.#Run(System.IObserver`1<!2>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`1.#Run(System.IObserver`1<System.Collections.Generic.IList`1<!0>>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.Zip`5.#Run(System.IObserver`1<!4>,System.IDisposable,System.Action`1<System.IDisposable>)", Justification = "Producer cannot pass null to setSink parameter.")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Scope = "member", Target = "System.Reactive.Linq.ObservableImpl.ElementAt`1+_.#OnCompleted()", Justification = "Asynchronous behavior; no more index parameter in scope.")]

Rx.NET/Source/System.Reactive.Linq/Reactive/Internal/Helpers.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 using System.Collections.Generic;
-using System.Reactive.Linq.Observαble;
+using System.Reactive.Linq.ObservableImpl;
 
 namespace System.Reactive
 {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/AddRef.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class AddRef<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Aggregate.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Aggregate<TSource, TAccumulate, TResult> : Producer<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/All.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class All<TSource> : Producer<bool>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Amb.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Amb<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Any.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Any<TSource> : Producer<bool>
     {
@@ -25,7 +25,7 @@ namespace System.Reactive.Linq.Observαble
         {
             if (_predicate != null)
             {
-                var sink = new π(this, observer, cancel);
+                var sink = new AnyImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -65,11 +65,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class π : Sink<bool>, IObserver<TSource>
+        class AnyImpl : Sink<bool>, IObserver<TSource>
         {
             private readonly Any<TSource> _parent;
 
-            public π(Any<TSource> parent, IObserver<bool> observer, IDisposable cancel)
+            public AnyImpl(Any<TSource> parent, IObserver<bool> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/AsObservable.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class AsObservable<TSource> : Producer<TSource>, IEvaluatableObservable<TSource>
     {
@@ -14,7 +14,7 @@ namespace System.Reactive.Linq.Observαble
             _source = source;
         }
 
-        public IObservable<TSource> Ω()
+        public IObservable<TSource> Omega()
         {
             return this;
         }

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Average.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class AverageDouble : Producer<double>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Buffer.cs

@@ -8,7 +8,7 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Buffer<TSource> : Producer<IList<TSource>>
     {
@@ -53,7 +53,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else if (_count > 0)
             {
-                var sink = new μ(this, observer, cancel);
+                var sink = new Impl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -61,13 +61,13 @@ namespace System.Reactive.Linq.Observαble
             {
                 if (_timeSpan == _timeShift)
                 {
-                    var sink = new π(this, observer, cancel);
+                    var sink = new BufferTimeShift(this, observer, cancel);
                     setSink(sink);
                     return sink.Run();
                 }
                 else
                 {
-                    var sink = new τ(this, observer, cancel);
+                    var sink = new BufferImpl(this, observer, cancel);
                     setSink(sink);
                     return sink.Run();
                 }
@@ -143,11 +143,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class τ : Sink<IList<TSource>>, IObserver<TSource>
+        class BufferImpl : Sink<IList<TSource>>, IObserver<TSource>
         {
             private readonly Buffer<TSource> _parent;
 
-            public τ(Buffer<TSource> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
+            public BufferImpl(Buffer<TSource> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -283,11 +283,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class π : Sink<IList<TSource>>, IObserver<TSource>
+        class BufferTimeShift : Sink<IList<TSource>>, IObserver<TSource>
         {
             private readonly Buffer<TSource> _parent;
 
-            public π(Buffer<TSource> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
+            public BufferTimeShift(Buffer<TSource> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -346,11 +346,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class μ : Sink<IList<TSource>>, IObserver<TSource>
+        class Impl : Sink<IList<TSource>>, IObserver<TSource>
         {
             private readonly Buffer<TSource> _parent;
 
-            public μ(Buffer<TSource> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
+            public Impl(Buffer<TSource> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -487,7 +487,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new β(this, observer, cancel);
+                var sink = new Beta(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -544,7 +544,7 @@ namespace System.Reactive.Linq.Observαble
 
                 var closingSubscription = new SingleAssignmentDisposable();
                 _m.Disposable = closingSubscription;
-                closingSubscription.Disposable = bufferClose.SubscribeSafe(new ω(this, closingSubscription));
+                closingSubscription.Disposable = bufferClose.SubscribeSafe(new Omega(this, closingSubscription));
             }
 
             private void CloseBuffer(IDisposable closingSubscription)
@@ -561,12 +561,12 @@ namespace System.Reactive.Linq.Observαble
                 _bufferGate.Wait(CreateBufferClose);
             }
 
-            class ω : IObserver<TBufferClosing>
+            class Omega : IObserver<TBufferClosing>
             {
                 private readonly _ _parent;
                 private readonly IDisposable _self;
 
-                public ω(_ parent, IDisposable self)
+                public Omega(_ parent, IDisposable self)
                 {
                     _parent = parent;
                     _self = self;
@@ -617,11 +617,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class β : Sink<IList<TSource>>, IObserver<TSource>
+        class Beta : Sink<IList<TSource>>, IObserver<TSource>
         {
             private readonly Buffer<TSource, TBufferClosing> _parent;
 
-            public β(Buffer<TSource, TBufferClosing> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
+            public Beta(Buffer<TSource, TBufferClosing> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -641,16 +641,16 @@ namespace System.Reactive.Linq.Observαble
                 _refCountDisposable = new RefCountDisposable(d);
 
                 d.Add(_parent._source.SubscribeSafe(this));
-                d.Add(_parent._bufferBoundaries.SubscribeSafe(new ω(this)));
+                d.Add(_parent._bufferBoundaries.SubscribeSafe(new Omega(this)));
 
                 return _refCountDisposable;
             }
 
-            class ω : IObserver<TBufferClosing>
+            class Omega : IObserver<TBufferClosing>
             {
-                private readonly β _parent;
+                private readonly Beta _parent;
 
-                public ω(β parent)
+                public Omega(Beta parent)
                 {
                     _parent = parent;
                 }

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Case.cs

@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Case<TValue, TResult> : Producer<TResult>, IEvaluatableObservable<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Cast.cs

@@ -3,9 +3,9 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
-    class Cast<TSource, TResult> : Producer<TResult> /* Could optimize further by deriving from Select<TResult> and providing Ω<TResult2>. We're not doing this (yet) for debuggability. */
+    class Cast<TSource, TResult> : Producer<TResult> /* Could optimize further by deriving from Select<TResult> and providing Omega<TResult2>. We're not doing this (yet) for debuggability. */
     {
         private readonly IObservable<TSource> _source;
 

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Catch.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Catch<TSource> : Producer<TSource>
     {
@@ -136,7 +136,7 @@ namespace System.Reactive.Linq.Observαble
 
                     var d = new SingleAssignmentDisposable();
                     _subscription.Disposable = d;
-                    d.Disposable = result.SubscribeSafe(new ε(this));
+                    d.Disposable = result.SubscribeSafe(new Impl(this));
                 }
                 else
                 {
@@ -151,11 +151,11 @@ namespace System.Reactive.Linq.Observαble
                 base.Dispose();
             }
 
-            class ε : IObserver<TSource>
+            class Impl : IObserver<TSource>
             {
                 private readonly _ _parent;
 
-                public ε(_ parent)
+                public Impl(_ parent)
                 {
                     _parent = parent;
                 }

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Collect.cs

@@ -7,7 +7,7 @@ using System.Reactive;
 using System.Reactive.Threading;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Collect<TSource, TResult> : PushToPullAdapter<TSource, TResult>
     {

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

@@ -7,7 +7,7 @@ using System.Collections.ObjectModel;
 using System.Linq;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     #region Binary
 

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Concat.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Concat<TSource> : Producer<TSource>, IConcatenatable<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Contains.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Contains<TSource> : Producer<bool>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Count.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Count<TSource> : Producer<int>
     {
@@ -31,7 +31,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new π(this, observer, cancel);
+                var sink = new CountImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -77,12 +77,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class π : Sink<int>, IObserver<TSource>
+        class CountImpl : Sink<int>, IObserver<TSource>
         {
             private readonly Count<TSource> _parent;
             private int _count;
 
-            public π(Count<TSource> parent, IObserver<int> observer, IDisposable cancel)
+            public CountImpl(Count<TSource> parent, IObserver<int> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/DefaultIfEmpty.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class DefaultIfEmpty<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Defer.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Defer<TValue> : Producer<TValue>, IEvaluatableObservable<TValue>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Delay.cs

@@ -10,7 +10,7 @@ using System.Threading;
 using System.Reactive.Threading;
 #endif
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Delay<TSource> : Producer<TSource>
     {
@@ -37,7 +37,7 @@ namespace System.Reactive.Linq.Observαble
         {
             if (_scheduler.AsLongRunning() != null)
             {
-                var sink = new λ(this, observer, cancel);
+                var sink = new LongRunningImpl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -227,9 +227,9 @@ namespace System.Reactive.Linq.Observαble
                 // implementation, the loop below kept running while there was work for immediate dispatch,
                 // potentially causing a long running work item on the target scheduler. With the addition
                 // of long-running scheduling in Rx v2.0, we can check whether the scheduler supports this
-                // interface and perform different processing (see λ). To reduce the code churn in the old
-                // loop code here, we set the shouldYield flag to true after the first dispatch iteration,
-                // in order to break from the loop and enter the recursive scheduling path.
+                // interface and perform different processing (see LongRunningImpl). To reduce the code 
+                // churn in the old loop code here, we set the shouldYield flag to true after the first 
+                // dispatch iteration, in order to break from the loop and enter the recursive scheduling path.
                 //
                 var shouldYield = false;
 
@@ -322,11 +322,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class λ : Sink<TSource>, IObserver<TSource>
+        class LongRunningImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly Delay<TSource> _parent;
 
-            public λ(Delay<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public LongRunningImpl(Delay<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -629,7 +629,7 @@ namespace System.Reactive.Linq.Observαble
                 }
                 else
                 {
-                    _subscription.Disposable = _parent._subscriptionDelay.SubscribeSafe(new σ(this));
+                    _subscription.Disposable = _parent._subscriptionDelay.SubscribeSafe(new SubscriptionDelay(this));
                 }
 
                 return new CompositeDisposable(_subscription, _delays);
@@ -660,7 +660,7 @@ namespace System.Reactive.Linq.Observαble
 
                 var d = new SingleAssignmentDisposable();
                 _delays.Add(d);
-                d.Disposable = delay.SubscribeSafe(new δ(this, value, d));
+                d.Disposable = delay.SubscribeSafe(new Delta(this, value, d));
             }
 
             public void OnError(Exception error)
@@ -692,11 +692,11 @@ namespace System.Reactive.Linq.Observαble
                 }
             }
 
-            class σ : IObserver<TDelay>
+            class SubscriptionDelay : IObserver<TDelay>
             {
                 private readonly _ _parent;
 
-                public σ(_ parent)
+                public SubscriptionDelay(_ parent)
                 {
                     _parent = parent;
                 }
@@ -718,13 +718,13 @@ namespace System.Reactive.Linq.Observαble
                 }
             }
 
-            class δ : IObserver<TDelay>
+            class Delta : IObserver<TDelay>
             {
                 private readonly _ _parent;
                 private readonly TSource _value;
                 private readonly IDisposable _self;
 
-                public δ(_ parent, TSource value, IDisposable self)
+                public Delta(_ parent, TSource value, IDisposable self)
                 {
                     _parent = parent;
                     _value = value;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/DelaySubscription.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Concurrency;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class DelaySubscription<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Dematerialize.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Dematerialize<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Distinct.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Distinct<TSource, TKey> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/DistinctUntilChanged.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class DistinctUntilChanged<TSource, TKey> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Do.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Do<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/DoWhile.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class DoWhile<TSource> : Producer<TSource>, IConcatenatable<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/ElementAt.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class ElementAt<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Empty.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Concurrency;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Empty<TResult> : Producer<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Finally.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Finally<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/FirstAsync.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class FirstAsync<TSource> : Producer<TSource>
     {
@@ -22,7 +22,7 @@ namespace System.Reactive.Linq.Observαble
         {
             if (_predicate != null)
             {
-                var sink = new π(this, observer, cancel);
+                var sink = new FirstAsyncImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -73,11 +73,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class π : Sink<TSource>, IObserver<TSource>
+        class FirstAsyncImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly FirstAsync<TSource> _parent;
 
-            public π(FirstAsync<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public FirstAsyncImpl(FirstAsync<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/For.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class For<TSource, TResult> : Producer<TResult>, IConcatenatable<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/ForEach.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class ForEach<TSource>
     {
@@ -62,7 +62,7 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        public class τ : IObserver<TSource>
+        public class ForEachImpl : IObserver<TSource>
         {
             private readonly Action<TSource, int> _onNext;
             private readonly Action _done;
@@ -71,7 +71,7 @@ namespace System.Reactive.Linq.Observαble
             private Exception _exception;
             private int _stopped;
 
-            public τ(Action<TSource, int> onNext, Action done)
+            public ForEachImpl(Action<TSource, int> onNext, Action done)
             {
                 _onNext = onNext;
                 _done = done;

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

@@ -156,7 +156,7 @@ using System.Reactive.Subjects;
 // subject (which is opaque to the event producer). Not to mention that the subject would always be
 // rooted by the target event (even when the FromEvent[Pattern] observable wrapper is unreachable).
 //
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class FromEvent<TDelegate, TEventArgs> : ClassicEventProducer<TDelegate, TEventArgs>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/FromEventPattern.cs

@@ -12,23 +12,23 @@ using System.Threading;
 //
 // See FromEvent.cs for more information.
 //
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class FromEventPattern
     {
-        public class τ<TDelegate, TEventArgs> : ClassicEventProducer<TDelegate, EventPattern<TEventArgs>>
+        public class Impl<TDelegate, TEventArgs> : ClassicEventProducer<TDelegate, EventPattern<TEventArgs>>
 #if !NO_EVENTARGS_CONSTRAINT
             where TEventArgs : EventArgs
 #endif
         {
             private readonly Func<EventHandler<TEventArgs>, TDelegate> _conversion;
 
-            public τ(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)
+            public Impl(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)
                 : base(addHandler, removeHandler, scheduler)
             {
             }
 
-            public τ(Func<EventHandler<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)
+            public Impl(Func<EventHandler<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)
                 : base(addHandler, removeHandler, scheduler)
             {
                 _conversion = conversion;
@@ -52,12 +52,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        public class τ<TDelegate, TSender, TEventArgs> : ClassicEventProducer<TDelegate, EventPattern<TSender, TEventArgs>>
+        public class Impl<TDelegate, TSender, TEventArgs> : ClassicEventProducer<TDelegate, EventPattern<TSender, TEventArgs>>
 #if !NO_EVENTARGS_CONSTRAINT
             where TEventArgs : EventArgs
 #endif
         {
-            public τ(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)
+            public Impl(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler)
                 : base(addHandler, removeHandler, scheduler)
             {
             }
@@ -69,7 +69,7 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        public class ρ<TSender, TEventArgs, TResult> : EventProducer<Delegate, TResult>
+        public class Handler<TSender, TEventArgs, TResult> : EventProducer<Delegate, TResult>
         {
             private readonly object _target;
             private readonly Type _delegateType;
@@ -80,7 +80,7 @@ namespace System.Reactive.Linq.Observαble
             private readonly bool _isWinRT;
 #endif
 
-            public ρ(object target, Type delegateType, MethodInfo addMethod, MethodInfo removeMethod, Func<TSender, TEventArgs, TResult> getResult, bool isWinRT, IScheduler scheduler)
+            public Handler(object target, Type delegateType, MethodInfo addMethod, MethodInfo removeMethod, Func<TSender, TEventArgs, TResult> getResult, bool isWinRT, IScheduler scheduler)
                 : base(scheduler)
             {
 #if HAS_WINRT

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Generate.cs

@@ -7,7 +7,7 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Generate<TState, TResult> : Producer<TResult>
     {
@@ -52,13 +52,13 @@ namespace System.Reactive.Linq.Observαble
         {
             if (_timeSelectorA != null)
             {
-                var sink = new α(this, observer, cancel);
+                var sink = new SelectorA(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
             else if (_timeSelectorR != null)
             {
-                var sink = new δ(this, observer, cancel);
+                var sink = new Delta(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -70,11 +70,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class α : Sink<TResult>
+        class SelectorA : Sink<TResult>
         {
             private readonly Generate<TState, TResult> _parent;
 
-            public α(Generate<TState, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
+            public SelectorA(Generate<TState, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -130,11 +130,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class δ : Sink<TResult>
+        class Delta : Sink<TResult>
         {
             private readonly Generate<TState, TResult> _parent;
 
-            public δ(Generate<TState, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
+            public Delta(Generate<TState, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/GetEnumerator.cs

@@ -8,7 +8,7 @@ using System.Diagnostics;
 using System.Reactive.Disposables;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class GetEnumerator<TSource> : IEnumerator<TSource>, IObserver<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/GroupBy.cs

@@ -7,7 +7,7 @@ using System.Linq;
 using System.Reactive.Disposables;
 using System.Reactive.Subjects;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class GroupBy<TSource, TKey, TElement> : Producer<IGroupedObservable<TKey, TElement>>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/GroupByUntil.cs

@@ -7,7 +7,7 @@ using System.Linq;
 using System.Reactive.Disposables;
 using System.Reactive.Subjects;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class GroupByUntil<TSource, TKey, TElement, TDuration> : Producer<IGroupedObservable<TKey, TElement>>
     {
@@ -129,7 +129,7 @@ namespace System.Reactive.Linq.Observαble
 
                     var md = new SingleAssignmentDisposable();
                     _parent._groupDisposable.Add(md);
-                    md.Disposable = duration.SubscribeSafe(new δ(this, key, writer, md));
+                    md.Disposable = duration.SubscribeSafe(new Delta(this, key, writer, md));
                 }
 
                 var element = default(TElement);
@@ -165,14 +165,14 @@ namespace System.Reactive.Linq.Observαble
                     writer.OnNext(element);
             }
 
-            class δ : IObserver<TDuration>
+            class Delta : IObserver<TDuration>
             {
                 private readonly _ _parent;
                 private readonly TKey _key;
                 private readonly ISubject<TElement> _writer;
                 private readonly IDisposable _self;
 
-                public δ(_ parent, TKey key, ISubject<TElement> writer, IDisposable self)
+                public Delta(_ parent, TKey key, ISubject<TElement> writer, IDisposable self)
                 {
                     _parent = parent;
                     _key = key;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/GroupJoin.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using System.Reactive.Disposables;
 using System.Reactive.Subjects;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult> : Producer<TResult>
     {
@@ -68,18 +68,18 @@ namespace System.Reactive.Linq.Observαble
                 _rightID = 0;
                 _rightMap = new Dictionary<int, TRight>();
 
-                leftSubscription.Disposable = _parent._left.SubscribeSafe(new λ(this, leftSubscription));
-                rightSubscription.Disposable = _parent._right.SubscribeSafe(new ρ(this, rightSubscription));
+                leftSubscription.Disposable = _parent._left.SubscribeSafe(new LeftObserver(this, leftSubscription));
+                rightSubscription.Disposable = _parent._right.SubscribeSafe(new RightObserver(this, rightSubscription));
 
                 return _refCount;
             }
 
-            class λ : IObserver<TLeft>
+            class LeftObserver : IObserver<TLeft>
             {
                 private readonly _ _parent;
                 private readonly IDisposable _self;
 
-                public λ(_ parent, IDisposable self)
+                public LeftObserver(_ parent, IDisposable self)
                 {
                     _parent = parent;
                     _self = self;
@@ -122,7 +122,7 @@ namespace System.Reactive.Linq.Observαble
                     }
 
                     // BREAKING CHANGE v2 > v1.x - The duration sequence is subscribed to before the result sequence is evaluated.
-                    md.Disposable = duration.SubscribeSafe(new δ(this, id, s, md));
+                    md.Disposable = duration.SubscribeSafe(new Delta(this, id, s, md));
 
                     var result = default(TResult);
                     try
@@ -146,14 +146,14 @@ namespace System.Reactive.Linq.Observαble
                     }
                 }
 
-                class δ : IObserver<TLeftDuration>
+                class Delta : IObserver<TLeftDuration>
                 {
-                    private readonly λ _parent;
+                    private readonly LeftObserver _parent;
                     private readonly int _id;
                     private readonly IObserver<TRight> _group;
                     private readonly IDisposable _self;
 
-                    public δ(λ parent, int id, IObserver<TRight> group, IDisposable self)
+                    public Delta(LeftObserver parent, int id, IObserver<TRight> group, IDisposable self)
                     {
                         _parent = parent;
                         _id = id;
@@ -201,12 +201,12 @@ namespace System.Reactive.Linq.Observαble
                 }
             }
 
-            class ρ : IObserver<TRight>
+            class RightObserver : IObserver<TRight>
             {
                 private readonly _ _parent;
                 private readonly IDisposable _self;
 
-                public ρ(_ parent, IDisposable self)
+                public RightObserver(_ parent, IDisposable self)
                 {
                     _parent = parent;
                     _self = self;
@@ -242,7 +242,7 @@ namespace System.Reactive.Linq.Observαble
                         OnError(exception);
                         return;
                     }
-                    md.Disposable = duration.SubscribeSafe(new δ(this, id, md));
+                    md.Disposable = duration.SubscribeSafe(new Delta(this, id, md));
 
                     lock (_parent._gate)
                     {
@@ -251,13 +251,13 @@ namespace System.Reactive.Linq.Observαble
                     }
                 }
 
-                class δ : IObserver<TRightDuration>
+                class Delta : IObserver<TRightDuration>
                 {
-                    private readonly ρ _parent;
+                    private readonly RightObserver _parent;
                     private readonly int _id;
                     private readonly IDisposable _self;
 
-                    public δ(ρ parent, int id, IDisposable self)
+                    public Delta(RightObserver parent, int id, IDisposable self)
                     {
                         _parent = parent;
                         _id = id;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/If.cs

@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class If<TResult> : Producer<TResult>, IEvaluatableObservable<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/IgnoreElements.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class IgnoreElements<TSource> : Producer<TSource>
     {
@@ -14,7 +14,7 @@ namespace System.Reactive.Linq.Observαble
             _source = source;
         }
 
-        public IObservable<TSource> Ω()
+        public IObservable<TSource> Omega()
         {
             return this;
         }

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/IsEmpty.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class IsEmpty<TSource> : Producer<bool>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Join.cs

@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Join<TLeft, TRight, TLeftDuration, TRightDuration, TResult> : Producer<TResult>
     {
@@ -69,18 +69,18 @@ namespace System.Reactive.Linq.Observαble
                 _rightID = 0;
                 _rightMap = new Dictionary<int, TRight>();
 
-                leftSubscription.Disposable = _parent._left.SubscribeSafe(new λ(this, leftSubscription));
-                rightSubscription.Disposable = _parent._right.SubscribeSafe(new ρ(this, rightSubscription));
+                leftSubscription.Disposable = _parent._left.SubscribeSafe(new LeftObserver(this, leftSubscription));
+                rightSubscription.Disposable = _parent._right.SubscribeSafe(new RightObserver(this, rightSubscription));
 
                 return _group;
             }
 
-            class λ : IObserver<TLeft>
+            class LeftObserver : IObserver<TLeft>
             {
                 private readonly _ _parent;
                 private readonly IDisposable _self;
 
-                public λ(_ parent, IDisposable self)
+                public LeftObserver(_ parent, IDisposable self)
                 {
                     _parent = parent;
                     _self = self;
@@ -124,7 +124,7 @@ namespace System.Reactive.Linq.Observαble
                         return;
                     }
 
-                    md.Disposable = duration.SubscribeSafe(new δ(this, id, md));
+                    md.Disposable = duration.SubscribeSafe(new Delta(this, id, md));
 
                     lock (_parent._gate)
                     {
@@ -147,13 +147,13 @@ namespace System.Reactive.Linq.Observαble
                     }
                 }
 
-                class δ : IObserver<TLeftDuration>
+                class Delta : IObserver<TLeftDuration>
                 {
-                    private readonly λ _parent;
+                    private readonly LeftObserver _parent;
                     private readonly int _id;
                     private readonly IDisposable _self;
 
-                    public δ(λ parent, int id, IDisposable self)
+                    public Delta(LeftObserver parent, int id, IDisposable self)
                     {
                         _parent = parent;
                         _id = id;
@@ -203,12 +203,12 @@ namespace System.Reactive.Linq.Observαble
                 }
             }
 
-            class ρ : IObserver<TRight>
+            class RightObserver : IObserver<TRight>
             {
                 private readonly _ _parent;
                 private readonly IDisposable _self;
 
-                public ρ(_ parent, IDisposable self)
+                public RightObserver(_ parent, IDisposable self)
                 {
                     _parent = parent;
                     _self = self;
@@ -252,7 +252,7 @@ namespace System.Reactive.Linq.Observαble
                         return;
                     }
 
-                    md.Disposable = duration.SubscribeSafe(new δ(this, id, md));
+                    md.Disposable = duration.SubscribeSafe(new Delta(this, id, md));
 
                     lock (_parent._gate)
                     {
@@ -275,13 +275,13 @@ namespace System.Reactive.Linq.Observαble
                     }
                 }
 
-                class δ : IObserver<TRightDuration>
+                class Delta : IObserver<TRightDuration>
                 {
-                    private readonly ρ _parent;
+                    private readonly RightObserver _parent;
                     private readonly int _id;
                     private readonly IDisposable _self;
 
-                    public δ(ρ parent, int id, IDisposable self)
+                    public Delta(RightObserver parent, int id, IDisposable self)
                     {
                         _parent = parent;
                         _id = id;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/LastAsync.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class LastAsync<TSource> : Producer<TSource>
     {
@@ -22,7 +22,7 @@ namespace System.Reactive.Linq.Observαble
         {
             if (_predicate != null)
             {
-                var sink = new π(this, observer, cancel);
+                var sink = new LastAsyncImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -77,13 +77,13 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class π : Sink<TSource>, IObserver<TSource>
+        class LastAsyncImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly LastAsync<TSource> _parent;
             private TSource _value;
             private bool _seenValue;
 
-            public π(LastAsync<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public LastAsyncImpl(LastAsync<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Latest.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using System.Reactive.Threading;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Latest<TSource> : PushToPullAdapter<TSource, TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/LongCount.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class LongCount<TSource> : Producer<long>
     {
@@ -31,7 +31,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new π(this, observer, cancel);
+                var sink = new LongCountImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -77,12 +77,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class π : Sink<long>, IObserver<TSource>
+        class LongCountImpl : Sink<long>, IObserver<TSource>
         {
             private readonly LongCount<TSource> _parent;
             private long _count;
 
-            public π(LongCount<TSource> parent, IObserver<long> observer, IDisposable cancel)
+            public LongCountImpl(LongCount<TSource> parent, IObserver<long> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Materialize.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Materialize<TSource> : Producer<Notification<TSource>>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Max.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Max<TSource> : Producer<TSource>
     {
@@ -28,19 +28,19 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new δ(this, observer, cancel);
+                var sink = new Delta(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
         }
 
-        class δ : Sink<TSource>, IObserver<TSource>
+        class Delta : Sink<TSource>, IObserver<TSource>
         {
             private readonly Max<TSource> _parent;
             private bool _hasValue;
             private TSource _lastValue;
 
-            public δ(Max<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public Delta(Max<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/MaxBy.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class MaxBy<TSource, TKey> : Producer<IList<TSource>>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Merge.cs

@@ -10,7 +10,7 @@ using System.Threading;
 using System.Threading.Tasks;
 #endif
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Merge<TSource> : Producer<TSource>
     {
@@ -41,14 +41,14 @@ namespace System.Reactive.Linq.Observαble
         {
             if (_maxConcurrent > 0)
             {
-                var sink = new μ(this, observer, cancel);
+                var sink = new MergeConcurrent(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
 #if !NO_TPL
             else if (_sourcesT != null)
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new MergeImpl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -93,7 +93,7 @@ namespace System.Reactive.Linq.Observαble
             {
                 var innerSubscription = new SingleAssignmentDisposable();
                 _group.Add(innerSubscription);
-                innerSubscription.Disposable = value.SubscribeSafe(new ι(this, innerSubscription));
+                innerSubscription.Disposable = value.SubscribeSafe(new Iter(this, innerSubscription));
             }
 
             public void OnError(Exception error)
@@ -129,12 +129,12 @@ namespace System.Reactive.Linq.Observαble
                 }
             }
 
-            class ι : IObserver<TSource>
+            class Iter : IObserver<TSource>
             {
                 private readonly _ _parent;
                 private readonly IDisposable _self;
 
-                public ι(_ parent, IDisposable self)
+                public Iter(_ parent, IDisposable self)
                 {
                     _parent = parent;
                     _self = self;
@@ -177,11 +177,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class μ : Sink<TSource>, IObserver<IObservable<TSource>>
+        class MergeConcurrent : Sink<TSource>, IObserver<IObservable<TSource>>
         {
             private readonly Merge<TSource> _parent;
 
-            public μ(Merge<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public MergeConcurrent(Merge<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -253,15 +253,15 @@ namespace System.Reactive.Linq.Observαble
             {
                 var subscription = new SingleAssignmentDisposable();
                 _group.Add(subscription);
-                subscription.Disposable = innerSource.SubscribeSafe(new ι(this, subscription));
+                subscription.Disposable = innerSource.SubscribeSafe(new Iter(this, subscription));
             }
 
-            class ι : IObserver<TSource>
+            class Iter : IObserver<TSource>
             {
-                private readonly μ _parent;
+                private readonly MergeConcurrent _parent;
                 private readonly IDisposable _self;
 
-                public ι(μ parent, IDisposable self)
+                public Iter(MergeConcurrent parent, IDisposable self)
                 {
                     _parent = parent;
                     _self = self;
@@ -308,11 +308,11 @@ namespace System.Reactive.Linq.Observαble
 
 #if !NO_TPL
 #pragma warning disable 0420
-        class τ : Sink<TSource>, IObserver<Task<TSource>>
+        class MergeImpl : Sink<TSource>, IObserver<Task<TSource>>
         {
             private readonly Merge<TSource> _parent;
 
-            public τ(Merge<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public MergeImpl(Merge<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Min.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Min<TSource> : Producer<TSource>
     {
@@ -28,19 +28,19 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new δ(this, observer, cancel);
+                var sink = new Delta(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
         }
 
-        class δ : Sink<TSource>, IObserver<TSource>
+        class Delta : Sink<TSource>, IObserver<TSource>
         {
             private readonly Min<TSource> _parent;
             private bool _hasValue;
             private TSource _lastValue;
 
-            public δ(Min<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public Delta(Min<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/MinBy.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class MinBy<TSource, TKey> : Producer<IList<TSource>>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/MostRecent.cs

@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class MostRecent<TSource> : PushToPullAdapter<TSource, TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Multicast.cs

@@ -5,7 +5,7 @@ using System;
 using System.Reactive.Disposables;
 using System.Reactive.Subjects;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Multicast<TSource, TIntermediate, TResult> : Producer<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Never.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Never<TResult> : IObservable<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Next.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using System.Reactive.Threading;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Next<TSource> : PushToPullAdapter<TSource, TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/ObserveOn.cs

@@ -5,7 +5,7 @@ using System;
 using System.Reactive.Concurrency;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class ObserveOn<TSource> : Producer<TSource>
     {
@@ -33,7 +33,7 @@ namespace System.Reactive.Linq.Observαble
 #if !NO_SYNCCTX
             if (_context != null)
             {
-                var sink = new ς(this, observer, cancel);
+                var sink = new ObserveOnImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.Subscribe(sink);
             }
@@ -47,11 +47,11 @@ namespace System.Reactive.Linq.Observαble
         }
 
 #if !NO_SYNCCTX
-        class ς : Sink<TSource>, IObserver<TSource>
+        class ObserveOnImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly ObserveOn<TSource> _parent;
 
-            public ς(ObserveOn<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public ObserveOnImpl(ObserveOn<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/OfType.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class OfType<TSource, TResult> : Producer<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/OnErrorResumeNext.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class OnErrorResumeNext<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/OrderBy.cs

@@ -7,7 +7,7 @@ using System.Linq;
 using System.Reactive.Disposables;
 using System.Reactive.Subjects;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class OrderBy<TSource, TKey> : OrderedProducer<TSource>, IOrderedObservable<TSource>
     {
@@ -46,9 +46,9 @@ namespace System.Reactive.Linq.Observαble
             _descending = descending;
         }
 
-        public IOrderedObservable<TSource> CreateOrderedObservable<TKey>(Func<TSource, TKey> keySelector, IComparer<TKey> comparer, bool descending)
+        public IOrderedObservable<TSource> CreateOrderedObservable<TTKey>(Func<TSource, TTKey> keySelector, IComparer<TTKey> comparer, bool descending)
         {
-            return new OrderBy<TSource, TKey>(base._source, keySelector, comparer, descending, previous: this);
+            return new OrderBy<TSource, TTKey>(base._source, keySelector, comparer, descending, previous: this);
         }
 
         public IOrderedObservable<TSource> CreateOrderedObservable<TOther>(Func<TSource, IObservable<TOther>> timeSelector, bool descending)

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/PushToPullAdapter.cs

@@ -5,7 +5,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     abstract class PushToPullAdapter<TSource, TResult> : IEnumerable<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Range.cs

@@ -5,7 +5,7 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Range : Producer<int>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/RefCount.cs

@@ -5,7 +5,7 @@ using System;
 using System.Reactive.Disposables;
 using System.Reactive.Subjects;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class RefCount<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Repeat.cs

@@ -5,7 +5,7 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Repeat<TResult> : Producer<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Return.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Concurrency;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Return<TResult> : Producer<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Sample.cs

@@ -5,7 +5,7 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Sample<TSource, TSample> : Producer<TSource>
     {
@@ -51,7 +51,7 @@ namespace System.Reactive.Linq.Observαble
                 _sourceSubscription = sourceSubscription;
                 sourceSubscription.Disposable = _parent._source.SubscribeSafe(this);
 
-                var samplerSubscription = _parent._sampler.SubscribeSafe(new σ(this));
+                var samplerSubscription = _parent._sampler.SubscribeSafe(new SampleImpl(this));
 
                 return new CompositeDisposable(_sourceSubscription, samplerSubscription);
             }
@@ -83,11 +83,11 @@ namespace System.Reactive.Linq.Observαble
                 }
             }
 
-            class σ : IObserver<TSample>
+            class SampleImpl : IObserver<TSample>
             {
                 private readonly _ _parent;
 
-                public σ(_ parent)
+                public SampleImpl(_ parent)
                 {
                     _parent = parent;
                 }

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Scan.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Scan<TSource, TAccumulate> : Producer<TAccumulate>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Select.cs

@@ -3,11 +3,11 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     abstract class Select<TResult> : Producer<TResult>
     {
-        public abstract IObservable<TResult2> Ω<TResult2>(Func<TResult, TResult2> selector);
+        public abstract IObservable<TResult2> Omega<TResult2>(Func<TResult, TResult2> selector);
     }
 
     class Select<TSource, TResult> : Select<TResult>
@@ -28,7 +28,7 @@ namespace System.Reactive.Linq.Observαble
             _selectorI = selector;
         }
 
-        public override IObservable<TResult2> Ω<TResult2>(Func<TResult, TResult2> selector)
+        public override IObservable<TResult2> Omega<TResult2>(Func<TResult, TResult2> selector)
         {
             if (_selector != null)
                 return new Select<TSource, TResult2>(_source, x => selector(_selector(x)));
@@ -46,7 +46,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new SelectImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -92,12 +92,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class τ : Sink<TResult>, IObserver<TSource>
+        class SelectImpl : Sink<TResult>, IObserver<TSource>
         {
             private readonly Select<TSource, TResult> _parent;
             private int _index;
 
-            public τ(Select<TSource, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
+            public SelectImpl(Select<TSource, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/SelectMany.cs

@@ -11,7 +11,7 @@ using System.Threading;
 using System.Threading.Tasks;
 #endif
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class SelectMany<TSource, TCollection, TResult> : Producer<TResult>
     {
@@ -73,14 +73,14 @@ namespace System.Reactive.Linq.Observαble
 #if !NO_TPL
             else if (_collectionSelectorT != null)
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new SelectManyImpl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
 #endif
             else
             {
-                var sink = new ε(this, observer, cancel);
+                var sink = new NoSelectorImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -142,7 +142,7 @@ namespace System.Reactive.Linq.Observαble
 
                 var innerSubscription = new SingleAssignmentDisposable();
                 _group.Add(innerSubscription);
-                innerSubscription.Disposable = collection.SubscribeSafe(new ι(this, value, innerSubscription, _indexInSource));
+                innerSubscription.Disposable = collection.SubscribeSafe(new Iter(this, value, innerSubscription, _indexInSource));
             }
 
             public void OnError(Exception error)
@@ -178,7 +178,7 @@ namespace System.Reactive.Linq.Observαble
                 }
             }
 
-            class ι : IObserver<TCollection>
+            class Iter : IObserver<TCollection>
             {
                 private readonly _ _parent;
                 private readonly TSource _value;
@@ -186,7 +186,7 @@ namespace System.Reactive.Linq.Observαble
                 private int _indexInSource;
                 private int _indexInIntermediate = -1;
 
-                public ι(_ parent, TSource value, IDisposable self, int indexInSource)
+                public Iter(_ parent, TSource value, IDisposable self, int indexInSource)
                 {
                     _parent = parent;
                     _value = value;
@@ -254,12 +254,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class ε : Sink<TResult>, IObserver<TSource>
+        class NoSelectorImpl : Sink<TResult>, IObserver<TSource>
         {
             private readonly SelectMany<TSource, TCollection, TResult> _parent;
             private int _indexInSource;   // The "Weird SelectMany" requires indices in the original collection as well as an intermediate collection
 
-            public ε(SelectMany<TSource, TCollection, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
+            public NoSelectorImpl(SelectMany<TSource, TCollection, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -354,11 +354,11 @@ namespace System.Reactive.Linq.Observαble
 
 #if !NO_TPL
 #pragma warning disable 0420
-        class τ : Sink<TResult>, IObserver<TSource>
+        class SelectManyImpl : Sink<TResult>, IObserver<TSource>
         {
             private readonly SelectMany<TSource, TCollection, TResult> _parent;
 
-            public τ(SelectMany<TSource, TCollection, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
+            public SelectManyImpl(SelectMany<TSource, TCollection, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -564,14 +564,14 @@ namespace System.Reactive.Linq.Observαble
 #if !NO_TPL
             else if (_selectorT != null)
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new SelectManyImpl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
 #endif
             else
             {
-                var sink = new ε(this, observer, cancel);
+                var sink = new NoSelectorImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -731,15 +731,15 @@ namespace System.Reactive.Linq.Observαble
             {
                 var innerSubscription = new SingleAssignmentDisposable();
                 _group.Add(innerSubscription);
-                innerSubscription.Disposable = inner.SubscribeSafe(new ι(this, innerSubscription));
+                innerSubscription.Disposable = inner.SubscribeSafe(new Iter(this, innerSubscription));
             }
 
-            class ι : IObserver<TResult>
+            class Iter : IObserver<TResult>
             {
                 private readonly _ _parent;
                 private readonly IDisposable _self;
 
-                public ι(_ parent, IDisposable self)
+                public Iter(_ parent, IDisposable self)
                 {
                     _parent = parent;
                     _self = self;
@@ -782,12 +782,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class ε : Sink<TResult>, IObserver<TSource>
+        class NoSelectorImpl : Sink<TResult>, IObserver<TSource>
         {
             private readonly SelectMany<TSource, TResult> _parent;
             private int _index;
 
-            public ε(SelectMany<TSource, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
+            public NoSelectorImpl(SelectMany<TSource, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -873,11 +873,11 @@ namespace System.Reactive.Linq.Observαble
 
 #if !NO_TPL
 #pragma warning disable 0420
-        class τ : Sink<TResult>, IObserver<TSource>
+        class SelectManyImpl : Sink<TResult>, IObserver<TSource>
         {
             private readonly SelectMany<TSource, TResult> _parent;
 
-            public τ(SelectMany<TSource, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
+            public SelectManyImpl(SelectMany<TSource, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/SequenceEqual.cs

@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class SequenceEqual<TSource> : Producer<bool>
     {
@@ -38,7 +38,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new ε(this, observer, cancel);
+                var sink = new SequenceEqualImpl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -226,11 +226,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class ε : Sink<bool>, IObserver<TSource>
+        class SequenceEqualImpl : Sink<bool>, IObserver<TSource>
         {
             private readonly SequenceEqual<TSource> _parent;
 
-            public ε(SequenceEqual<TSource> parent, IObserver<bool> observer, IDisposable cancel)
+            public SequenceEqualImpl(SequenceEqual<TSource> parent, IObserver<bool> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/SingleAsync.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class SingleAsync<TSource> : Producer<TSource>
     {
@@ -22,7 +22,7 @@ namespace System.Reactive.Linq.Observαble
         {
             if (_predicate != null)
             {
-                var sink = new π(this, observer, cancel);
+                var sink = new SingleAsyncImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -84,13 +84,13 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class π : Sink<TSource>, IObserver<TSource>
+        class SingleAsyncImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly SingleAsync<TSource> _parent;
             private TSource _value;
             private bool _seenValue;
 
-            public π(SingleAsync<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public SingleAsyncImpl(SingleAsync<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Skip.cs

@@ -5,7 +5,7 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Skip<TSource> : Producer<TSource>
     {
@@ -27,7 +27,7 @@ namespace System.Reactive.Linq.Observαble
             _scheduler = scheduler;
         }
 
-        public IObservable<TSource> Ω(int count)
+        public IObservable<TSource> Omega(int count)
         {
             //
             // Sum semantics:
@@ -39,7 +39,7 @@ namespace System.Reactive.Linq.Observαble
             return new Skip<TSource>(_source, _count + count);
         }
 
-        public IObservable<TSource> Ω(TimeSpan duration)
+        public IObservable<TSource> Omega(TimeSpan duration)
         {
             //
             // Maximum semantics:
@@ -66,7 +66,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new SkipImpl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -105,12 +105,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class τ : Sink<TSource>, IObserver<TSource>
+        class SkipImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly Skip<TSource> _parent;
             private volatile bool _open;
 
-            public τ(Skip<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public SkipImpl(Skip<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/SkipLast.cs

@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Reactive.Concurrency;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class SkipLast<TSource> : Producer<TSource>
     {
@@ -37,7 +37,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new SkipLastImpl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -75,12 +75,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class τ : Sink<TSource>, IObserver<TSource>
+        class SkipLastImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly SkipLast<TSource> _parent;
             private Queue<System.Reactive.TimeInterval<TSource>> _queue;
 
-            public τ(SkipLast<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public SkipLastImpl(SkipLast<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/SkipUntil.cs

@@ -6,7 +6,7 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class SkipUntil<TSource, TOther> : Producer<TSource>
     {
@@ -140,7 +140,7 @@ namespace System.Reactive.Linq.Observαble
             _scheduler = scheduler;
         }
 
-        public IObservable<TSource> Ω(DateTimeOffset startTime)
+        public IObservable<TSource> Omega(DateTimeOffset startTime)
         {
             //
             // Maximum semantics:

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/SkipWhile.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class SkipWhile<TSource> : Producer<TSource>
     {
@@ -33,7 +33,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new SkipWhileImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -86,13 +86,13 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class τ : Sink<TSource>, IObserver<TSource>
+        class SkipWhileImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly SkipWhile<TSource> _parent;
             private bool _running;
             private int _index;
 
-            public τ(SkipWhile<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public SkipWhileImpl(SkipWhile<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Sum.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class SumDouble : Producer<double>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Switch.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Switch<TSource> : Producer<TSource>
     {
@@ -65,7 +65,7 @@ namespace System.Reactive.Linq.Observαble
 
                 var d = new SingleAssignmentDisposable();
                 _innerSubscription.Disposable = d;
-                d.Disposable = value.SubscribeSafe(new ι(this, id, d));
+                d.Disposable = value.SubscribeSafe(new Iter(this, id, d));
             }
 
             public void OnError(Exception error)
@@ -91,13 +91,13 @@ namespace System.Reactive.Linq.Observαble
                 }
             }
 
-            class ι : IObserver<TSource>
+            class Iter : IObserver<TSource>
             {
                 private readonly _ _parent;
                 private readonly ulong _id;
                 private readonly IDisposable _self;
 
-                public ι(_ parent, ulong id, IDisposable self)
+                public Iter(_ parent, ulong id, IDisposable self)
                 {
                     _parent = parent;
                     _id = id;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Synchronize.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Synchronize<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Take.cs

@@ -5,7 +5,7 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Take<TSource> : Producer<TSource>
     {
@@ -27,7 +27,7 @@ namespace System.Reactive.Linq.Observαble
             _scheduler = scheduler;
         }
 
-        public IObservable<TSource> Ω(int count)
+        public IObservable<TSource> Omega(int count)
         {
             //
             // Minimum semantics:
@@ -42,7 +42,7 @@ namespace System.Reactive.Linq.Observαble
                 return new Take<TSource>(_source, count);
         }
 
-        public IObservable<TSource> Ω(TimeSpan duration)
+        public IObservable<TSource> Omega(TimeSpan duration)
         {
             //
             // Minimum semantics:
@@ -69,7 +69,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new TakeImpl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -115,11 +115,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class τ : Sink<TSource>, IObserver<TSource>
+        class TakeImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly Take<TSource> _parent;
 
-            public τ(Take<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public TakeImpl(Take<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/TakeLast.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class TakeLast<TSource> : Producer<TSource>
     {
@@ -41,7 +41,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new TakeLastImpl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -131,12 +131,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class τ : Sink<TSource>, IObserver<TSource>
+        class TakeLastImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly TakeLast<TSource> _parent;
             private Queue<System.Reactive.TimeInterval<TSource>> _queue;
 
-            public τ(TakeLast<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public TakeLastImpl(TakeLast<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/TakeLastBuffer.cs

@@ -7,7 +7,7 @@ using System.Linq;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class TakeLastBuffer<TSource> : Producer<IList<TSource>>
     {
@@ -39,7 +39,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new Impl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -82,12 +82,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class τ : Sink<IList<TSource>>, IObserver<TSource>
+        class Impl : Sink<IList<TSource>>, IObserver<TSource>
         {
             private readonly TakeLastBuffer<TSource> _parent;
             private Queue<System.Reactive.TimeInterval<TSource>> _queue;
 
-            public τ(TakeLastBuffer<TSource> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
+            public Impl(TakeLastBuffer<TSource> parent, IObserver<IList<TSource>> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/TakeUntil.cs

@@ -6,7 +6,7 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class TakeUntil<TSource, TOther> : Producer<TSource>
     {
@@ -173,7 +173,7 @@ namespace System.Reactive.Linq.Observαble
             _scheduler = scheduler;
         }
 
-        public IObservable<TSource> Ω(DateTimeOffset endTime)
+        public IObservable<TSource> Omega(DateTimeOffset endTime)
         {
             //
             // Minimum semantics:

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/TakeWhile.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class TakeWhile<TSource> : Producer<TSource>
     {
@@ -33,7 +33,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new TakeWhileImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -91,13 +91,13 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class τ : Sink<TSource>, IObserver<TSource>
+        class TakeWhileImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly TakeWhile<TSource> _parent;
             private bool _running;
             private int _index;
 
-            public τ(TakeWhile<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public TakeWhileImpl(TakeWhile<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Throttle.cs

@@ -5,7 +5,7 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Throttle<TSource> : Producer<TSource>
     {
@@ -192,7 +192,7 @@ namespace System.Reactive.Linq.Observαble
 
                 var d = new SingleAssignmentDisposable();
                 _cancelable.Disposable = d;
-                d.Disposable = throttle.SubscribeSafe(new δ(this, value, currentid, d));
+                d.Disposable = throttle.SubscribeSafe(new Delta(this, value, currentid, d));
             }
 
             public void OnError(Exception error)
@@ -226,14 +226,14 @@ namespace System.Reactive.Linq.Observαble
                 }
             }
 
-            class δ : IObserver<TThrottle>
+            class Delta : IObserver<TThrottle>
             {
                 private readonly _ _parent;
                 private readonly TSource _value;
                 private readonly ulong _currentid;
                 private readonly IDisposable _self;
 
-                public δ(_ parent, TSource value, ulong currentid, IDisposable self)
+                public Delta(_ parent, TSource value, ulong currentid, IDisposable self)
                 {
                     _parent = parent;
                     _value = value;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Throw.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Concurrency;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Throw<TResult> : Producer<TResult>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/TimeInterval.cs

@@ -7,7 +7,7 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class TimeInterval<TSource> : Producer<System.Reactive.TimeInterval<TSource>>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Timeout.cs

@@ -5,7 +5,7 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Timeout<TSource> : Producer<TSource>
     {
@@ -35,23 +35,23 @@ namespace System.Reactive.Linq.Observαble
         {
             if (_dueTimeA.HasValue)
             {
-                var sink = new α(this, observer, cancel);
+                var sink = new TimeA(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
             else
             {
-                var sink = new ρ(this, observer, cancel);
+                var sink = new TimeR(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
         }
 
-        class α : Sink<TSource>, IObserver<TSource>
+        class TimeA : Sink<TSource>, IObserver<TSource>
         {
             private readonly Timeout<TSource> _parent;
 
-            public α(Timeout<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public TimeA(Timeout<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -136,11 +136,11 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class ρ : Sink<TSource>, IObserver<TSource>
+        class TimeR : Sink<TSource>, IObserver<TSource>
         {
             private readonly Timeout<TSource> _parent;
 
-            public ρ(Timeout<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public TimeR(Timeout<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;
@@ -358,16 +358,16 @@ namespace System.Reactive.Linq.Observαble
 
                 var d = new SingleAssignmentDisposable();
                 _timer.Disposable = d;
-                d.Disposable = timeout.SubscribeSafe(new τ(this, myid, d));
+                d.Disposable = timeout.SubscribeSafe(new TimeoutImpl(this, myid, d));
             }
 
-            class τ : IObserver<TTimeout>
+            class TimeoutImpl : IObserver<TTimeout>
             {
                 private readonly _ _parent;
                 private readonly ulong _id;
                 private readonly IDisposable _self;
 
-                public τ(_ parent, ulong id, IDisposable self)
+                public TimeoutImpl(_ parent, ulong id, IDisposable self)
                 {
                     _parent = parent;
                     _id = id;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Timer.cs

@@ -7,7 +7,7 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Timer : Producer<long>
     {
@@ -34,7 +34,7 @@ namespace System.Reactive.Linq.Observαble
         {
             if (_period.HasValue)
             {
-                var sink = new π(this, observer, cancel);
+                var sink = new TimerImpl(this, observer, cancel);
                 setSink(sink);
                 return sink.Run();
             }
@@ -76,12 +76,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class π : Sink<long>
+        class TimerImpl : Sink<long>
         {
             private readonly Timer _parent;
             private readonly TimeSpan _period;
 
-            public π(Timer parent, IObserver<long> observer, IDisposable cancel)
+            public TimerImpl(Timer parent, IObserver<long> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Timestamp.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Concurrency;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Timestamp<TSource> : Producer<Timestamped<TSource>>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/ToArray.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class ToArray<TSource> : Producer<TSource[]>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/ToDictionary.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class ToDictionary<TSource, TKey, TElement> : Producer<IDictionary<TKey, TElement>>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/ToList.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class ToList<TSource> : Producer<IList<TSource>>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/ToLookup.cs

@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class ToLookup<TSource, TKey, TElement> : Producer<ILookup<TKey, TElement>>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/ToObservable.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class ToObservable<TSource> : Producer<TSource>
     {

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Using.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Disposables;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Using<TSource, TResource> : Producer<TSource>
         where TResource : IDisposable

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Where.cs

@@ -3,7 +3,7 @@
 #if !NO_PERF
 using System;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class Where<TSource> : Producer<TSource>
     {
@@ -23,7 +23,7 @@ namespace System.Reactive.Linq.Observαble
             _predicateI = predicate;
         }
 
-        public IObservable<TSource> Ω(Func<TSource, bool> predicate)
+        public IObservable<TSource> Omega(Func<TSource, bool> predicate)
         {
             if (_predicate != null)
                 return new Where<TSource>(_source, x => _predicate(x) && predicate(x));
@@ -41,7 +41,7 @@ namespace System.Reactive.Linq.Observαble
             }
             else
             {
-                var sink = new τ(this, observer, cancel);
+                var sink = new WhereImpl(this, observer, cancel);
                 setSink(sink);
                 return _source.SubscribeSafe(sink);
             }
@@ -88,12 +88,12 @@ namespace System.Reactive.Linq.Observαble
             }
         }
 
-        class τ : Sink<TSource>, IObserver<TSource>
+        class WhereImpl : Sink<TSource>, IObserver<TSource>
         {
             private readonly Where<TSource> _parent;
             private int _index;
 
-            public τ(Where<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+            public WhereImpl(Where<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
                 : base(observer, cancel)
             {
                 _parent = parent;

Rx.NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/While.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace System.Reactive.Linq.Observαble
+namespace System.Reactive.Linq.ObservableImpl
 {
     class While<TSource> : Producer<TSource>, IConcatenatable<TSource>
     {