From 1b3573c1809b179d40f0b53658a9fe1bb4be43e5 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Mon, 13 Mar 2023 23:11:45 -0400
Subject: [PATCH 01/42] Target .NET 7

---
 Cycle.NET.Demo/Cycle.NET.Demo.csproj | 2 +-
 Cycle.NET/Cycle.NET.csproj           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cycle.NET.Demo/Cycle.NET.Demo.csproj b/Cycle.NET.Demo/Cycle.NET.Demo.csproj
index 894227f..3254220 100644
--- a/Cycle.NET.Demo/Cycle.NET.Demo.csproj
+++ b/Cycle.NET.Demo/Cycle.NET.Demo.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/Cycle.NET/Cycle.NET.csproj b/Cycle.NET/Cycle.NET.csproj
index e7aa633..44b3457 100644
--- a/Cycle.NET/Cycle.NET.csproj
+++ b/Cycle.NET/Cycle.NET.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

From e3e2b1dea4869b94bd07dcfbc5b57dc376419ee4 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Mon, 13 Mar 2023 23:14:18 -0400
Subject: [PATCH 02/42] Install sealed unions

---
 Cycle.NET/Cycle.NET.csproj | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Cycle.NET/Cycle.NET.csproj b/Cycle.NET/Cycle.NET.csproj
index 44b3457..ce9389a 100644
--- a/Cycle.NET/Cycle.NET.csproj
+++ b/Cycle.NET/Cycle.NET.csproj
@@ -5,7 +5,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.Reactive" Version="3.1.1" />
+    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.0" />
+    <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 
 </Project>

From 3a6c7634382d5e5e22dd8bc10070c4620f6b683b Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Tue, 14 Mar 2023 22:13:25 -0400
Subject: [PATCH 03/42] Finish initial Runner3

---
 Cycle.NET/Runner3.cs | 78 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 Cycle.NET/Runner3.cs

diff --git a/Cycle.NET/Runner3.cs b/Cycle.NET/Runner3.cs
new file mode 100644
index 0000000..27d3e7e
--- /dev/null
+++ b/Cycle.NET/Runner3.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Linq;
+using SdgApps.Common.DotnetSealedUnions;
+using SdgApps.Common.DotnetSealedUnions.Generic;
+
+namespace Cycle.NET
+{
+    public class Streams<T1, T2, T3> : List<IUnion3<IObservable<T1>, IObservable<T2>, IObservable<T3>>>
+    {
+        public Streams() : base() { }
+        public Streams(List<IUnion3<IObservable<T1>, IObservable<T2>, IObservable<T3>>> value) : base(value) { }
+    }
+
+    public class Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
+    {
+        public Drivers(
+            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
+            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond,
+            Func<IObservable<TSink3>, IObservable<TSource3>> onThird)
+        {
+            OnFirst = onFirst;
+            OnSecond = onSecond;
+            OnThird = onThird;
+        }
+
+        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
+        public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
+        public Func<IObservable<TSink3>, IObservable<TSource3>> OnThird { get; }
+    }
+
+    public static class Runner<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
+    {
+        public static void Run(
+            Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> main,
+            Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> drivers)
+        {
+            // Create fake sinks to use to call the drivers to get around the interdependency between
+            // main and the drivers.
+            var sinksFactory = GenericUnions.TripletFactory<ISubject<TSink1>, ISubject<TSink2>, ISubject<TSink3>>();
+            var fakeSinks = new List<IUnion3<ISubject<TSink1>, ISubject<TSink2>, ISubject<TSink3>>>
+            {
+                sinksFactory.First(new ReplaySubject<TSink1>()),
+                sinksFactory.Second(new ReplaySubject<TSink2>()),
+                sinksFactory.Third(new ReplaySubject<TSink3>()),
+            };
+
+            // Call the drivers and collate the returned sources.
+            var sourcesFactory = GenericUnions.TripletFactory<IObservable<TSource1>, IObservable<TSource2>, IObservable<TSource3>>();
+            var sources = fakeSinks.Select(sink => sink.Join(
+                s1s => sourcesFactory.First(drivers.OnFirst(s1s)),
+                s2s => sourcesFactory.Second(drivers.OnSecond(s2s)),
+                s3s => sourcesFactory.Third(drivers.OnThird(s3s))));
+
+            Streams<TSink1, TSink2, TSink3> sinks = main(new Streams<TSource1, TSource2, TSource3>(sources.ToList()));
+
+            // Update the sinks returned from main with the sinks used by the drivers.
+            foreach (var sink in sinks)
+            {
+                sink.Join(
+                    mapFirst: s1 => s1.Subscribe(s => fakeSinks.SelectMany(f => f.Join(
+                        mapFirst: f1 => new List<ISubject<TSink1>> { f1 },
+                        mapSecond: f2 => Enumerable.Empty<ISubject<TSink1>>(),
+                        mapThird: f3 => Enumerable.Empty<ISubject<TSink1>>())).Single().OnNext(s)),
+                    mapSecond: s2 => s2.Subscribe(s => fakeSinks.SelectMany(f => f.Join(
+                        mapFirst: f1 => Enumerable.Empty<ISubject<TSink2>>(),
+                        mapSecond: f2 => new List<ISubject<TSink2>> { f2 },
+                        mapThird: f3 => Enumerable.Empty<ISubject<TSink2>>())).Single().OnNext(s)),
+                    mapThird: s3 => s3.Subscribe(s => fakeSinks.SelectMany(f => f.Join(
+                        mapFirst: f1 => Enumerable.Empty<ISubject<TSink3>>(),
+                        mapSecond: f2 => Enumerable.Empty<ISubject<TSink3>>(),
+                        mapThird: f3 => new List<ISubject<TSink3>> { f3 })).Single().OnNext(s)));
+            }
+        }
+    }
+}

From 8af41a7cbe73f501b5b195cb4341d6587a5b9a14 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Tue, 14 Mar 2023 22:23:27 -0400
Subject: [PATCH 04/42] Test Runner3

---
 Cycle.NET.Demo/Program.cs | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 0d7e7b1..a64cd2a 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -1,40 +1,47 @@
 using System;
 using System.Collections.Generic;
+using System.Reactive;
 using System.Reactive.Linq;
+using SdgApps.Common.DotnetSealedUnions.Generic;
+using System.Reactive.Subjects;
+using System.Linq;
 
 namespace Cycle.NET.Demo
 {
     class Program
     {
-        private static IObservable<object> LogDriver(IObservable<object> sinks)
+        private static IObservable<int> LogDriver(IObservable<int> sinks)
         {
-            sinks.Cast<int>().Subscribe(i => Console.WriteLine("Log " + i.ToString()));
+            sinks.Subscribe(i => Console.WriteLine("Log " + i.ToString()));
 
-            return Observable.Empty<object>();
+            return Observable.Empty<int>();
         }
 
-        private static IObservable<object> KeyInputDriver(IObservable<object> sinks)
+        private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
         {
-            return Observable.Range(20, 5).Select(i => (object)i);
+            return Observable.Range(20, 5);
         }
 
-        private static Streams CycleMain(Streams sources)
+        private static Streams<int, int, Unit> CycleMain(Streams<int, int, Unit> sources)
         {
-            var sinks = new Streams
+            var sinksFactory = GenericUnions.TripletFactory<IObservable<int>, IObservable<int>, IObservable<Unit>>();
+            var sinks = new Streams<int, int, Unit>
             {
-                { "log", sources["keys"] }
+                sinksFactory.First(sources.SelectMany(s => s.Join(
+                    mapFirst: s1 => Enumerable.Empty<IObservable<int>>(),
+                    mapSecond: s2 => new List<IObservable<int>> { s2 },
+                    mapThird: s3 => Enumerable.Empty<IObservable<int>>())).Single()),
             };
 
             return sinks;
         }
         static void Main(string[] args)
         {
-            var drivers = new Drivers
-            {
-                { "log", LogDriver },
-                { "keys", KeyInputDriver }
-            };
-            Runner.Run(CycleMain, drivers);
+            var drivers = new Drivers<int, int, int, int, Unit, Unit>(
+                onFirst: LogDriver,
+                onSecond: KeyInputDriver,
+                onThird: _ => _);
+            Runner<int, int, int, int, Unit, Unit>.Run(CycleMain, drivers);
             Console.ReadLine();
         }
     }

From b9fe928d6cac10c72004522df30244828921ab89 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Tue, 14 Mar 2023 23:36:18 -0400
Subject: [PATCH 05/42] Simplify implementation

---
 Cycle.NET.Demo/Program.cs | 16 +++------
 Cycle.NET/Runner3.cs      | 76 +++++++++++++++++++++------------------
 2 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index a64cd2a..3af2491 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -1,10 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Reactive;
 using System.Reactive.Linq;
-using SdgApps.Common.DotnetSealedUnions.Generic;
-using System.Reactive.Subjects;
-using System.Linq;
 
 namespace Cycle.NET.Demo
 {
@@ -24,14 +20,10 @@ private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
 
         private static Streams<int, int, Unit> CycleMain(Streams<int, int, Unit> sources)
         {
-            var sinksFactory = GenericUnions.TripletFactory<IObservable<int>, IObservable<int>, IObservable<Unit>>();
-            var sinks = new Streams<int, int, Unit>
-            {
-                sinksFactory.First(sources.SelectMany(s => s.Join(
-                    mapFirst: s1 => Enumerable.Empty<IObservable<int>>(),
-                    mapSecond: s2 => new List<IObservable<int>> { s2 },
-                    mapThird: s3 => Enumerable.Empty<IObservable<int>>())).Single()),
-            };
+            var sinks = new Streams<int, int, Unit>(
+                sources.Second,
+                Observable.Empty<int>(),
+                Observable.Empty<Unit>());
 
             return sinks;
         }
diff --git a/Cycle.NET/Runner3.cs b/Cycle.NET/Runner3.cs
index 27d3e7e..2183350 100644
--- a/Cycle.NET/Runner3.cs
+++ b/Cycle.NET/Runner3.cs
@@ -1,17 +1,24 @@
 using System;
-using System.Collections.Generic;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
-using System.Linq;
-using SdgApps.Common.DotnetSealedUnions;
-using SdgApps.Common.DotnetSealedUnions.Generic;
 
 namespace Cycle.NET
 {
-    public class Streams<T1, T2, T3> : List<IUnion3<IObservable<T1>, IObservable<T2>, IObservable<T3>>>
+    public class Streams<T1, T2, T3>
     {
-        public Streams() : base() { }
-        public Streams(List<IUnion3<IObservable<T1>, IObservable<T2>, IObservable<T3>>> value) : base(value) { }
+        public Streams(
+            IObservable<T1> first,
+            IObservable<T2> second,
+            IObservable<T3> third)
+        {
+            First = first;
+            Second = second;
+            Third = third;
+        }
+
+        public IObservable<T1> First { get; }
+        public IObservable<T2> Second { get; }
+        public IObservable<T3> Third { get; }
     }
 
     public class Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
@@ -39,40 +46,41 @@ public static void Run(
         {
             // Create fake sinks to use to call the drivers to get around the interdependency between
             // main and the drivers.
-            var sinksFactory = GenericUnions.TripletFactory<ISubject<TSink1>, ISubject<TSink2>, ISubject<TSink3>>();
-            var fakeSinks = new List<IUnion3<ISubject<TSink1>, ISubject<TSink2>, ISubject<TSink3>>>
-            {
-                sinksFactory.First(new ReplaySubject<TSink1>()),
-                sinksFactory.Second(new ReplaySubject<TSink2>()),
-                sinksFactory.Third(new ReplaySubject<TSink3>()),
-            };
+            var fakeSinks = new FakeSinks<TSink1, TSink2, TSink3>(
+                new ReplaySubject<TSink1>(),
+                new ReplaySubject<TSink2>(),
+                new ReplaySubject<TSink3>());
 
             // Call the drivers and collate the returned sources.
-            var sourcesFactory = GenericUnions.TripletFactory<IObservable<TSource1>, IObservable<TSource2>, IObservable<TSource3>>();
-            var sources = fakeSinks.Select(sink => sink.Join(
-                s1s => sourcesFactory.First(drivers.OnFirst(s1s)),
-                s2s => sourcesFactory.Second(drivers.OnSecond(s2s)),
-                s3s => sourcesFactory.Third(drivers.OnThird(s3s))));
+            var sources = new Streams<TSource1, TSource2, TSource3>(
+                drivers.OnFirst(fakeSinks.First),
+                drivers.OnSecond(fakeSinks.Second),
+                drivers.OnThird(fakeSinks.Third));
 
-            Streams<TSink1, TSink2, TSink3> sinks = main(new Streams<TSource1, TSource2, TSource3>(sources.ToList()));
+            Streams<TSink1, TSink2, TSink3> sinks = main(sources);
 
             // Update the sinks returned from main with the sinks used by the drivers.
-            foreach (var sink in sinks)
+            sinks.First.Subscribe(fakeSinks.First.OnNext);
+            sinks.Second.Subscribe(fakeSinks.Second.OnNext);
+            sinks.Third.Subscribe(fakeSinks.Third.OnNext);
+        }
+
+        private class FakeSinks<T1, T2, T3>
+        {
+            public FakeSinks(
+                ISubject<T1> first,
+                ISubject<T2> second,
+                ISubject<T3> third)
             {
-                sink.Join(
-                    mapFirst: s1 => s1.Subscribe(s => fakeSinks.SelectMany(f => f.Join(
-                        mapFirst: f1 => new List<ISubject<TSink1>> { f1 },
-                        mapSecond: f2 => Enumerable.Empty<ISubject<TSink1>>(),
-                        mapThird: f3 => Enumerable.Empty<ISubject<TSink1>>())).Single().OnNext(s)),
-                    mapSecond: s2 => s2.Subscribe(s => fakeSinks.SelectMany(f => f.Join(
-                        mapFirst: f1 => Enumerable.Empty<ISubject<TSink2>>(),
-                        mapSecond: f2 => new List<ISubject<TSink2>> { f2 },
-                        mapThird: f3 => Enumerable.Empty<ISubject<TSink2>>())).Single().OnNext(s)),
-                    mapThird: s3 => s3.Subscribe(s => fakeSinks.SelectMany(f => f.Join(
-                        mapFirst: f1 => Enumerable.Empty<ISubject<TSink3>>(),
-                        mapSecond: f2 => Enumerable.Empty<ISubject<TSink3>>(),
-                        mapThird: f3 => new List<ISubject<TSink3>> { f3 })).Single().OnNext(s)));
+                First = first;
+                Second = second;
+                Third = third;
             }
+
+            public ISubject<T1> First { get; }
+            public ISubject<T2> Second { get; }
+            public ISubject<T3> Third { get; }
         }
+
     }
 }

From 9a486ac5bfcccc6f4baa0a7af180a5b0a95dae70 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Thu, 16 Mar 2023 23:04:10 -0400
Subject: [PATCH 06/42] Wrap main delegate

---
 Cycle.NET.Demo/Program.cs |  4 +++-
 Cycle.NET/Runner3.cs      | 15 +++++++++++++--
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 3af2491..15b7757 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -29,11 +29,13 @@ private static Streams<int, int, Unit> CycleMain(Streams<int, int, Unit> sources
         }
         static void Main(string[] args)
         {
+            var component = new Component<int, int, int, int, Unit, Unit>(
+                CycleMain);
             var drivers = new Drivers<int, int, int, int, Unit, Unit>(
                 onFirst: LogDriver,
                 onSecond: KeyInputDriver,
                 onThird: _ => _);
-            Runner<int, int, int, int, Unit, Unit>.Run(CycleMain, drivers);
+            Runner<int, int, int, int, Unit, Unit>.Run(component, drivers);
             Console.ReadLine();
         }
     }
diff --git a/Cycle.NET/Runner3.cs b/Cycle.NET/Runner3.cs
index 2183350..585d973 100644
--- a/Cycle.NET/Runner3.cs
+++ b/Cycle.NET/Runner3.cs
@@ -21,6 +21,17 @@ public Streams(
         public IObservable<T3> Third { get; }
     }
 
+    public class Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
+    {
+        public Component(
+            Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> main)
+        {
+            Main = main;
+        }
+
+        public Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> Main { get; }
+    }
+
     public class Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
     {
         public Drivers(
@@ -41,7 +52,7 @@ public Drivers(
     public static class Runner<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
     {
         public static void Run(
-            Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> main,
+            Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> component,
             Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> drivers)
         {
             // Create fake sinks to use to call the drivers to get around the interdependency between
@@ -57,7 +68,7 @@ public static void Run(
                 drivers.OnSecond(fakeSinks.Second),
                 drivers.OnThird(fakeSinks.Third));
 
-            Streams<TSink1, TSink2, TSink3> sinks = main(sources);
+            Streams<TSink1, TSink2, TSink3> sinks = component.Main(sources);
 
             // Update the sinks returned from main with the sinks used by the drivers.
             sinks.First.Subscribe(fakeSinks.First.OnNext);

From 12a300d17a8f8044dced5bc31525634c89d8404b Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Wed, 22 Mar 2023 20:38:09 -0400
Subject: [PATCH 07/42] Attempt ungeneric interface

Unfortunately this is little better than IRunner.Run
---
 Cycle.NET.Demo/Program.cs | 140 ++++++++++++++++++++++++++++++++++++--
 Cycle.NET/Runner3.cs      |  84 +++++------------------
 2 files changed, 152 insertions(+), 72 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 15b7757..dc7c2ea 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -1,10 +1,143 @@
 using System;
 using System.Reactive;
 using System.Reactive.Linq;
+using System.Reactive.Subjects;
 
 namespace Cycle.NET.Demo
 {
-    class Program
+    public class Streams<T1, T2, T3>
+    {
+        public Streams(
+            IObservable<T1> first,
+            IObservable<T2> second,
+            IObservable<T3> third)
+        {
+            First = first;
+            Second = second;
+            Third = third;
+        }
+
+        public IObservable<T1> First { get; }
+        public IObservable<T2> Second { get; }
+        public IObservable<T3> Third { get; }
+    }
+
+    public class Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> : IComponent
+    {
+        public Component(
+            FakeSinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> fakeSinks,
+            IObservable<TSource1> first,
+            IObservable<TSource2> second,
+            IObservable<TSource3> third)
+        {
+            FakeSinks = fakeSinks;
+            First = first;
+            Second = second;
+            Third = third;
+        }
+
+        public FakeSinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> FakeSinks { get; }
+        public IObservable<TSource1> First { get; }
+        public IObservable<TSource2> Second { get; }
+        public IObservable<TSource3> Third { get; }
+
+        public ISinks Main()
+        {
+            var sources = new Streams<TSource1, TSource2, TSource3>(First, Second, Third);
+            var sinks = FakeSinks.Drivers.Main(sources);
+            return new Sinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>(
+                this,
+                sinks.First,
+                sinks.Second,
+                sinks.Third);
+        }
+    }
+
+    internal class Sinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> : ISinks
+    {
+        public Sinks(Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> component, IObservable<TSink1> first, IObservable<TSink2> second, IObservable<TSink3> third)
+        {
+            Component = component;
+            First = first;
+            Second = second;
+            Third = third;
+        }
+
+        public Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> Component { get; }
+        public IObservable<TSink1> First { get; }
+        public IObservable<TSink2> Second { get; }
+        public IObservable<TSink3> Third { get; }
+
+        public void Subscribe()
+        {
+            First.Subscribe(Component.FakeSinks.First.OnNext);
+            Second.Subscribe(Component.FakeSinks.Second.OnNext);
+            Third.Subscribe(Component.FakeSinks.Third.OnNext);
+        }
+    }
+
+    public class Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> : IDrivers
+    {
+        public Drivers(
+            Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
+            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond,
+            Func<IObservable<TSink3>, IObservable<TSource3>> onThird)
+        {
+            Main = main;
+            OnFirst = onFirst;
+            OnSecond = onSecond;
+            OnThird = onThird;
+        }
+
+        public Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> Main { get; }
+        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
+        public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
+        public Func<IObservable<TSink3>, IObservable<TSource3>> OnThird { get; }
+
+        public IFakeSinks CreateFakeSinks()
+        {
+            return new FakeSinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>(
+                this,
+                new ReplaySubject<TSink1>(),
+                new ReplaySubject<TSink2>(),
+                new ReplaySubject<TSink3>());
+        }
+    }
+
+    public class FakeSinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> : IFakeSinks
+    {
+        public FakeSinks(
+            Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> drivers,
+            ISubject<TSink1> first,
+            ISubject<TSink2> second,
+            ISubject<TSink3> third)
+        {
+            Drivers = drivers;
+            First = first;
+            Second = second;
+            Third = third;
+        }
+
+        public Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> Drivers { get; }
+        public ISubject<TSink1> First { get; }
+        public ISubject<TSink2> Second { get; }
+        public ISubject<TSink3> Third { get; }
+
+        public IComponent Invoke()
+        {
+            IObservable<TSource1> first = this.Drivers.OnFirst(this.First);
+            IObservable<TSource2> second = this.Drivers.OnSecond(this.Second);
+            IObservable<TSource3> third = this.Drivers.OnThird(this.Third);
+            return new Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>(
+                this,
+                first,
+                second,
+                third);
+        }
+    }
+
+    static class Program
     {
         private static IObservable<int> LogDriver(IObservable<int> sinks)
         {
@@ -29,13 +162,12 @@ private static Streams<int, int, Unit> CycleMain(Streams<int, int, Unit> sources
         }
         static void Main(string[] args)
         {
-            var component = new Component<int, int, int, int, Unit, Unit>(
-                CycleMain);
             var drivers = new Drivers<int, int, int, int, Unit, Unit>(
+                CycleMain,
                 onFirst: LogDriver,
                 onSecond: KeyInputDriver,
                 onThird: _ => _);
-            Runner<int, int, int, int, Unit, Unit>.Run(component, drivers);
+            Runner<Unit, Unit>.Run(drivers);
             Console.ReadLine();
         }
     }
diff --git a/Cycle.NET/Runner3.cs b/Cycle.NET/Runner3.cs
index 585d973..e974cba 100644
--- a/Cycle.NET/Runner3.cs
+++ b/Cycle.NET/Runner3.cs
@@ -4,94 +4,42 @@
 
 namespace Cycle.NET
 {
-    public class Streams<T1, T2, T3>
+    public interface IComponent
     {
-        public Streams(
-            IObservable<T1> first,
-            IObservable<T2> second,
-            IObservable<T3> third)
-        {
-            First = first;
-            Second = second;
-            Third = third;
-        }
-
-        public IObservable<T1> First { get; }
-        public IObservable<T2> Second { get; }
-        public IObservable<T3> Third { get; }
+        ISinks Main();
     }
 
-    public class Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
+    public interface ISinks
     {
-        public Component(
-            Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> main)
-        {
-            Main = main;
-        }
-
-        public Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> Main { get; }
+        void Subscribe();
     }
 
-    public class Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
+    public interface IDrivers
     {
-        public Drivers(
-            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
-            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond,
-            Func<IObservable<TSink3>, IObservable<TSource3>> onThird)
-        {
-            OnFirst = onFirst;
-            OnSecond = onSecond;
-            OnThird = onThird;
-        }
+        IFakeSinks CreateFakeSinks();
+    }
 
-        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
-        public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
-        public Func<IObservable<TSink3>, IObservable<TSource3>> OnThird { get; }
+    public interface IFakeSinks
+    {
+        IComponent Invoke();
     }
 
-    public static class Runner<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
+    public static class Runner<TD, TM>
     {
         public static void Run(
-            Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> component,
-            Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> drivers)
+            IDrivers drivers)
         {
             // Create fake sinks to use to call the drivers to get around the interdependency between
             // main and the drivers.
-            var fakeSinks = new FakeSinks<TSink1, TSink2, TSink3>(
-                new ReplaySubject<TSink1>(),
-                new ReplaySubject<TSink2>(),
-                new ReplaySubject<TSink3>());
+            var fakeSinks = drivers.CreateFakeSinks();
 
             // Call the drivers and collate the returned sources.
-            var sources = new Streams<TSource1, TSource2, TSource3>(
-                drivers.OnFirst(fakeSinks.First),
-                drivers.OnSecond(fakeSinks.Second),
-                drivers.OnThird(fakeSinks.Third));
+            var sources = fakeSinks.Invoke();
 
-            Streams<TSink1, TSink2, TSink3> sinks = component.Main(sources);
+            var sinks = sources.Main();
 
             // Update the sinks returned from main with the sinks used by the drivers.
-            sinks.First.Subscribe(fakeSinks.First.OnNext);
-            sinks.Second.Subscribe(fakeSinks.Second.OnNext);
-            sinks.Third.Subscribe(fakeSinks.Third.OnNext);
+            sinks.Subscribe();
         }
-
-        private class FakeSinks<T1, T2, T3>
-        {
-            public FakeSinks(
-                ISubject<T1> first,
-                ISubject<T2> second,
-                ISubject<T3> third)
-            {
-                First = first;
-                Second = second;
-                Third = third;
-            }
-
-            public ISubject<T1> First { get; }
-            public ISubject<T2> Second { get; }
-            public ISubject<T3> Third { get; }
-        }
-
     }
 }

From 890f37733ee8e93ecd038d2c8d3ac48cddce9576 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Wed, 22 Mar 2023 20:38:20 -0400
Subject: [PATCH 08/42] Revert "Attempt ungeneric interface"

This reverts commit 12a300d17a8f8044dced5bc31525634c89d8404b.
---
 Cycle.NET.Demo/Program.cs | 140 ++------------------------------------
 Cycle.NET/Runner3.cs      |  84 ++++++++++++++++++-----
 2 files changed, 72 insertions(+), 152 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index dc7c2ea..15b7757 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -1,143 +1,10 @@
 using System;
 using System.Reactive;
 using System.Reactive.Linq;
-using System.Reactive.Subjects;
 
 namespace Cycle.NET.Demo
 {
-    public class Streams<T1, T2, T3>
-    {
-        public Streams(
-            IObservable<T1> first,
-            IObservable<T2> second,
-            IObservable<T3> third)
-        {
-            First = first;
-            Second = second;
-            Third = third;
-        }
-
-        public IObservable<T1> First { get; }
-        public IObservable<T2> Second { get; }
-        public IObservable<T3> Third { get; }
-    }
-
-    public class Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> : IComponent
-    {
-        public Component(
-            FakeSinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> fakeSinks,
-            IObservable<TSource1> first,
-            IObservable<TSource2> second,
-            IObservable<TSource3> third)
-        {
-            FakeSinks = fakeSinks;
-            First = first;
-            Second = second;
-            Third = third;
-        }
-
-        public FakeSinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> FakeSinks { get; }
-        public IObservable<TSource1> First { get; }
-        public IObservable<TSource2> Second { get; }
-        public IObservable<TSource3> Third { get; }
-
-        public ISinks Main()
-        {
-            var sources = new Streams<TSource1, TSource2, TSource3>(First, Second, Third);
-            var sinks = FakeSinks.Drivers.Main(sources);
-            return new Sinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>(
-                this,
-                sinks.First,
-                sinks.Second,
-                sinks.Third);
-        }
-    }
-
-    internal class Sinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> : ISinks
-    {
-        public Sinks(Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> component, IObservable<TSink1> first, IObservable<TSink2> second, IObservable<TSink3> third)
-        {
-            Component = component;
-            First = first;
-            Second = second;
-            Third = third;
-        }
-
-        public Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> Component { get; }
-        public IObservable<TSink1> First { get; }
-        public IObservable<TSink2> Second { get; }
-        public IObservable<TSink3> Third { get; }
-
-        public void Subscribe()
-        {
-            First.Subscribe(Component.FakeSinks.First.OnNext);
-            Second.Subscribe(Component.FakeSinks.Second.OnNext);
-            Third.Subscribe(Component.FakeSinks.Third.OnNext);
-        }
-    }
-
-    public class Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> : IDrivers
-    {
-        public Drivers(
-            Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> main,
-            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
-            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond,
-            Func<IObservable<TSink3>, IObservable<TSource3>> onThird)
-        {
-            Main = main;
-            OnFirst = onFirst;
-            OnSecond = onSecond;
-            OnThird = onThird;
-        }
-
-        public Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> Main { get; }
-        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
-        public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
-        public Func<IObservable<TSink3>, IObservable<TSource3>> OnThird { get; }
-
-        public IFakeSinks CreateFakeSinks()
-        {
-            return new FakeSinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>(
-                this,
-                new ReplaySubject<TSink1>(),
-                new ReplaySubject<TSink2>(),
-                new ReplaySubject<TSink3>());
-        }
-    }
-
-    public class FakeSinks<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> : IFakeSinks
-    {
-        public FakeSinks(
-            Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> drivers,
-            ISubject<TSink1> first,
-            ISubject<TSink2> second,
-            ISubject<TSink3> third)
-        {
-            Drivers = drivers;
-            First = first;
-            Second = second;
-            Third = third;
-        }
-
-        public Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> Drivers { get; }
-        public ISubject<TSink1> First { get; }
-        public ISubject<TSink2> Second { get; }
-        public ISubject<TSink3> Third { get; }
-
-        public IComponent Invoke()
-        {
-            IObservable<TSource1> first = this.Drivers.OnFirst(this.First);
-            IObservable<TSource2> second = this.Drivers.OnSecond(this.Second);
-            IObservable<TSource3> third = this.Drivers.OnThird(this.Third);
-            return new Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>(
-                this,
-                first,
-                second,
-                third);
-        }
-    }
-
-    static class Program
+    class Program
     {
         private static IObservable<int> LogDriver(IObservable<int> sinks)
         {
@@ -162,12 +29,13 @@ private static Streams<int, int, Unit> CycleMain(Streams<int, int, Unit> sources
         }
         static void Main(string[] args)
         {
+            var component = new Component<int, int, int, int, Unit, Unit>(
+                CycleMain);
             var drivers = new Drivers<int, int, int, int, Unit, Unit>(
-                CycleMain,
                 onFirst: LogDriver,
                 onSecond: KeyInputDriver,
                 onThird: _ => _);
-            Runner<Unit, Unit>.Run(drivers);
+            Runner<int, int, int, int, Unit, Unit>.Run(component, drivers);
             Console.ReadLine();
         }
     }
diff --git a/Cycle.NET/Runner3.cs b/Cycle.NET/Runner3.cs
index e974cba..585d973 100644
--- a/Cycle.NET/Runner3.cs
+++ b/Cycle.NET/Runner3.cs
@@ -4,42 +4,94 @@
 
 namespace Cycle.NET
 {
-    public interface IComponent
+    public class Streams<T1, T2, T3>
     {
-        ISinks Main();
-    }
+        public Streams(
+            IObservable<T1> first,
+            IObservable<T2> second,
+            IObservable<T3> third)
+        {
+            First = first;
+            Second = second;
+            Third = third;
+        }
 
-    public interface ISinks
-    {
-        void Subscribe();
+        public IObservable<T1> First { get; }
+        public IObservable<T2> Second { get; }
+        public IObservable<T3> Third { get; }
     }
 
-    public interface IDrivers
+    public class Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
     {
-        IFakeSinks CreateFakeSinks();
+        public Component(
+            Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> main)
+        {
+            Main = main;
+        }
+
+        public Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> Main { get; }
     }
 
-    public interface IFakeSinks
+    public class Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
     {
-        IComponent Invoke();
+        public Drivers(
+            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
+            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond,
+            Func<IObservable<TSink3>, IObservable<TSource3>> onThird)
+        {
+            OnFirst = onFirst;
+            OnSecond = onSecond;
+            OnThird = onThird;
+        }
+
+        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
+        public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
+        public Func<IObservable<TSink3>, IObservable<TSource3>> OnThird { get; }
     }
 
-    public static class Runner<TD, TM>
+    public static class Runner<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
     {
         public static void Run(
-            IDrivers drivers)
+            Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> component,
+            Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> drivers)
         {
             // Create fake sinks to use to call the drivers to get around the interdependency between
             // main and the drivers.
-            var fakeSinks = drivers.CreateFakeSinks();
+            var fakeSinks = new FakeSinks<TSink1, TSink2, TSink3>(
+                new ReplaySubject<TSink1>(),
+                new ReplaySubject<TSink2>(),
+                new ReplaySubject<TSink3>());
 
             // Call the drivers and collate the returned sources.
-            var sources = fakeSinks.Invoke();
+            var sources = new Streams<TSource1, TSource2, TSource3>(
+                drivers.OnFirst(fakeSinks.First),
+                drivers.OnSecond(fakeSinks.Second),
+                drivers.OnThird(fakeSinks.Third));
 
-            var sinks = sources.Main();
+            Streams<TSink1, TSink2, TSink3> sinks = component.Main(sources);
 
             // Update the sinks returned from main with the sinks used by the drivers.
-            sinks.Subscribe();
+            sinks.First.Subscribe(fakeSinks.First.OnNext);
+            sinks.Second.Subscribe(fakeSinks.Second.OnNext);
+            sinks.Third.Subscribe(fakeSinks.Third.OnNext);
         }
+
+        private class FakeSinks<T1, T2, T3>
+        {
+            public FakeSinks(
+                ISubject<T1> first,
+                ISubject<T2> second,
+                ISubject<T3> third)
+            {
+                First = first;
+                Second = second;
+                Third = third;
+            }
+
+            public ISubject<T1> First { get; }
+            public ISubject<T2> Second { get; }
+            public ISubject<T3> Third { get; }
+        }
+
     }
 }

From b55ffdc0b694bca70bc3654bb3376776c04f2696 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Wed, 22 Mar 2023 20:41:25 -0400
Subject: [PATCH 09/42] Make Runner1 from Runner3

---
 Cycle.NET/Runner1.cs | 73 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 Cycle.NET/Runner1.cs

diff --git a/Cycle.NET/Runner1.cs b/Cycle.NET/Runner1.cs
new file mode 100644
index 0000000..dafc96e
--- /dev/null
+++ b/Cycle.NET/Runner1.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace Cycle.NET
+{
+    public class Streams<T1>
+    {
+        public Streams(
+            IObservable<T1> first)
+        {
+            First = first;
+        }
+
+        public IObservable<T1> First { get; }
+    }
+
+    public class Component<TSource1, TSink1>
+    {
+        public Component(
+            Func<Streams<TSource1>, Streams<TSink1>> main)
+        {
+            Main = main;
+        }
+
+        public Func<Streams<TSource1>, Streams<TSink1>> Main { get; }
+    }
+
+    public class Drivers<TSource1, TSink1>
+    {
+        public Drivers(
+            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst)
+        {
+            OnFirst = onFirst;
+        }
+
+        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
+    }
+
+    public static class Runner<TSource1, TSink1>
+    {
+        public static void Run(
+            Component<TSource1, TSink1> component,
+            Drivers<TSource1, TSink1> drivers)
+        {
+            // Create fake sinks to use to call the drivers to get around the interdependency between
+            // main and the drivers.
+            var fakeSinks = new FakeSinks<TSink1>(
+                new ReplaySubject<TSink1>());
+
+            // Call the drivers and collate the returned sources.
+            var sources = new Streams<TSource1>(
+                drivers.OnFirst(fakeSinks.First));
+
+            Streams<TSink1> sinks = component.Main(sources);
+
+            // Update the sinks returned from main with the sinks used by the drivers.
+            sinks.First.Subscribe(fakeSinks.First.OnNext);
+        }
+
+        private class FakeSinks<T1>
+        {
+            public FakeSinks(
+                ISubject<T1> first)
+            {
+                First = first;
+            }
+
+            public ISubject<T1> First { get; }
+        }
+
+    }
+}

From c30ec5875007664e56bf54ca6a62cd38104c68f7 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Mon, 27 Mar 2023 20:29:25 -0400
Subject: [PATCH 10/42] Implement demo with obs of tuple

---
 Cycle.NET.Demo/Program.cs | 33 ++++++++++++++++++++++-----------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 15b7757..b27b47b 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -18,24 +18,35 @@ private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
             return Observable.Range(20, 5);
         }
 
-        private static Streams<int, int, Unit> CycleMain(Streams<int, int, Unit> sources)
+        private static IObservable<(int? Log, int? KeyInput)> Driver(IObservable<(int? Log, int? KeyInput)> sinks)
         {
-            var sinks = new Streams<int, int, Unit>(
-                sources.Second,
-                Observable.Empty<int>(),
-                Observable.Empty<Unit>());
+            var logSinks = sinks.Where(s => s.Log.HasValue);
+            var logSources = LogDriver(logSinks.Select(s => s.Log.Value));
+
+            var keyInputSinks = sinks.Where(s => s.KeyInput.HasValue);
+            var keyInputSources = KeyInputDriver(keyInputSinks.Select(s => s.KeyInput.Value));
+
+            return Observable.Merge(
+                logSources.Select(s => (Log: s as int?, KeyInput: null as int?)),
+                keyInputSources.Select(s => (Log: null as int?, KeyInput: s as int?)));
+        }
+
+        private static Streams<(int? Log, int? KeyInput)> CycleMain(Streams<(int? Log, int? KeyInput)> sources)
+        {
+            var sinks = new Streams<(int? Log, int? KeyInput)>(
+                sources.First.Select(s => (
+                    Log: s.KeyInput,
+                    KeyInput: null as int?)));
 
             return sinks;
         }
         static void Main(string[] args)
         {
-            var component = new Component<int, int, int, int, Unit, Unit>(
+            var component = new Component<(int? Log, int? KeyInput), (int? Log, int? KeyInput)>(
                 CycleMain);
-            var drivers = new Drivers<int, int, int, int, Unit, Unit>(
-                onFirst: LogDriver,
-                onSecond: KeyInputDriver,
-                onThird: _ => _);
-            Runner<int, int, int, int, Unit, Unit>.Run(component, drivers);
+            var drivers = new Drivers<(int? Log, int? KeyInput), (int? Log, int? KeyInput)>(
+                onFirst: Driver);
+            Runner<(int? Log, int? KeyInput), (int? Log, int? KeyInput)>.Run(component, drivers);
             Console.ReadLine();
         }
     }

From ec88a0da7d86c176a76186ec0f62b0aa93c77bcf Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Mon, 27 Mar 2023 20:35:51 -0400
Subject: [PATCH 11/42] Remove redundant streams type

---
 Cycle.NET.Demo/Program.cs |  9 ++++-----
 Cycle.NET/Runner1.cs      | 37 ++++++-------------------------------
 2 files changed, 10 insertions(+), 36 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index b27b47b..483aa13 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -31,12 +31,11 @@ private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
                 keyInputSources.Select(s => (Log: null as int?, KeyInput: s as int?)));
         }
 
-        private static Streams<(int? Log, int? KeyInput)> CycleMain(Streams<(int? Log, int? KeyInput)> sources)
+        private static IObservable<(int? Log, int? KeyInput)> CycleMain(IObservable<(int? Log, int? KeyInput)> sources)
         {
-            var sinks = new Streams<(int? Log, int? KeyInput)>(
-                sources.First.Select(s => (
-                    Log: s.KeyInput,
-                    KeyInput: null as int?)));
+            var sinks = sources.Select(s => (
+                Log: s.KeyInput,
+                KeyInput: null as int?));
 
             return sinks;
         }
diff --git a/Cycle.NET/Runner1.cs b/Cycle.NET/Runner1.cs
index dafc96e..334b928 100644
--- a/Cycle.NET/Runner1.cs
+++ b/Cycle.NET/Runner1.cs
@@ -4,26 +4,15 @@
 
 namespace Cycle.NET
 {
-    public class Streams<T1>
-    {
-        public Streams(
-            IObservable<T1> first)
-        {
-            First = first;
-        }
-
-        public IObservable<T1> First { get; }
-    }
-
     public class Component<TSource1, TSink1>
     {
         public Component(
-            Func<Streams<TSource1>, Streams<TSink1>> main)
+            Func<IObservable<TSource1>, IObservable<TSink1>> main)
         {
             Main = main;
         }
 
-        public Func<Streams<TSource1>, Streams<TSink1>> Main { get; }
+        public Func<IObservable<TSource1>, IObservable<TSink1>> Main { get; }
     }
 
     public class Drivers<TSource1, TSink1>
@@ -45,29 +34,15 @@ public static void Run(
         {
             // Create fake sinks to use to call the drivers to get around the interdependency between
             // main and the drivers.
-            var fakeSinks = new FakeSinks<TSink1>(
-                new ReplaySubject<TSink1>());
+            var fakeSinks = new ReplaySubject<TSink1>();
 
             // Call the drivers and collate the returned sources.
-            var sources = new Streams<TSource1>(
-                drivers.OnFirst(fakeSinks.First));
+            var sources = drivers.OnFirst(fakeSinks);
 
-            Streams<TSink1> sinks = component.Main(sources);
+            IObservable<TSink1> sinks = component.Main(sources);
 
             // Update the sinks returned from main with the sinks used by the drivers.
-            sinks.First.Subscribe(fakeSinks.First.OnNext);
+            sinks.Subscribe(fakeSinks.OnNext);
         }
-
-        private class FakeSinks<T1>
-        {
-            public FakeSinks(
-                ISubject<T1> first)
-            {
-                First = first;
-            }
-
-            public ISubject<T1> First { get; }
-        }
-
     }
 }

From 603d2ab73c7a301a9d7402a8b9dd645f3b358c27 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Mon, 27 Mar 2023 21:22:24 -0400
Subject: [PATCH 12/42] Convert tuple to sum type

---
 Cycle.NET.Demo/Cycle.NET.Demo.csproj |  4 +++
 Cycle.NET.Demo/Program.cs            | 39 ++++++++++++++++++----------
 Cycle.NET/Cycle.NET.csproj           |  1 -
 3 files changed, 29 insertions(+), 15 deletions(-)

diff --git a/Cycle.NET.Demo/Cycle.NET.Demo.csproj b/Cycle.NET.Demo/Cycle.NET.Demo.csproj
index 3254220..6ac46b6 100644
--- a/Cycle.NET.Demo/Cycle.NET.Demo.csproj
+++ b/Cycle.NET.Demo/Cycle.NET.Demo.csproj
@@ -5,6 +5,10 @@
     <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.0" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\Cycle.NET\Cycle.NET.csproj" />
   </ItemGroup>
diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 483aa13..ea9e745 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Reactive;
 using System.Reactive.Linq;
+using SdgApps.Common.DotnetSealedUnions;
+using SdgApps.Common.DotnetSealedUnions.Generic;
 
 namespace Cycle.NET.Demo
 {
@@ -18,34 +20,43 @@ private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
             return Observable.Range(20, 5);
         }
 
-        private static IObservable<(int? Log, int? KeyInput)> Driver(IObservable<(int? Log, int? KeyInput)> sinks)
+        private static IObservable<IUnion2<int, int>> Driver(IObservable<IUnion2<int, int>> sinks)
         {
-            var logSinks = sinks.Where(s => s.Log.HasValue);
-            var logSources = LogDriver(logSinks.Select(s => s.Log.Value));
+            var fac = GenericUnions.DoubletFactory<int, int>();
 
-            var keyInputSinks = sinks.Where(s => s.KeyInput.HasValue);
-            var keyInputSources = KeyInputDriver(keyInputSinks.Select(s => s.KeyInput.Value));
+            var logSinks = sinks.SelectMany(s => s.Join(
+                mapFirst: Observable.Return,
+                mapSecond: _ => Observable.Empty<int>()));
+            var logSources = LogDriver(logSinks);
+
+            var keyInputSinks = sinks.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<int>(),
+                mapSecond: Observable.Return));
+            var keyInputSources = KeyInputDriver(keyInputSinks);
 
             return Observable.Merge(
-                logSources.Select(s => (Log: s as int?, KeyInput: null as int?)),
-                keyInputSources.Select(s => (Log: null as int?, KeyInput: s as int?)));
+                logSources.Select(fac.First),
+                keyInputSources.Select(fac.Second));
         }
 
-        private static IObservable<(int? Log, int? KeyInput)> CycleMain(IObservable<(int? Log, int? KeyInput)> sources)
+        private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int, int>> sources)
         {
-            var sinks = sources.Select(s => (
-                Log: s.KeyInput,
-                KeyInput: null as int?));
+            var fac = GenericUnions.DoubletFactory<int, int>();
+
+            var keyInputSources = sources.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<int>(),
+                mapSecond: Observable.Return));
+            var sinks = keyInputSources.Select(fac.First);
 
             return sinks;
         }
         static void Main(string[] args)
         {
-            var component = new Component<(int? Log, int? KeyInput), (int? Log, int? KeyInput)>(
+            var component = new Component<IUnion2<int, int>, IUnion2<int, int>>(
                 CycleMain);
-            var drivers = new Drivers<(int? Log, int? KeyInput), (int? Log, int? KeyInput)>(
+            var drivers = new Drivers<IUnion2<int, int>, IUnion2<int, int>>(
                 onFirst: Driver);
-            Runner<(int? Log, int? KeyInput), (int? Log, int? KeyInput)>.Run(component, drivers);
+            Runner<IUnion2<int, int>, IUnion2<int, int>>.Run(component, drivers);
             Console.ReadLine();
         }
     }
diff --git a/Cycle.NET/Cycle.NET.csproj b/Cycle.NET/Cycle.NET.csproj
index ce9389a..624b282 100644
--- a/Cycle.NET/Cycle.NET.csproj
+++ b/Cycle.NET/Cycle.NET.csproj
@@ -5,7 +5,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.0" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 

From 99a5a47850204a1667a9cafa1803a25031b0242b Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Thu, 30 Mar 2023 22:39:50 -0400
Subject: [PATCH 13/42] Add stream adapters

---
 Cycle.NET.Demo/Program.cs                 | 31 +++++++++++----------
 Cycle.NET/Cycle.NET.csproj                |  1 +
 Cycle.NET/Extensions/StreamsExtensions.cs | 25 +++++++++++++++++
 Cycle.NET/Streams2.cs                     | 33 +++++++++++++++++++++++
 4 files changed, 74 insertions(+), 16 deletions(-)
 create mode 100644 Cycle.NET/Extensions/StreamsExtensions.cs
 create mode 100644 Cycle.NET/Streams2.cs

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index ea9e745..a5ebd4b 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Reactive;
 using System.Reactive.Linq;
+using Cycle.NET.Extensions;
 using SdgApps.Common.DotnetSealedUnions;
 using SdgApps.Common.DotnetSealedUnions.Generic;
 
@@ -22,33 +23,31 @@ private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
 
         private static IObservable<IUnion2<int, int>> Driver(IObservable<IUnion2<int, int>> sinks)
         {
-            var fac = GenericUnions.DoubletFactory<int, int>();
+            var sinkStreams = sinks.ToStreams();
 
-            var logSinks = sinks.SelectMany(s => s.Join(
-                mapFirst: Observable.Return,
-                mapSecond: _ => Observable.Empty<int>()));
+            var logSinks = sinkStreams.First;
             var logSources = LogDriver(logSinks);
 
-            var keyInputSinks = sinks.SelectMany(s => s.Join(
-                mapFirst: _ => Observable.Empty<int>(),
-                mapSecond: Observable.Return));
+            var keyInputSinks = sinkStreams.Second;
             var keyInputSources = KeyInputDriver(keyInputSinks);
 
-            return Observable.Merge(
-                logSources.Select(fac.First),
-                keyInputSources.Select(fac.Second));
+            return new Streams<int, int>(
+                logSources,
+                keyInputSources)
+                .ToStream();
         }
 
         private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int, int>> sources)
         {
-            var fac = GenericUnions.DoubletFactory<int, int>();
+            var sourceStreams = sources.ToStreams();
 
-            var keyInputSources = sources.SelectMany(s => s.Join(
-                mapFirst: _ => Observable.Empty<int>(),
-                mapSecond: Observable.Return));
-            var sinks = keyInputSources.Select(fac.First);
+            var keyInputSource = sourceStreams.Second;
+            var logSink = keyInputSource;
+            var sinkStreams = new Streams<int, int>(
+                logSink,
+                Observable.Empty<int>());
 
-            return sinks;
+            return sinkStreams.ToStream();
         }
         static void Main(string[] args)
         {
diff --git a/Cycle.NET/Cycle.NET.csproj b/Cycle.NET/Cycle.NET.csproj
index 624b282..ce9389a 100644
--- a/Cycle.NET/Cycle.NET.csproj
+++ b/Cycle.NET/Cycle.NET.csproj
@@ -5,6 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.0" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 
diff --git a/Cycle.NET/Extensions/StreamsExtensions.cs b/Cycle.NET/Extensions/StreamsExtensions.cs
new file mode 100644
index 0000000..63c05bf
--- /dev/null
+++ b/Cycle.NET/Extensions/StreamsExtensions.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Reactive.Linq;
+using SdgApps.Common.DotnetSealedUnions;
+
+namespace Cycle.NET.Extensions
+{
+    public static class StreamsExtensions
+    {
+        public static Streams<TFirst, TSecond> ToStreams<TFirst, TSecond>(
+            this IObservable<IUnion2<TFirst, TSecond>> source)
+        {
+            var first = source.SelectMany(s => s.Join(
+                mapFirst: Observable.Return,
+                mapSecond: _ => Observable.Empty<TFirst>()));
+
+            var second = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSecond>(),
+                mapSecond: Observable.Return));
+
+            return new Streams<TFirst, TSecond>(
+                first,
+                second);
+        }
+    }
+}
diff --git a/Cycle.NET/Streams2.cs b/Cycle.NET/Streams2.cs
new file mode 100644
index 0000000..20a24cf
--- /dev/null
+++ b/Cycle.NET/Streams2.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Reactive.Linq;
+using SdgApps.Common.DotnetSealedUnions;
+using SdgApps.Common.DotnetSealedUnions.Generic;
+
+namespace Cycle.NET
+{
+    public class Streams<TFirst, TSecond>
+    {
+        public Streams(
+            IObservable<TFirst> first,
+            IObservable<TSecond> second)
+        {
+            First = first;
+            Second = second;
+        }
+
+        public IObservable<TFirst> First { get; }
+        public IObservable<TSecond> Second { get; }
+
+        public IObservable<IUnion2<TFirst, TSecond>> ToStream()
+        {
+            var fac = GenericUnions.DoubletFactory<TFirst, TSecond>();
+
+            var first = this.First.Select(fac.First);
+            var second = this.Second.Select(fac.Second);
+
+            return Observable.Merge(
+                first,
+                second);
+        }
+    }
+}

From d6cabf35f4e552079c87148f0c86b1893fef7550 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Sat, 1 Apr 2023 23:30:57 -0400
Subject: [PATCH 14/42] Replace streams with generic tuple

---
 Cycle.NET.Demo/Program.cs                     | 24 +++++++-------
 ...nsions.cs => ObservableUnionExtensions.cs} | 16 +++++----
 Cycle.NET/ObservableUnion.cs                  | 24 ++++++++++++++
 Cycle.NET/Streams2.cs                         | 33 -------------------
 4 files changed, 44 insertions(+), 53 deletions(-)
 rename Cycle.NET/Extensions/{StreamsExtensions.cs => ObservableUnionExtensions.cs} (53%)
 create mode 100644 Cycle.NET/ObservableUnion.cs
 delete mode 100644 Cycle.NET/Streams2.cs

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index a5ebd4b..c0f4146 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -23,31 +23,29 @@ private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
 
         private static IObservable<IUnion2<int, int>> Driver(IObservable<IUnion2<int, int>> sinks)
         {
-            var sinkStreams = sinks.ToStreams();
+            var (
+                logSinks,
+                keyInputSinks) = sinks.Split();
 
-            var logSinks = sinkStreams.First;
             var logSources = LogDriver(logSinks);
-
-            var keyInputSinks = sinkStreams.Second;
             var keyInputSources = KeyInputDriver(keyInputSinks);
 
-            return new Streams<int, int>(
+            return ObservableUnion.Merge(
                 logSources,
-                keyInputSources)
-                .ToStream();
+                keyInputSources);
         }
 
         private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int, int>> sources)
         {
-            var sourceStreams = sources.ToStreams();
+            var (
+                _,
+                keyInputSources) = sources.Split();
+
+            var logSink = keyInputSources;
 
-            var keyInputSource = sourceStreams.Second;
-            var logSink = keyInputSource;
-            var sinkStreams = new Streams<int, int>(
+            return ObservableUnion.Merge(
                 logSink,
                 Observable.Empty<int>());
-
-            return sinkStreams.ToStream();
         }
         static void Main(string[] args)
         {
diff --git a/Cycle.NET/Extensions/StreamsExtensions.cs b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
similarity index 53%
rename from Cycle.NET/Extensions/StreamsExtensions.cs
rename to Cycle.NET/Extensions/ObservableUnionExtensions.cs
index 63c05bf..c4cf995 100644
--- a/Cycle.NET/Extensions/StreamsExtensions.cs
+++ b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
@@ -4,22 +4,24 @@
 
 namespace Cycle.NET.Extensions
 {
-    public static class StreamsExtensions
+    public static class ObservableUnionExtensions
     {
-        public static Streams<TFirst, TSecond> ToStreams<TFirst, TSecond>(
+        public static (
+            IObservable<TFirst> Firsts,
+            IObservable<TSecond> Seconds) Split<TFirst, TSecond>(
             this IObservable<IUnion2<TFirst, TSecond>> source)
         {
-            var first = source.SelectMany(s => s.Join(
+            var firsts = source.SelectMany(s => s.Join(
                 mapFirst: Observable.Return,
                 mapSecond: _ => Observable.Empty<TFirst>()));
 
-            var second = source.SelectMany(s => s.Join(
+            var seconds = source.SelectMany(s => s.Join(
                 mapFirst: _ => Observable.Empty<TSecond>(),
                 mapSecond: Observable.Return));
 
-            return new Streams<TFirst, TSecond>(
-                first,
-                second);
+            return (
+                Firsts: firsts,
+                Seconds: seconds);
         }
     }
 }
diff --git a/Cycle.NET/ObservableUnion.cs b/Cycle.NET/ObservableUnion.cs
new file mode 100644
index 0000000..e6a3060
--- /dev/null
+++ b/Cycle.NET/ObservableUnion.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Reactive.Linq;
+using SdgApps.Common.DotnetSealedUnions;
+using SdgApps.Common.DotnetSealedUnions.Generic;
+
+namespace Cycle.NET
+{
+    public static class ObservableUnion
+    {
+        public static IObservable<IUnion2<TFirst, TSecond>> Merge<TFirst, TSecond>(
+            IObservable<TFirst> firsts,
+            IObservable<TSecond> seconds)
+        {
+            var fac = GenericUnions.DoubletFactory<TFirst, TSecond>();
+
+            var unionFirsts = firsts.Select(fac.First);
+            var unionSeconds = seconds.Select(fac.Second);
+
+            return Observable.Merge(
+                unionFirsts,
+                unionSeconds);
+        }
+    }
+}
diff --git a/Cycle.NET/Streams2.cs b/Cycle.NET/Streams2.cs
deleted file mode 100644
index 20a24cf..0000000
--- a/Cycle.NET/Streams2.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using System;
-using System.Reactive.Linq;
-using SdgApps.Common.DotnetSealedUnions;
-using SdgApps.Common.DotnetSealedUnions.Generic;
-
-namespace Cycle.NET
-{
-    public class Streams<TFirst, TSecond>
-    {
-        public Streams(
-            IObservable<TFirst> first,
-            IObservable<TSecond> second)
-        {
-            First = first;
-            Second = second;
-        }
-
-        public IObservable<TFirst> First { get; }
-        public IObservable<TSecond> Second { get; }
-
-        public IObservable<IUnion2<TFirst, TSecond>> ToStream()
-        {
-            var fac = GenericUnions.DoubletFactory<TFirst, TSecond>();
-
-            var first = this.First.Select(fac.First);
-            var second = this.Second.Select(fac.Second);
-
-            return Observable.Merge(
-                first,
-                second);
-        }
-    }
-}

From 7bbb5d9f58e6f9a82bb5b9de039ad15bced8bf94 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Mon, 3 Apr 2023 21:07:32 -0400
Subject: [PATCH 15/42] Abstract calling drivers

---
 Cycle.NET.Demo/Program.cs                     | 13 ++-----
 .../Extensions/ObservableUnionExtensions.cs   | 35 +++++++++++++++++--
 2 files changed, 36 insertions(+), 12 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index c0f4146..c6c7aee 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -23,16 +23,9 @@ private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
 
         private static IObservable<IUnion2<int, int>> Driver(IObservable<IUnion2<int, int>> sinks)
         {
-            var (
-                logSinks,
-                keyInputSinks) = sinks.Split();
-
-            var logSources = LogDriver(logSinks);
-            var keyInputSources = KeyInputDriver(keyInputSinks);
-
-            return ObservableUnion.Merge(
-                logSources,
-                keyInputSources);
+            return sinks.CallDrivers(
+                LogDriver,
+                KeyInputDriver);
         }
 
         private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int, int>> sources)
diff --git a/Cycle.NET/Extensions/ObservableUnionExtensions.cs b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
index c4cf995..fabcbb0 100644
--- a/Cycle.NET/Extensions/ObservableUnionExtensions.cs
+++ b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
@@ -8,8 +8,13 @@ public static class ObservableUnionExtensions
     {
         public static (
             IObservable<TFirst> Firsts,
-            IObservable<TSecond> Seconds) Split<TFirst, TSecond>(
-            this IObservable<IUnion2<TFirst, TSecond>> source)
+            IObservable<TSecond> Seconds)
+            Split<
+            TFirst,
+            TSecond>(
+            this IObservable<IUnion2<
+                TFirst,
+                TSecond>> source)
         {
             var firsts = source.SelectMany(s => s.Join(
                 mapFirst: Observable.Return,
@@ -23,5 +28,31 @@ public static (
                 Firsts: firsts,
                 Seconds: seconds);
         }
+
+        public static IObservable<IUnion2<
+            TFirstSource,
+            TSecondSource>>
+            CallDrivers<
+            TFirstSink,
+            TFirstSource,
+            TSecondSink,
+            TSecondSource>(
+            this IObservable<IUnion2<
+                TFirstSink,
+                TSecondSink>> sinks,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
+            Func<IObservable<TSecondSink>, IObservable<TSecondSource>> secondDriver)
+        {
+            var (
+                firstSink,
+                secondSink) = sinks.Split();
+
+            var firstSource = firstDriver(firstSink);
+            var secondSource = secondDriver(secondSink);
+
+            return ObservableUnion.Merge(
+                firstSource,
+                secondSource);
+        }
     }
 }

From a8747dde5c9cf8fa6c437bd230b526a132cafc8c Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Mon, 3 Apr 2023 21:16:03 -0400
Subject: [PATCH 16/42] Move drivers caller

---
 Cycle.NET.Demo/Program.cs                     | 12 +++----
 Cycle.NET/Drivers.cs                          | 35 +++++++++++++++++++
 .../Extensions/ObservableUnionExtensions.cs   | 26 --------------
 Cycle.NET/Runner.cs                           |  2 +-
 4 files changed, 40 insertions(+), 35 deletions(-)
 create mode 100644 Cycle.NET/Drivers.cs

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index c6c7aee..0528fbc 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -21,13 +21,6 @@ private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
             return Observable.Range(20, 5);
         }
 
-        private static IObservable<IUnion2<int, int>> Driver(IObservable<IUnion2<int, int>> sinks)
-        {
-            return sinks.CallDrivers(
-                LogDriver,
-                KeyInputDriver);
-        }
-
         private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int, int>> sources)
         {
             var (
@@ -45,7 +38,10 @@ static void Main(string[] args)
             var component = new Component<IUnion2<int, int>, IUnion2<int, int>>(
                 CycleMain);
             var drivers = new Drivers<IUnion2<int, int>, IUnion2<int, int>>(
-                onFirst: Driver);
+                onFirst: sinks => Drivers.Call(
+                    sinks,
+                    LogDriver,
+                    KeyInputDriver));
             Runner<IUnion2<int, int>, IUnion2<int, int>>.Run(component, drivers);
             Console.ReadLine();
         }
diff --git a/Cycle.NET/Drivers.cs b/Cycle.NET/Drivers.cs
new file mode 100644
index 0000000..205be4c
--- /dev/null
+++ b/Cycle.NET/Drivers.cs
@@ -0,0 +1,35 @@
+using System;
+using Cycle.NET.Extensions;
+using SdgApps.Common.DotnetSealedUnions;
+
+namespace Cycle.NET
+{
+    public partial class Drivers
+    {
+        public static IObservable<IUnion2<
+            TFirstSource,
+            TSecondSource>>
+            Call<
+            TFirstSink,
+            TFirstSource,
+            TSecondSink,
+            TSecondSource>(
+            IObservable<IUnion2<
+                TFirstSink,
+                TSecondSink>> sinks,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
+            Func<IObservable<TSecondSink>, IObservable<TSecondSource>> secondDriver)
+        {
+            var (
+                firstSink,
+                secondSink) = sinks.Split();
+
+            var firstSource = firstDriver(firstSink);
+            var secondSource = secondDriver(secondSink);
+
+            return ObservableUnion.Merge(
+                firstSource,
+                secondSource);
+        }
+    }
+}
diff --git a/Cycle.NET/Extensions/ObservableUnionExtensions.cs b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
index fabcbb0..604159e 100644
--- a/Cycle.NET/Extensions/ObservableUnionExtensions.cs
+++ b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
@@ -28,31 +28,5 @@ this IObservable<IUnion2<
                 Firsts: firsts,
                 Seconds: seconds);
         }
-
-        public static IObservable<IUnion2<
-            TFirstSource,
-            TSecondSource>>
-            CallDrivers<
-            TFirstSink,
-            TFirstSource,
-            TSecondSink,
-            TSecondSource>(
-            this IObservable<IUnion2<
-                TFirstSink,
-                TSecondSink>> sinks,
-            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
-            Func<IObservable<TSecondSink>, IObservable<TSecondSource>> secondDriver)
-        {
-            var (
-                firstSink,
-                secondSink) = sinks.Split();
-
-            var firstSource = firstDriver(firstSink);
-            var secondSource = secondDriver(secondSink);
-
-            return ObservableUnion.Merge(
-                firstSource,
-                secondSource);
-        }
     }
 }
diff --git a/Cycle.NET/Runner.cs b/Cycle.NET/Runner.cs
index 07b668c..c9bb4fb 100644
--- a/Cycle.NET/Runner.cs
+++ b/Cycle.NET/Runner.cs
@@ -13,7 +13,7 @@ public Streams() : base() { }
         public Streams(Dictionary<string, IObservable<object>> value) : base(value) { }
     }
 
-    public class Drivers : Dictionary<string, Func<IObservable<object>, IObservable<object>>>
+    public partial class Drivers : Dictionary<string, Func<IObservable<object>, IObservable<object>>>
     {
         public Drivers() : base() { }
     }

From 24de5460e67736f9e1d8ad08c365c3856b55b87f Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Mon, 3 Apr 2023 23:17:19 -0400
Subject: [PATCH 17/42] Move driver call again

---
 Cycle.NET.Demo/Program.cs                                | 3 +--
 Cycle.NET/{Drivers.cs => Extensions/DriverExtensions.cs} | 6 +++---
 Cycle.NET/Runner.cs                                      | 2 +-
 3 files changed, 5 insertions(+), 6 deletions(-)
 rename Cycle.NET/{Drivers.cs => Extensions/DriverExtensions.cs} (89%)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 0528fbc..1511b06 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -38,8 +38,7 @@ static void Main(string[] args)
             var component = new Component<IUnion2<int, int>, IUnion2<int, int>>(
                 CycleMain);
             var drivers = new Drivers<IUnion2<int, int>, IUnion2<int, int>>(
-                onFirst: sinks => Drivers.Call(
-                    sinks,
+                onFirst: sinks => sinks.CallDrivers(
                     LogDriver,
                     KeyInputDriver));
             Runner<IUnion2<int, int>, IUnion2<int, int>>.Run(component, drivers);
diff --git a/Cycle.NET/Drivers.cs b/Cycle.NET/Extensions/DriverExtensions.cs
similarity index 89%
rename from Cycle.NET/Drivers.cs
rename to Cycle.NET/Extensions/DriverExtensions.cs
index 205be4c..d708023 100644
--- a/Cycle.NET/Drivers.cs
+++ b/Cycle.NET/Extensions/DriverExtensions.cs
@@ -4,17 +4,17 @@
 
 namespace Cycle.NET
 {
-    public partial class Drivers
+    public static class DriverExtensions
     {
         public static IObservable<IUnion2<
             TFirstSource,
             TSecondSource>>
-            Call<
+            CallDrivers<
             TFirstSink,
             TFirstSource,
             TSecondSink,
             TSecondSource>(
-            IObservable<IUnion2<
+            this IObservable<IUnion2<
                 TFirstSink,
                 TSecondSink>> sinks,
             Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
diff --git a/Cycle.NET/Runner.cs b/Cycle.NET/Runner.cs
index c9bb4fb..07b668c 100644
--- a/Cycle.NET/Runner.cs
+++ b/Cycle.NET/Runner.cs
@@ -13,7 +13,7 @@ public Streams() : base() { }
         public Streams(Dictionary<string, IObservable<object>> value) : base(value) { }
     }
 
-    public partial class Drivers : Dictionary<string, Func<IObservable<object>, IObservable<object>>>
+    public class Drivers : Dictionary<string, Func<IObservable<object>, IObservable<object>>>
     {
         public Drivers() : base() { }
     }

From 35fee2d29b96e46c63aae326ee7f8afaaefc5b67 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Mon, 3 Apr 2023 23:22:00 -0400
Subject: [PATCH 18/42] Remove redundant types

---
 Cycle.NET.Demo/Program.cs |  8 +++-----
 Cycle.NET/Runner1.cs      | 34 ++++++----------------------------
 2 files changed, 9 insertions(+), 33 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 1511b06..9b933e3 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -35,13 +35,11 @@ private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int,
         }
         static void Main(string[] args)
         {
-            var component = new Component<IUnion2<int, int>, IUnion2<int, int>>(
-                CycleMain);
-            var drivers = new Drivers<IUnion2<int, int>, IUnion2<int, int>>(
-                onFirst: sinks => sinks.CallDrivers(
+            Runner<IUnion2<int, int>, IUnion2<int, int>>.Run(
+                CycleMain,
+                sinks => sinks.CallDrivers(
                     LogDriver,
                     KeyInputDriver));
-            Runner<IUnion2<int, int>, IUnion2<int, int>>.Run(component, drivers);
             Console.ReadLine();
         }
     }
diff --git a/Cycle.NET/Runner1.cs b/Cycle.NET/Runner1.cs
index 334b928..78a28b5 100644
--- a/Cycle.NET/Runner1.cs
+++ b/Cycle.NET/Runner1.cs
@@ -4,42 +4,20 @@
 
 namespace Cycle.NET
 {
-    public class Component<TSource1, TSink1>
-    {
-        public Component(
-            Func<IObservable<TSource1>, IObservable<TSink1>> main)
-        {
-            Main = main;
-        }
-
-        public Func<IObservable<TSource1>, IObservable<TSink1>> Main { get; }
-    }
-
-    public class Drivers<TSource1, TSink1>
-    {
-        public Drivers(
-            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst)
-        {
-            OnFirst = onFirst;
-        }
-
-        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
-    }
-
-    public static class Runner<TSource1, TSink1>
+    public static class Runner<TSources, TSinks>
     {
         public static void Run(
-            Component<TSource1, TSink1> component,
-            Drivers<TSource1, TSink1> drivers)
+            Func<IObservable<TSources>, IObservable<TSinks>> main,
+            Func<IObservable<TSinks>, IObservable<TSources>> drivers)
         {
             // Create fake sinks to use to call the drivers to get around the interdependency between
             // main and the drivers.
-            var fakeSinks = new ReplaySubject<TSink1>();
+            var fakeSinks = new ReplaySubject<TSinks>();
 
             // Call the drivers and collate the returned sources.
-            var sources = drivers.OnFirst(fakeSinks);
+            var sources = drivers(fakeSinks);
 
-            IObservable<TSink1> sinks = component.Main(sources);
+            var sinks = main(sources);
 
             // Update the sinks returned from main with the sinks used by the drivers.
             sinks.Subscribe(fakeSinks.OnNext);

From 996d75e5471aa2460e4428cb99737b5cb9612972 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Mon, 3 Apr 2023 23:28:25 -0400
Subject: [PATCH 19/42] Collapse down to one runner

---
 Cycle.NET.Demo/Program.cs                     |  2 +-
 ...riverExtensions.cs => RunnerExtensions.cs} |  2 +-
 Cycle.NET/Runner.cs                           | 29 ++----
 Cycle.NET/Runner1.cs                          | 26 -----
 Cycle.NET/Runner3.cs                          | 97 -------------------
 5 files changed, 9 insertions(+), 147 deletions(-)
 rename Cycle.NET/Extensions/{DriverExtensions.cs => RunnerExtensions.cs} (95%)
 delete mode 100644 Cycle.NET/Runner1.cs
 delete mode 100644 Cycle.NET/Runner3.cs

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 9b933e3..4a3e6e5 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -35,7 +35,7 @@ private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int,
         }
         static void Main(string[] args)
         {
-            Runner<IUnion2<int, int>, IUnion2<int, int>>.Run(
+            Runner.Run<IUnion2<int, int>, IUnion2<int, int>>(
                 CycleMain,
                 sinks => sinks.CallDrivers(
                     LogDriver,
diff --git a/Cycle.NET/Extensions/DriverExtensions.cs b/Cycle.NET/Extensions/RunnerExtensions.cs
similarity index 95%
rename from Cycle.NET/Extensions/DriverExtensions.cs
rename to Cycle.NET/Extensions/RunnerExtensions.cs
index d708023..4047506 100644
--- a/Cycle.NET/Extensions/DriverExtensions.cs
+++ b/Cycle.NET/Extensions/RunnerExtensions.cs
@@ -4,7 +4,7 @@
 
 namespace Cycle.NET
 {
-    public static class DriverExtensions
+    public static class RunnerExtensions
     {
         public static IObservable<IUnion2<
             TFirstSource,
diff --git a/Cycle.NET/Runner.cs b/Cycle.NET/Runner.cs
index 07b668c..2d6b1e9 100644
--- a/Cycle.NET/Runner.cs
+++ b/Cycle.NET/Runner.cs
@@ -1,41 +1,26 @@
 using System;
-using System.Collections.Generic;
-using System.Reactive;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
-using System.Linq;
 
 namespace Cycle.NET
 {
-    public class Streams : Dictionary<string, IObservable<object>>
-    {
-        public Streams() : base() { }
-        public Streams(Dictionary<string, IObservable<object>> value) : base(value) { }
-    }
-
-    public class Drivers : Dictionary<string, Func<IObservable<object>, IObservable<object>>>
-    {
-        public Drivers() : base() { }
-    }
-
     public static class Runner
     {
-        public static void Run(Func<Streams, Streams> main, Drivers drivers)
+        public static void Run<TSources, TSinks>(
+            Func<IObservable<TSources>, IObservable<TSinks>> main,
+            Func<IObservable<TSinks>, IObservable<TSources>> drivers)
         {
             // Create fake sinks to use to call the drivers to get around the interdependency between
             // main and the drivers.
-            var fakeSinks = drivers.ToDictionary(d => d.Key, d => new ReplaySubject<object>());
+            var fakeSinks = new ReplaySubject<TSinks>();
 
             // Call the drivers and collate the returned sources.
-            var sources = drivers.ToDictionary(d => d.Key, d => d.Value(fakeSinks[d.Key]));
+            var sources = drivers(fakeSinks);
 
-            Streams sinks = main(new Streams(sources));
+            var sinks = main(sources);
 
             // Update the sinks returned from main with the sinks used by the drivers.
-            foreach (var sink in sinks)
-            {
-                sink.Value.Subscribe(s => fakeSinks[sink.Key].OnNext(s));
-            }
+            sinks.Subscribe(fakeSinks.OnNext);
         }
     }
 }
diff --git a/Cycle.NET/Runner1.cs b/Cycle.NET/Runner1.cs
deleted file mode 100644
index 78a28b5..0000000
--- a/Cycle.NET/Runner1.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using System;
-using System.Reactive.Linq;
-using System.Reactive.Subjects;
-
-namespace Cycle.NET
-{
-    public static class Runner<TSources, TSinks>
-    {
-        public static void Run(
-            Func<IObservable<TSources>, IObservable<TSinks>> main,
-            Func<IObservable<TSinks>, IObservable<TSources>> drivers)
-        {
-            // Create fake sinks to use to call the drivers to get around the interdependency between
-            // main and the drivers.
-            var fakeSinks = new ReplaySubject<TSinks>();
-
-            // Call the drivers and collate the returned sources.
-            var sources = drivers(fakeSinks);
-
-            var sinks = main(sources);
-
-            // Update the sinks returned from main with the sinks used by the drivers.
-            sinks.Subscribe(fakeSinks.OnNext);
-        }
-    }
-}
diff --git a/Cycle.NET/Runner3.cs b/Cycle.NET/Runner3.cs
deleted file mode 100644
index 585d973..0000000
--- a/Cycle.NET/Runner3.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-using System;
-using System.Reactive.Linq;
-using System.Reactive.Subjects;
-
-namespace Cycle.NET
-{
-    public class Streams<T1, T2, T3>
-    {
-        public Streams(
-            IObservable<T1> first,
-            IObservable<T2> second,
-            IObservable<T3> third)
-        {
-            First = first;
-            Second = second;
-            Third = third;
-        }
-
-        public IObservable<T1> First { get; }
-        public IObservable<T2> Second { get; }
-        public IObservable<T3> Third { get; }
-    }
-
-    public class Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
-    {
-        public Component(
-            Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> main)
-        {
-            Main = main;
-        }
-
-        public Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> Main { get; }
-    }
-
-    public class Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
-    {
-        public Drivers(
-            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
-            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond,
-            Func<IObservable<TSink3>, IObservable<TSource3>> onThird)
-        {
-            OnFirst = onFirst;
-            OnSecond = onSecond;
-            OnThird = onThird;
-        }
-
-        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
-        public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
-        public Func<IObservable<TSink3>, IObservable<TSource3>> OnThird { get; }
-    }
-
-    public static class Runner<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
-    {
-        public static void Run(
-            Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> component,
-            Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> drivers)
-        {
-            // Create fake sinks to use to call the drivers to get around the interdependency between
-            // main and the drivers.
-            var fakeSinks = new FakeSinks<TSink1, TSink2, TSink3>(
-                new ReplaySubject<TSink1>(),
-                new ReplaySubject<TSink2>(),
-                new ReplaySubject<TSink3>());
-
-            // Call the drivers and collate the returned sources.
-            var sources = new Streams<TSource1, TSource2, TSource3>(
-                drivers.OnFirst(fakeSinks.First),
-                drivers.OnSecond(fakeSinks.Second),
-                drivers.OnThird(fakeSinks.Third));
-
-            Streams<TSink1, TSink2, TSink3> sinks = component.Main(sources);
-
-            // Update the sinks returned from main with the sinks used by the drivers.
-            sinks.First.Subscribe(fakeSinks.First.OnNext);
-            sinks.Second.Subscribe(fakeSinks.Second.OnNext);
-            sinks.Third.Subscribe(fakeSinks.Third.OnNext);
-        }
-
-        private class FakeSinks<T1, T2, T3>
-        {
-            public FakeSinks(
-                ISubject<T1> first,
-                ISubject<T2> second,
-                ISubject<T3> third)
-            {
-                First = first;
-                Second = second;
-                Third = third;
-            }
-
-            public ISubject<T1> First { get; }
-            public ISubject<T2> Second { get; }
-            public ISubject<T3> Third { get; }
-        }
-
-    }
-}

From 1ef53ca494dfef51ce0fa638be551a5279118ef4 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Tue, 4 Apr 2023 21:47:18 -0400
Subject: [PATCH 20/42] Scale arity

---
 .../Extensions/ObservableUnionExtensions.cs   | 616 ++++++++++++++++++
 Cycle.NET/Extensions/RunnerExtensions.cs      | 446 +++++++++++++
 Cycle.NET/ObservableUnion.cs                  | 360 +++++++++-
 3 files changed, 1420 insertions(+), 2 deletions(-)

diff --git a/Cycle.NET/Extensions/ObservableUnionExtensions.cs b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
index 604159e..36461e1 100644
--- a/Cycle.NET/Extensions/ObservableUnionExtensions.cs
+++ b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Reactive;
 using System.Reactive.Linq;
 using SdgApps.Common.DotnetSealedUnions;
 
@@ -6,6 +7,40 @@ namespace Cycle.NET.Extensions
 {
     public static class ObservableUnionExtensions
     {
+        public static
+            IObservable<TFirst>
+            Split<
+            TFirst>(
+            this IObservable<IUnion0<
+                TFirst>> source)
+        {
+            var firsts = source.SelectMany(s => s.Join(
+                mapFirst: Observable.Return));
+
+            return firsts;
+        }
+
+        public static (
+            IObservable<Unit> Nones,
+            IObservable<TFirst> Firsts)
+            Split<
+            TFirst>(
+            this IObservable<IUnion1<
+                TFirst>> source)
+        {
+            var nones = source.SelectMany(s => s.Join(
+                mapNone: () => Observable.Return(Unit.Default),
+                mapFirst: _ => Observable.Empty<Unit>()));
+
+            var firsts = source.SelectMany(s => s.Join(
+                mapNone: Observable.Empty<TFirst>,
+                mapFirst: Observable.Return));
+
+            return (
+                Nones: nones,
+                Firsts: firsts);
+        }
+
         public static (
             IObservable<TFirst> Firsts,
             IObservable<TSecond> Seconds)
@@ -28,5 +63,586 @@ this IObservable<IUnion2<
                 Firsts: firsts,
                 Seconds: seconds);
         }
+
+        public static (
+            IObservable<TFirst> Firsts,
+            IObservable<TSecond> Seconds,
+            IObservable<TThird> Thirds)
+            Split<
+            TFirst,
+            TSecond,
+            TThird>(
+            this IObservable<IUnion3<
+                TFirst,
+                TSecond,
+                TThird>> source)
+        {
+            var firsts = source.SelectMany(s => s.Join(
+                mapFirst: Observable.Return,
+                mapSecond: _ => Observable.Empty<TFirst>(),
+                mapThird: _ => Observable.Empty<TFirst>()));
+
+            var seconds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSecond>(),
+                mapSecond: Observable.Return,
+                mapThird: _ => Observable.Empty<TSecond>()));
+
+            var thirds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TThird>(),
+                mapSecond: _ => Observable.Empty<TThird>(),
+                mapThird: Observable.Return));
+
+            return (
+                Firsts: firsts,
+                Seconds: seconds,
+                Thirds: thirds);
+        }
+
+        public static (
+            IObservable<TFirst> Firsts,
+            IObservable<TSecond> Seconds,
+            IObservable<TThird> Thirds,
+            IObservable<TFourth> Fourths)
+            Split<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth>(
+            this IObservable<IUnion4<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth>> source)
+        {
+            var firsts = source.SelectMany(s => s.Join(
+                mapFirst: Observable.Return,
+                mapSecond: _ => Observable.Empty<TFirst>(),
+                mapThird: _ => Observable.Empty<TFirst>(),
+                mapFourth: _ => Observable.Empty<TFirst>()));
+
+            var seconds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSecond>(),
+                mapSecond: Observable.Return,
+                mapThird: _ => Observable.Empty<TSecond>(),
+                mapFourth: _ => Observable.Empty<TSecond>()));
+
+            var thirds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TThird>(),
+                mapSecond: _ => Observable.Empty<TThird>(),
+                mapThird: Observable.Return,
+                mapFourth: _ => Observable.Empty<TThird>()));
+
+            var fourths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFourth>(),
+                mapSecond: _ => Observable.Empty<TFourth>(),
+                mapThird: _ => Observable.Empty<TFourth>(),
+                mapFourth: Observable.Return));
+
+            return (
+                Firsts: firsts,
+                Seconds: seconds,
+                Thirds: thirds,
+                Fourths: fourths);
+        }
+
+        public static (
+            IObservable<TFirst> Firsts,
+            IObservable<TSecond> Seconds,
+            IObservable<TThird> Thirds,
+            IObservable<TFourth> Fourths,
+            IObservable<TFifth> Fifths)
+            Split<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth>(
+            this IObservable<IUnion5<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth,
+                TFifth>> source)
+        {
+            var firsts = source.SelectMany(s => s.Join(
+                mapFirst: Observable.Return,
+                mapSecond: _ => Observable.Empty<TFirst>(),
+                mapThird: _ => Observable.Empty<TFirst>(),
+                mapFourth: _ => Observable.Empty<TFirst>(),
+                mapFifth: _ => Observable.Empty<TFirst>()));
+
+            var seconds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSecond>(),
+                mapSecond: Observable.Return,
+                mapThird: _ => Observable.Empty<TSecond>(),
+                mapFourth: _ => Observable.Empty<TSecond>(),
+                mapFifth: _ => Observable.Empty<TSecond>()));
+
+            var thirds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TThird>(),
+                mapSecond: _ => Observable.Empty<TThird>(),
+                mapThird: Observable.Return,
+                mapFourth: _ => Observable.Empty<TThird>(),
+                mapFifth: _ => Observable.Empty<TThird>()));
+
+            var fourths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFourth>(),
+                mapSecond: _ => Observable.Empty<TFourth>(),
+                mapThird: _ => Observable.Empty<TFourth>(),
+                mapFourth: Observable.Return,
+                mapFifth: _ => Observable.Empty<TFourth>()));
+
+            var fifths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFifth>(),
+                mapSecond: _ => Observable.Empty<TFifth>(),
+                mapThird: _ => Observable.Empty<TFifth>(),
+                mapFourth: _ => Observable.Empty<TFifth>(),
+                mapFifth: Observable.Return));
+
+            return (
+                Firsts: firsts,
+                Seconds: seconds,
+                Thirds: thirds,
+                Fourths: fourths,
+                Fifths: fifths);
+        }
+
+        public static (
+            IObservable<TFirst> Firsts,
+            IObservable<TSecond> Seconds,
+            IObservable<TThird> Thirds,
+            IObservable<TFourth> Fourths,
+            IObservable<TFifth> Fifths,
+            IObservable<TSixth> Sixths)
+            Split<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth>(
+            this IObservable<IUnion6<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth,
+                TFifth,
+                TSixth>> source)
+        {
+            var firsts = source.SelectMany(s => s.Join(
+                mapFirst: Observable.Return,
+                mapSecond: _ => Observable.Empty<TFirst>(),
+                mapThird: _ => Observable.Empty<TFirst>(),
+                mapFourth: _ => Observable.Empty<TFirst>(),
+                mapFifth: _ => Observable.Empty<TFirst>(),
+                mapSixth: _ => Observable.Empty<TFirst>()));
+
+            var seconds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSecond>(),
+                mapSecond: Observable.Return,
+                mapThird: _ => Observable.Empty<TSecond>(),
+                mapFourth: _ => Observable.Empty<TSecond>(),
+                mapFifth: _ => Observable.Empty<TSecond>(),
+                mapSixth: _ => Observable.Empty<TSecond>()));
+
+            var thirds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TThird>(),
+                mapSecond: _ => Observable.Empty<TThird>(),
+                mapThird: Observable.Return,
+                mapFourth: _ => Observable.Empty<TThird>(),
+                mapFifth: _ => Observable.Empty<TThird>(),
+                mapSixth: _ => Observable.Empty<TThird>()));
+
+            var fourths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFourth>(),
+                mapSecond: _ => Observable.Empty<TFourth>(),
+                mapThird: _ => Observable.Empty<TFourth>(),
+                mapFourth: Observable.Return,
+                mapFifth: _ => Observable.Empty<TFourth>(),
+                mapSixth: _ => Observable.Empty<TFourth>()));
+
+            var fifths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFifth>(),
+                mapSecond: _ => Observable.Empty<TFifth>(),
+                mapThird: _ => Observable.Empty<TFifth>(),
+                mapFourth: _ => Observable.Empty<TFifth>(),
+                mapFifth: Observable.Return,
+                mapSixth: _ => Observable.Empty<TFifth>()));
+
+            var sixths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSixth>(),
+                mapSecond: _ => Observable.Empty<TSixth>(),
+                mapThird: _ => Observable.Empty<TSixth>(),
+                mapFourth: _ => Observable.Empty<TSixth>(),
+                mapFifth: _ => Observable.Empty<TSixth>(),
+                mapSixth: Observable.Return));
+
+            return (
+                Firsts: firsts,
+                Seconds: seconds,
+                Thirds: thirds,
+                Fourths: fourths,
+                Fifths: fifths,
+                Sixths: sixths);
+        }
+
+        public static (
+            IObservable<TFirst> Firsts,
+            IObservable<TSecond> Seconds,
+            IObservable<TThird> Thirds,
+            IObservable<TFourth> Fourths,
+            IObservable<TFifth> Fifths,
+            IObservable<TSixth> Sixths,
+            IObservable<TSeventh> Sevenths)
+            Split<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth,
+            TSeventh>(
+            this IObservable<IUnion7<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth,
+                TFifth,
+                TSixth,
+                TSeventh>> source)
+        {
+            var firsts = source.SelectMany(s => s.Join(
+                mapFirst: Observable.Return,
+                mapSecond: _ => Observable.Empty<TFirst>(),
+                mapThird: _ => Observable.Empty<TFirst>(),
+                mapFourth: _ => Observable.Empty<TFirst>(),
+                mapFifth: _ => Observable.Empty<TFirst>(),
+                mapSixth: _ => Observable.Empty<TFirst>(),
+                mapSeventh: _ => Observable.Empty<TFirst>()));
+
+            var seconds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSecond>(),
+                mapSecond: Observable.Return,
+                mapThird: _ => Observable.Empty<TSecond>(),
+                mapFourth: _ => Observable.Empty<TSecond>(),
+                mapFifth: _ => Observable.Empty<TSecond>(),
+                mapSixth: _ => Observable.Empty<TSecond>(),
+                mapSeventh: _ => Observable.Empty<TSecond>()));
+
+            var thirds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TThird>(),
+                mapSecond: _ => Observable.Empty<TThird>(),
+                mapThird: Observable.Return,
+                mapFourth: _ => Observable.Empty<TThird>(),
+                mapFifth: _ => Observable.Empty<TThird>(),
+                mapSixth: _ => Observable.Empty<TThird>(),
+                mapSeventh: _ => Observable.Empty<TThird>()));
+
+            var fourths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFourth>(),
+                mapSecond: _ => Observable.Empty<TFourth>(),
+                mapThird: _ => Observable.Empty<TFourth>(),
+                mapFourth: Observable.Return,
+                mapFifth: _ => Observable.Empty<TFourth>(),
+                mapSixth: _ => Observable.Empty<TFourth>(),
+                mapSeventh: _ => Observable.Empty<TFourth>()));
+
+            var fifths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFifth>(),
+                mapSecond: _ => Observable.Empty<TFifth>(),
+                mapThird: _ => Observable.Empty<TFifth>(),
+                mapFourth: _ => Observable.Empty<TFifth>(),
+                mapFifth: Observable.Return,
+                mapSixth: _ => Observable.Empty<TFifth>(),
+                mapSeventh: _ => Observable.Empty<TFifth>()));
+
+            var sixths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSixth>(),
+                mapSecond: _ => Observable.Empty<TSixth>(),
+                mapThird: _ => Observable.Empty<TSixth>(),
+                mapFourth: _ => Observable.Empty<TSixth>(),
+                mapFifth: _ => Observable.Empty<TSixth>(),
+                mapSixth: Observable.Return,
+                mapSeventh: _ => Observable.Empty<TSixth>()));
+
+            var sevenths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSeventh>(),
+                mapSecond: _ => Observable.Empty<TSeventh>(),
+                mapThird: _ => Observable.Empty<TSeventh>(),
+                mapFourth: _ => Observable.Empty<TSeventh>(),
+                mapFifth: _ => Observable.Empty<TSeventh>(),
+                mapSixth: _ => Observable.Empty<TSeventh>(),
+                mapSeventh: Observable.Return));
+
+            return (
+                Firsts: firsts,
+                Seconds: seconds,
+                Thirds: thirds,
+                Fourths: fourths,
+                Fifths: fifths,
+                Sixths: sixths,
+                Sevenths: sevenths);
+        }
+
+        public static (
+            IObservable<TFirst> Firsts,
+            IObservable<TSecond> Seconds,
+            IObservable<TThird> Thirds,
+            IObservable<TFourth> Fourths,
+            IObservable<TFifth> Fifths,
+            IObservable<TSixth> Sixths,
+            IObservable<TSeventh> Sevenths,
+            IObservable<TEighth> Eighths)
+            Split<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth,
+            TSeventh,
+            TEighth>(
+            this IObservable<IUnion8<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth,
+                TFifth,
+                TSixth,
+                TSeventh,
+                TEighth>> source)
+        {
+            var firsts = source.SelectMany(s => s.Join(
+                mapFirst: Observable.Return,
+                mapSecond: _ => Observable.Empty<TFirst>(),
+                mapThird: _ => Observable.Empty<TFirst>(),
+                mapFourth: _ => Observable.Empty<TFirst>(),
+                mapFifth: _ => Observable.Empty<TFirst>(),
+                mapSixth: _ => Observable.Empty<TFirst>(),
+                mapSeventh: _ => Observable.Empty<TFirst>(),
+                mapEighth: _ => Observable.Empty<TFirst>()));
+
+            var seconds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSecond>(),
+                mapSecond: Observable.Return,
+                mapThird: _ => Observable.Empty<TSecond>(),
+                mapFourth: _ => Observable.Empty<TSecond>(),
+                mapFifth: _ => Observable.Empty<TSecond>(),
+                mapSixth: _ => Observable.Empty<TSecond>(),
+                mapSeventh: _ => Observable.Empty<TSecond>(),
+                mapEighth: _ => Observable.Empty<TSecond>()));
+
+            var thirds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TThird>(),
+                mapSecond: _ => Observable.Empty<TThird>(),
+                mapThird: Observable.Return,
+                mapFourth: _ => Observable.Empty<TThird>(),
+                mapFifth: _ => Observable.Empty<TThird>(),
+                mapSixth: _ => Observable.Empty<TThird>(),
+                mapSeventh: _ => Observable.Empty<TThird>(),
+                mapEighth: _ => Observable.Empty<TThird>()));
+
+            var fourths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFourth>(),
+                mapSecond: _ => Observable.Empty<TFourth>(),
+                mapThird: _ => Observable.Empty<TFourth>(),
+                mapFourth: Observable.Return,
+                mapFifth: _ => Observable.Empty<TFourth>(),
+                mapSixth: _ => Observable.Empty<TFourth>(),
+                mapSeventh: _ => Observable.Empty<TFourth>(),
+                mapEighth: _ => Observable.Empty<TFourth>()));
+
+            var fifths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFifth>(),
+                mapSecond: _ => Observable.Empty<TFifth>(),
+                mapThird: _ => Observable.Empty<TFifth>(),
+                mapFourth: _ => Observable.Empty<TFifth>(),
+                mapFifth: Observable.Return,
+                mapSixth: _ => Observable.Empty<TFifth>(),
+                mapSeventh: _ => Observable.Empty<TFifth>(),
+                mapEighth: _ => Observable.Empty<TFifth>()));
+
+            var sixths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSixth>(),
+                mapSecond: _ => Observable.Empty<TSixth>(),
+                mapThird: _ => Observable.Empty<TSixth>(),
+                mapFourth: _ => Observable.Empty<TSixth>(),
+                mapFifth: _ => Observable.Empty<TSixth>(),
+                mapSixth: Observable.Return,
+                mapSeventh: _ => Observable.Empty<TSixth>(),
+                mapEighth: _ => Observable.Empty<TSixth>()));
+
+            var sevenths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSeventh>(),
+                mapSecond: _ => Observable.Empty<TSeventh>(),
+                mapThird: _ => Observable.Empty<TSeventh>(),
+                mapFourth: _ => Observable.Empty<TSeventh>(),
+                mapFifth: _ => Observable.Empty<TSeventh>(),
+                mapSixth: _ => Observable.Empty<TSeventh>(),
+                mapSeventh: Observable.Return,
+                mapEighth: _ => Observable.Empty<TSeventh>()));
+
+            var eighths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TEighth>(),
+                mapSecond: _ => Observable.Empty<TEighth>(),
+                mapThird: _ => Observable.Empty<TEighth>(),
+                mapFourth: _ => Observable.Empty<TEighth>(),
+                mapFifth: _ => Observable.Empty<TEighth>(),
+                mapSixth: _ => Observable.Empty<TEighth>(),
+                mapSeventh: _ => Observable.Empty<TEighth>(),
+                mapEighth: Observable.Return));
+
+            return (
+                Firsts: firsts,
+                Seconds: seconds,
+                Thirds: thirds,
+                Fourths: fourths,
+                Fifths: fifths,
+                Sixths: sixths,
+                Sevenths: sevenths,
+                Eighths: eighths);
+        }
+
+        public static (
+            IObservable<TFirst> Firsts,
+            IObservable<TSecond> Seconds,
+            IObservable<TThird> Thirds,
+            IObservable<TFourth> Fourths,
+            IObservable<TFifth> Fifths,
+            IObservable<TSixth> Sixths,
+            IObservable<TSeventh> Sevenths,
+            IObservable<TEighth> Eighths,
+            IObservable<TNinth> Ninths)
+            Split<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth,
+            TSeventh,
+            TEighth,
+            TNinth>(
+            this IObservable<IUnion9<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth,
+                TFifth,
+                TSixth,
+                TSeventh,
+                TEighth,
+                TNinth>> source)
+        {
+            var firsts = source.SelectMany(s => s.Join(
+                mapFirst: Observable.Return,
+                mapSecond: _ => Observable.Empty<TFirst>(),
+                mapThird: _ => Observable.Empty<TFirst>(),
+                mapFourth: _ => Observable.Empty<TFirst>(),
+                mapFifth: _ => Observable.Empty<TFirst>(),
+                mapSixth: _ => Observable.Empty<TFirst>(),
+                mapSeventh: _ => Observable.Empty<TFirst>(),
+                mapEighth: _ => Observable.Empty<TFirst>(),
+                mapNinth: _ => Observable.Empty<TFirst>()));
+
+            var seconds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSecond>(),
+                mapSecond: Observable.Return,
+                mapThird: _ => Observable.Empty<TSecond>(),
+                mapFourth: _ => Observable.Empty<TSecond>(),
+                mapFifth: _ => Observable.Empty<TSecond>(),
+                mapSixth: _ => Observable.Empty<TSecond>(),
+                mapSeventh: _ => Observable.Empty<TSecond>(),
+                mapEighth: _ => Observable.Empty<TSecond>(),
+                mapNinth: _ => Observable.Empty<TSecond>()));
+
+            var thirds = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TThird>(),
+                mapSecond: _ => Observable.Empty<TThird>(),
+                mapThird: Observable.Return,
+                mapFourth: _ => Observable.Empty<TThird>(),
+                mapFifth: _ => Observable.Empty<TThird>(),
+                mapSixth: _ => Observable.Empty<TThird>(),
+                mapSeventh: _ => Observable.Empty<TThird>(),
+                mapEighth: _ => Observable.Empty<TThird>(),
+                mapNinth: _ => Observable.Empty<TThird>()));
+
+            var fourths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFourth>(),
+                mapSecond: _ => Observable.Empty<TFourth>(),
+                mapThird: _ => Observable.Empty<TFourth>(),
+                mapFourth: Observable.Return,
+                mapFifth: _ => Observable.Empty<TFourth>(),
+                mapSixth: _ => Observable.Empty<TFourth>(),
+                mapSeventh: _ => Observable.Empty<TFourth>(),
+                mapEighth: _ => Observable.Empty<TFourth>(),
+                mapNinth: _ => Observable.Empty<TFourth>()));
+
+            var fifths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TFifth>(),
+                mapSecond: _ => Observable.Empty<TFifth>(),
+                mapThird: _ => Observable.Empty<TFifth>(),
+                mapFourth: _ => Observable.Empty<TFifth>(),
+                mapFifth: Observable.Return,
+                mapSixth: _ => Observable.Empty<TFifth>(),
+                mapSeventh: _ => Observable.Empty<TFifth>(),
+                mapEighth: _ => Observable.Empty<TFifth>(),
+                mapNinth: _ => Observable.Empty<TFifth>()));
+
+            var sixths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSixth>(),
+                mapSecond: _ => Observable.Empty<TSixth>(),
+                mapThird: _ => Observable.Empty<TSixth>(),
+                mapFourth: _ => Observable.Empty<TSixth>(),
+                mapFifth: _ => Observable.Empty<TSixth>(),
+                mapSixth: Observable.Return,
+                mapSeventh: _ => Observable.Empty<TSixth>(),
+                mapEighth: _ => Observable.Empty<TSixth>(),
+                mapNinth: _ => Observable.Empty<TSixth>()));
+
+            var sevenths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TSeventh>(),
+                mapSecond: _ => Observable.Empty<TSeventh>(),
+                mapThird: _ => Observable.Empty<TSeventh>(),
+                mapFourth: _ => Observable.Empty<TSeventh>(),
+                mapFifth: _ => Observable.Empty<TSeventh>(),
+                mapSixth: _ => Observable.Empty<TSeventh>(),
+                mapSeventh: Observable.Return,
+                mapEighth: _ => Observable.Empty<TSeventh>(),
+                mapNinth: _ => Observable.Empty<TSeventh>()));
+
+            var eighths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TEighth>(),
+                mapSecond: _ => Observable.Empty<TEighth>(),
+                mapThird: _ => Observable.Empty<TEighth>(),
+                mapFourth: _ => Observable.Empty<TEighth>(),
+                mapFifth: _ => Observable.Empty<TEighth>(),
+                mapSixth: _ => Observable.Empty<TEighth>(),
+                mapSeventh: _ => Observable.Empty<TEighth>(),
+                mapEighth: Observable.Return,
+                mapNinth: _ => Observable.Empty<TEighth>()));
+
+            var ninths = source.SelectMany(s => s.Join(
+                mapFirst: _ => Observable.Empty<TNinth>(),
+                mapSecond: _ => Observable.Empty<TNinth>(),
+                mapThird: _ => Observable.Empty<TNinth>(),
+                mapFourth: _ => Observable.Empty<TNinth>(),
+                mapFifth: _ => Observable.Empty<TNinth>(),
+                mapSixth: _ => Observable.Empty<TNinth>(),
+                mapSeventh: _ => Observable.Empty<TNinth>(),
+                mapEighth: _ => Observable.Empty<TNinth>(),
+                mapNinth: Observable.Return));
+
+            return (
+                Firsts: firsts,
+                Seconds: seconds,
+                Thirds: thirds,
+                Fourths: fourths,
+                Fifths: fifths,
+                Sixths: sixths,
+                Sevenths: sevenths,
+                Eighths: eighths,
+                Ninths: ninths);
+        }
     }
 }
diff --git a/Cycle.NET/Extensions/RunnerExtensions.cs b/Cycle.NET/Extensions/RunnerExtensions.cs
index 4047506..f96a4c2 100644
--- a/Cycle.NET/Extensions/RunnerExtensions.cs
+++ b/Cycle.NET/Extensions/RunnerExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Reactive;
 using Cycle.NET.Extensions;
 using SdgApps.Common.DotnetSealedUnions;
 
@@ -6,6 +7,45 @@ namespace Cycle.NET
 {
     public static class RunnerExtensions
     {
+        public static IObservable<IUnion0<
+            TFirstSource>>
+            CallDrivers<
+            TFirstSink,
+            TFirstSource>(
+            this IObservable<IUnion0<
+                TFirstSink>> sinks,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver)
+        {
+            var firstSink = sinks.Split();
+
+            var firstSource = firstDriver(firstSink);
+
+            return ObservableUnion.Merge(
+                firstSource);
+        }
+
+        public static IObservable<IUnion1<
+            TFirstSource>>
+            CallDrivers<
+            TFirstSink,
+            TFirstSource>(
+            this IObservable<IUnion1<
+                TFirstSink>> sinks,
+            Func<IObservable<Unit>, IObservable<Unit>> noneDriver,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver)
+        {
+            var (
+                noneSink,
+                firstSink) = sinks.Split();
+
+            var noneSource = noneDriver(noneSink);
+            var firstSource = firstDriver(firstSink);
+
+            return ObservableUnion.Merge(
+                noneSource,
+                firstSource);
+        }
+
         public static IObservable<IUnion2<
             TFirstSource,
             TSecondSource>>
@@ -31,5 +71,411 @@ this IObservable<IUnion2<
                 firstSource,
                 secondSource);
         }
+
+        public static IObservable<IUnion3<
+            TFirstSource,
+            TSecondSource,
+            TThirdSource>>
+            CallDrivers<
+            TFirstSink,
+            TFirstSource,
+            TSecondSink,
+            TSecondSource,
+            TThirdSink,
+            TThirdSource>(
+            this IObservable<IUnion3<
+                TFirstSink,
+                TSecondSink,
+                TThirdSink>> sinks,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
+            Func<IObservable<TSecondSink>, IObservable<TSecondSource>> secondDriver,
+            Func<IObservable<TThirdSink>, IObservable<TThirdSource>> thirdDriver)
+        {
+            var (
+                firstSink,
+                secondSink,
+                thirdSink) = sinks.Split();
+
+            var firstSource = firstDriver(firstSink);
+            var secondSource = secondDriver(secondSink);
+            var thirdSource = thirdDriver(thirdSink);
+
+            return ObservableUnion.Merge(
+                firstSource,
+                secondSource,
+                thirdSource);
+        }
+
+        public static IObservable<IUnion4<
+            TFirstSource,
+            TSecondSource,
+            TThirdSource,
+            TFourthSource>>
+            CallDrivers<
+            TFirstSink,
+            TFirstSource,
+            TSecondSink,
+            TSecondSource,
+            TThirdSink,
+            TThirdSource,
+            TFourthSink,
+            TFourthSource>(
+            this IObservable<IUnion4<
+                TFirstSink,
+                TSecondSink,
+                TThirdSink,
+                TFourthSink>> sinks,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
+            Func<IObservable<TSecondSink>, IObservable<TSecondSource>> secondDriver,
+            Func<IObservable<TThirdSink>, IObservable<TThirdSource>> thirdDriver,
+            Func<IObservable<TFourthSink>, IObservable<TFourthSource>> fourthDriver)
+        {
+            var (
+                firstSink,
+                secondSink,
+                thirdSink,
+                fourthSink) = sinks.Split();
+
+            var firstSource = firstDriver(firstSink);
+            var secondSource = secondDriver(secondSink);
+            var thirdSource = thirdDriver(thirdSink);
+            var fourthSource = fourthDriver(fourthSink);
+
+            return ObservableUnion.Merge(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource);
+        }
+
+        public static IObservable<IUnion5<
+            TFirstSource,
+            TSecondSource,
+            TThirdSource,
+            TFourthSource,
+            TFifthSource>>
+            CallDrivers<
+            TFirstSink,
+            TFirstSource,
+            TSecondSink,
+            TSecondSource,
+            TThirdSink,
+            TThirdSource,
+            TFourthSink,
+            TFourthSource,
+            TFifthSink,
+            TFifthSource>(
+            this IObservable<IUnion5<
+                TFirstSink,
+                TSecondSink,
+                TThirdSink,
+                TFourthSink,
+                TFifthSink>> sinks,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
+            Func<IObservable<TSecondSink>, IObservable<TSecondSource>> secondDriver,
+            Func<IObservable<TThirdSink>, IObservable<TThirdSource>> thirdDriver,
+            Func<IObservable<TFourthSink>, IObservable<TFourthSource>> fourthDriver,
+            Func<IObservable<TFifthSink>, IObservable<TFifthSource>> fifthDriver)
+        {
+            var (
+                firstSink,
+                secondSink,
+                thirdSink,
+                fourthSink,
+                fifthSink) = sinks.Split();
+
+            var firstSource = firstDriver(firstSink);
+            var secondSource = secondDriver(secondSink);
+            var thirdSource = thirdDriver(thirdSink);
+            var fourthSource = fourthDriver(fourthSink);
+            var fifthSource = fifthDriver(fifthSink);
+
+            return ObservableUnion.Merge(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource);
+        }
+
+        public static IObservable<IUnion6<
+            TFirstSource,
+            TSecondSource,
+            TThirdSource,
+            TFourthSource,
+            TFifthSource,
+            TSixthSource>>
+            CallDrivers<
+            TFirstSink,
+            TFirstSource,
+            TSecondSink,
+            TSecondSource,
+            TThirdSink,
+            TThirdSource,
+            TFourthSink,
+            TFourthSource,
+            TFifthSink,
+            TFifthSource,
+            TSixthSink,
+            TSixthSource>(
+            this IObservable<IUnion6<
+                TFirstSink,
+                TSecondSink,
+                TThirdSink,
+                TFourthSink,
+                TFifthSink,
+                TSixthSink>> sinks,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
+            Func<IObservable<TSecondSink>, IObservable<TSecondSource>> secondDriver,
+            Func<IObservable<TThirdSink>, IObservable<TThirdSource>> thirdDriver,
+            Func<IObservable<TFourthSink>, IObservable<TFourthSource>> fourthDriver,
+            Func<IObservable<TFifthSink>, IObservable<TFifthSource>> fifthDriver,
+            Func<IObservable<TSixthSink>, IObservable<TSixthSource>> sixthDriver)
+        {
+            var (
+                firstSink,
+                secondSink,
+                thirdSink,
+                fourthSink,
+                fifthSink,
+                sixthSink) = sinks.Split();
+
+            var firstSource = firstDriver(firstSink);
+            var secondSource = secondDriver(secondSink);
+            var thirdSource = thirdDriver(thirdSink);
+            var fourthSource = fourthDriver(fourthSink);
+            var fifthSource = fifthDriver(fifthSink);
+            var sixthSource = sixthDriver(sixthSink);
+
+            return ObservableUnion.Merge(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource);
+        }
+
+        public static IObservable<IUnion7<
+            TFirstSource,
+            TSecondSource,
+            TThirdSource,
+            TFourthSource,
+            TFifthSource,
+            TSixthSource,
+            TSeventhSource>>
+            CallDrivers<
+            TFirstSink,
+            TFirstSource,
+            TSecondSink,
+            TSecondSource,
+            TThirdSink,
+            TThirdSource,
+            TFourthSink,
+            TFourthSource,
+            TFifthSink,
+            TFifthSource,
+            TSixthSink,
+            TSixthSource,
+            TSeventhSink,
+            TSeventhSource>(
+            this IObservable<IUnion7<
+                TFirstSink,
+                TSecondSink,
+                TThirdSink,
+                TFourthSink,
+                TFifthSink,
+                TSixthSink,
+                TSeventhSink>> sinks,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
+            Func<IObservable<TSecondSink>, IObservable<TSecondSource>> secondDriver,
+            Func<IObservable<TThirdSink>, IObservable<TThirdSource>> thirdDriver,
+            Func<IObservable<TFourthSink>, IObservable<TFourthSource>> fourthDriver,
+            Func<IObservable<TFifthSink>, IObservable<TFifthSource>> fifthDriver,
+            Func<IObservable<TSixthSink>, IObservable<TSixthSource>> sixthDriver,
+            Func<IObservable<TSeventhSink>, IObservable<TSeventhSource>> seventhDriver)
+        {
+            var (
+                firstSink,
+                secondSink,
+                thirdSink,
+                fourthSink,
+                fifthSink,
+                sixthSink,
+                seventhSink) = sinks.Split();
+
+            var firstSource = firstDriver(firstSink);
+            var secondSource = secondDriver(secondSink);
+            var thirdSource = thirdDriver(thirdSink);
+            var fourthSource = fourthDriver(fourthSink);
+            var fifthSource = fifthDriver(fifthSink);
+            var sixthSource = sixthDriver(sixthSink);
+            var seventhSource = seventhDriver(seventhSink);
+
+            return ObservableUnion.Merge(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
+                seventhSource);
+        }
+
+        public static IObservable<IUnion8<
+            TFirstSource,
+            TSecondSource,
+            TThirdSource,
+            TFourthSource,
+            TFifthSource,
+            TSixthSource,
+            TSeventhSource,
+            TEighthSource>>
+            CallDrivers<
+            TFirstSink,
+            TFirstSource,
+            TSecondSink,
+            TSecondSource,
+            TThirdSink,
+            TThirdSource,
+            TFourthSink,
+            TFourthSource,
+            TFifthSink,
+            TFifthSource,
+            TSixthSink,
+            TSixthSource,
+            TSeventhSink,
+            TSeventhSource,
+            TEighthSink,
+            TEighthSource>(
+            this IObservable<IUnion8<
+                TFirstSink,
+                TSecondSink,
+                TThirdSink,
+                TFourthSink,
+                TFifthSink,
+                TSixthSink,
+                TSeventhSink,
+                TEighthSink>> sinks,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
+            Func<IObservable<TSecondSink>, IObservable<TSecondSource>> secondDriver,
+            Func<IObservable<TThirdSink>, IObservable<TThirdSource>> thirdDriver,
+            Func<IObservable<TFourthSink>, IObservable<TFourthSource>> fourthDriver,
+            Func<IObservable<TFifthSink>, IObservable<TFifthSource>> fifthDriver,
+            Func<IObservable<TSixthSink>, IObservable<TSixthSource>> sixthDriver,
+            Func<IObservable<TSeventhSink>, IObservable<TSeventhSource>> seventhDriver,
+            Func<IObservable<TEighthSink>, IObservable<TEighthSource>> eighthDriver)
+        {
+            var (
+                firstSink,
+                secondSink,
+                thirdSink,
+                fourthSink,
+                fifthSink,
+                sixthSink,
+                seventhSink,
+                eighthSink) = sinks.Split();
+
+            var firstSource = firstDriver(firstSink);
+            var secondSource = secondDriver(secondSink);
+            var thirdSource = thirdDriver(thirdSink);
+            var fourthSource = fourthDriver(fourthSink);
+            var fifthSource = fifthDriver(fifthSink);
+            var sixthSource = sixthDriver(sixthSink);
+            var seventhSource = seventhDriver(seventhSink);
+            var eighthSource = eighthDriver(eighthSink);
+
+            return ObservableUnion.Merge(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
+                seventhSource,
+                eighthSource);
+        }
+
+        public static IObservable<IUnion9<
+            TFirstSource,
+            TSecondSource,
+            TThirdSource,
+            TFourthSource,
+            TFifthSource,
+            TSixthSource,
+            TSeventhSource,
+            TEighthSource,
+            TNinthSource>>
+            CallDrivers<
+            TFirstSink,
+            TFirstSource,
+            TSecondSink,
+            TSecondSource,
+            TThirdSink,
+            TThirdSource,
+            TFourthSink,
+            TFourthSource,
+            TFifthSink,
+            TFifthSource,
+            TSixthSink,
+            TSixthSource,
+            TSeventhSink,
+            TSeventhSource,
+            TEighthSink,
+            TEighthSource,
+            TNinthSink,
+            TNinthSource>(
+            this IObservable<IUnion9<
+                TFirstSink,
+                TSecondSink,
+                TThirdSink,
+                TFourthSink,
+                TFifthSink,
+                TSixthSink,
+                TSeventhSink,
+                TEighthSink,
+                TNinthSink>> sinks,
+            Func<IObservable<TFirstSink>, IObservable<TFirstSource>> firstDriver,
+            Func<IObservable<TSecondSink>, IObservable<TSecondSource>> secondDriver,
+            Func<IObservable<TThirdSink>, IObservable<TThirdSource>> thirdDriver,
+            Func<IObservable<TFourthSink>, IObservable<TFourthSource>> fourthDriver,
+            Func<IObservable<TFifthSink>, IObservable<TFifthSource>> fifthDriver,
+            Func<IObservable<TSixthSink>, IObservable<TSixthSource>> sixthDriver,
+            Func<IObservable<TSeventhSink>, IObservable<TSeventhSource>> seventhDriver,
+            Func<IObservable<TEighthSink>, IObservable<TEighthSource>> eighthDriver,
+            Func<IObservable<TNinthSink>, IObservable<TNinthSource>> ninthDriver)
+        {
+            var (
+                firstSink,
+                secondSink,
+                thirdSink,
+                fourthSink,
+                fifthSink,
+                sixthSink,
+                seventhSink,
+                eighthSink,
+                ninthSink) = sinks.Split();
+
+            var firstSource = firstDriver(firstSink);
+            var secondSource = secondDriver(secondSink);
+            var thirdSource = thirdDriver(thirdSink);
+            var fourthSource = fourthDriver(fourthSink);
+            var fifthSource = fifthDriver(fifthSink);
+            var sixthSource = sixthDriver(sixthSink);
+            var seventhSource = seventhDriver(seventhSink);
+            var eighthSource = eighthDriver(eighthSink);
+            var ninthSource = ninthDriver(ninthSink);
+
+            return ObservableUnion.Merge(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
+                seventhSource,
+                eighthSource,
+                ninthSource);
+        }
     }
 }
diff --git a/Cycle.NET/ObservableUnion.cs b/Cycle.NET/ObservableUnion.cs
index e6a3060..f2c9afd 100644
--- a/Cycle.NET/ObservableUnion.cs
+++ b/Cycle.NET/ObservableUnion.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Reactive;
 using System.Reactive.Linq;
 using SdgApps.Common.DotnetSealedUnions;
 using SdgApps.Common.DotnetSealedUnions.Generic;
@@ -7,11 +8,51 @@ namespace Cycle.NET
 {
     public static class ObservableUnion
     {
-        public static IObservable<IUnion2<TFirst, TSecond>> Merge<TFirst, TSecond>(
+        public static IObservable<IUnion0<
+            TFirst>>
+            Merge<
+            TFirst>(
+            IObservable<TFirst> firsts)
+        {
+            var fac = GenericUnions.NulletFactory<
+                TFirst>();
+
+            var unionFirsts = firsts.Select(fac.First);
+
+            return Observable.Merge(
+                unionFirsts);
+        }
+
+        public static IObservable<IUnion1<
+            TFirst>>
+            Merge<
+            TFirst>(
+            IObservable<Unit> nones,
+            IObservable<TFirst> firsts)
+        {
+            var fac = GenericUnions.SingletFactory<
+                TFirst>();
+
+            var unionNones = nones.Select(_ => fac.None());
+            var unionFirsts = firsts.Select(fac.First);
+
+            return Observable.Merge(
+                unionNones,
+                unionFirsts);
+        }
+
+        public static IObservable<IUnion2<
+            TFirst,
+            TSecond>>
+            Merge<
+            TFirst,
+            TSecond>(
             IObservable<TFirst> firsts,
             IObservable<TSecond> seconds)
         {
-            var fac = GenericUnions.DoubletFactory<TFirst, TSecond>();
+            var fac = GenericUnions.DoubletFactory<
+                TFirst,
+                TSecond>();
 
             var unionFirsts = firsts.Select(fac.First);
             var unionSeconds = seconds.Select(fac.Second);
@@ -20,5 +61,320 @@ public static IObservable<IUnion2<TFirst, TSecond>> Merge<TFirst, TSecond>(
                 unionFirsts,
                 unionSeconds);
         }
+
+        public static IObservable<IUnion3<
+            TFirst,
+            TSecond,
+            TThird>>
+            Merge<
+            TFirst,
+            TSecond,
+            TThird>(
+            IObservable<TFirst> firsts,
+            IObservable<TSecond> seconds,
+            IObservable<TThird> thirds)
+        {
+            var fac = GenericUnions.TripletFactory<
+                TFirst,
+                TSecond,
+                TThird>();
+
+            var unionFirsts = firsts.Select(fac.First);
+            var unionSeconds = seconds.Select(fac.Second);
+            var unionThirds = thirds.Select(fac.Third);
+
+            return Observable.Merge(
+                unionFirsts,
+                unionSeconds,
+                unionThirds);
+        }
+
+        public static IObservable<IUnion4<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth>>
+            Merge<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth>(
+            IObservable<TFirst> firsts,
+            IObservable<TSecond> seconds,
+            IObservable<TThird> thirds,
+            IObservable<TFourth> fourths)
+        {
+            var fac = GenericUnions.QuartetFactory<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth>();
+
+            var unionFirsts = firsts.Select(fac.First);
+            var unionSeconds = seconds.Select(fac.Second);
+            var unionThirds = thirds.Select(fac.Third);
+            var unionFourths = fourths.Select(fac.Fourth);
+
+            return Observable.Merge(
+                unionFirsts,
+                unionSeconds,
+                unionThirds,
+                unionFourths);
+        }
+
+        public static IObservable<IUnion5<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth>>
+            Merge<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth>(
+            IObservable<TFirst> firsts,
+            IObservable<TSecond> seconds,
+            IObservable<TThird> thirds,
+            IObservable<TFourth> fourths,
+            IObservable<TFifth> fifths)
+        {
+            var fac = GenericUnions.QuintetFactory<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth,
+                TFifth>();
+
+            var unionFirsts = firsts.Select(fac.First);
+            var unionSeconds = seconds.Select(fac.Second);
+            var unionThirds = thirds.Select(fac.Third);
+            var unionFourths = fourths.Select(fac.Fourth);
+            var unionFifths = fifths.Select(fac.Fifth);
+
+            return Observable.Merge(
+                unionFirsts,
+                unionSeconds,
+                unionThirds,
+                unionFourths,
+                unionFifths);
+        }
+
+        public static IObservable<IUnion6<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth>>
+            Merge<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth>(
+            IObservable<TFirst> firsts,
+            IObservable<TSecond> seconds,
+            IObservable<TThird> thirds,
+            IObservable<TFourth> fourths,
+            IObservable<TFifth> fifths,
+            IObservable<TSixth> sixths)
+        {
+            var fac = GenericUnions.SextetFactory<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth,
+                TFifth,
+                TSixth>();
+
+            var unionFirsts = firsts.Select(fac.First);
+            var unionSeconds = seconds.Select(fac.Second);
+            var unionThirds = thirds.Select(fac.Third);
+            var unionFourths = fourths.Select(fac.Fourth);
+            var unionFifths = fifths.Select(fac.Fifth);
+            var unionSixths = sixths.Select(fac.Sixth);
+
+            return Observable.Merge(
+                unionFirsts,
+                unionSeconds,
+                unionThirds,
+                unionFourths,
+                unionFifths,
+                unionSixths);
+        }
+
+        public static IObservable<IUnion7<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth,
+            TSeventh>>
+            Merge<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth,
+            TSeventh>(
+            IObservable<TFirst> firsts,
+            IObservable<TSecond> seconds,
+            IObservable<TThird> thirds,
+            IObservable<TFourth> fourths,
+            IObservable<TFifth> fifths,
+            IObservable<TSixth> sixths,
+            IObservable<TSeventh> sevenths)
+        {
+            var fac = GenericUnions.SeptetFactory<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth,
+                TFifth,
+                TSixth,
+                TSeventh>();
+
+            var unionFirsts = firsts.Select(fac.First);
+            var unionSeconds = seconds.Select(fac.Second);
+            var unionThirds = thirds.Select(fac.Third);
+            var unionFourths = fourths.Select(fac.Fourth);
+            var unionFifths = fifths.Select(fac.Fifth);
+            var unionSixths = sixths.Select(fac.Sixth);
+            var unionSevenths = sevenths.Select(fac.Seventh);
+
+            return Observable.Merge(
+                unionFirsts,
+                unionSeconds,
+                unionThirds,
+                unionFourths,
+                unionFifths,
+                unionSixths,
+                unionSevenths);
+        }
+
+        public static IObservable<IUnion8<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth,
+            TSeventh,
+            TEighth>>
+            Merge<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth,
+            TSeventh,
+            TEighth>(
+            IObservable<TFirst> firsts,
+            IObservable<TSecond> seconds,
+            IObservable<TThird> thirds,
+            IObservable<TFourth> fourths,
+            IObservable<TFifth> fifths,
+            IObservable<TSixth> sixths,
+            IObservable<TSeventh> sevenths,
+            IObservable<TEighth> eighths)
+        {
+            var fac = GenericUnions.OctetFactory<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth,
+                TFifth,
+                TSixth,
+                TSeventh,
+                TEighth>();
+
+            var unionFirsts = firsts.Select(fac.First);
+            var unionSeconds = seconds.Select(fac.Second);
+            var unionThirds = thirds.Select(fac.Third);
+            var unionFourths = fourths.Select(fac.Fourth);
+            var unionFifths = fifths.Select(fac.Fifth);
+            var unionSixths = sixths.Select(fac.Sixth);
+            var unionSevenths = sevenths.Select(fac.Seventh);
+            var unionEighths = eighths.Select(fac.Eighth);
+
+            return Observable.Merge(
+                unionFirsts,
+                unionSeconds,
+                unionThirds,
+                unionFourths,
+                unionFifths,
+                unionSixths,
+                unionSevenths,
+                unionEighths);
+        }
+
+        public static IObservable<IUnion9<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth,
+            TSeventh,
+            TEighth,
+            TNinth>>
+            Merge<
+            TFirst,
+            TSecond,
+            TThird,
+            TFourth,
+            TFifth,
+            TSixth,
+            TSeventh,
+            TEighth,
+            TNinth>(
+            IObservable<TFirst> firsts,
+            IObservable<TSecond> seconds,
+            IObservable<TThird> thirds,
+            IObservable<TFourth> fourths,
+            IObservable<TFifth> fifths,
+            IObservable<TSixth> sixths,
+            IObservable<TSeventh> sevenths,
+            IObservable<TEighth> eighths,
+            IObservable<TNinth> ninths)
+        {
+            var fac = GenericUnions.NonetFactory<
+                TFirst,
+                TSecond,
+                TThird,
+                TFourth,
+                TFifth,
+                TSixth,
+                TSeventh,
+                TEighth,
+                TNinth>();
+
+            var unionFirsts = firsts.Select(fac.First);
+            var unionSeconds = seconds.Select(fac.Second);
+            var unionThirds = thirds.Select(fac.Third);
+            var unionFourths = fourths.Select(fac.Fourth);
+            var unionFifths = fifths.Select(fac.Fifth);
+            var unionSixths = sixths.Select(fac.Sixth);
+            var unionSevenths = sevenths.Select(fac.Seventh);
+            var unionEighths = eighths.Select(fac.Eighth);
+            var unionNinths = ninths.Select(fac.Ninth);
+
+            return Observable.Merge(
+                unionFirsts,
+                unionSeconds,
+                unionThirds,
+                unionFourths,
+                unionFifths,
+                unionSixths,
+                unionSevenths,
+                unionEighths,
+                unionNinths);
+        }
     }
 }

From f93ea4152e941126aa4f27f04655b61022ead489 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Tue, 4 Apr 2023 22:12:32 -0400
Subject: [PATCH 21/42] Improve typing

---
 Cycle.NET.Demo/Program.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 4a3e6e5..4f9b3ea 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -35,9 +35,9 @@ private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int,
         }
         static void Main(string[] args)
         {
-            Runner.Run<IUnion2<int, int>, IUnion2<int, int>>(
+            Runner.Run(
                 CycleMain,
-                sinks => sinks.CallDrivers(
+                (IObservable<IUnion2<int, int>> sinks) => sinks.CallDrivers(
                     LogDriver,
                     KeyInputDriver));
             Console.ReadLine();

From c84094b80a996def5ab3fe2890bcb7ed9d9c19e2 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Thu, 20 Apr 2023 20:53:39 -0400
Subject: [PATCH 22/42] Revert "Collapse down to one runner"

This reverts commit 996d75e5471aa2460e4428cb99737b5cb9612972.
---
 Cycle.NET.Demo/Program.cs |  2 +-
 Cycle.NET/Runner.cs       | 29 +++++++++---
 Cycle.NET/Runner1.cs      | 26 +++++++++++
 Cycle.NET/Runner3.cs      | 97 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 146 insertions(+), 8 deletions(-)
 create mode 100644 Cycle.NET/Runner1.cs
 create mode 100644 Cycle.NET/Runner3.cs

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 4f9b3ea..bd4c984 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -35,7 +35,7 @@ private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int,
         }
         static void Main(string[] args)
         {
-            Runner.Run(
+            Runner<IUnion2<int, int>, IUnion2<int, int>>.Run(
                 CycleMain,
                 (IObservable<IUnion2<int, int>> sinks) => sinks.CallDrivers(
                     LogDriver,
diff --git a/Cycle.NET/Runner.cs b/Cycle.NET/Runner.cs
index 2d6b1e9..07b668c 100644
--- a/Cycle.NET/Runner.cs
+++ b/Cycle.NET/Runner.cs
@@ -1,26 +1,41 @@
 using System;
+using System.Collections.Generic;
+using System.Reactive;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
+using System.Linq;
 
 namespace Cycle.NET
 {
+    public class Streams : Dictionary<string, IObservable<object>>
+    {
+        public Streams() : base() { }
+        public Streams(Dictionary<string, IObservable<object>> value) : base(value) { }
+    }
+
+    public class Drivers : Dictionary<string, Func<IObservable<object>, IObservable<object>>>
+    {
+        public Drivers() : base() { }
+    }
+
     public static class Runner
     {
-        public static void Run<TSources, TSinks>(
-            Func<IObservable<TSources>, IObservable<TSinks>> main,
-            Func<IObservable<TSinks>, IObservable<TSources>> drivers)
+        public static void Run(Func<Streams, Streams> main, Drivers drivers)
         {
             // Create fake sinks to use to call the drivers to get around the interdependency between
             // main and the drivers.
-            var fakeSinks = new ReplaySubject<TSinks>();
+            var fakeSinks = drivers.ToDictionary(d => d.Key, d => new ReplaySubject<object>());
 
             // Call the drivers and collate the returned sources.
-            var sources = drivers(fakeSinks);
+            var sources = drivers.ToDictionary(d => d.Key, d => d.Value(fakeSinks[d.Key]));
 
-            var sinks = main(sources);
+            Streams sinks = main(new Streams(sources));
 
             // Update the sinks returned from main with the sinks used by the drivers.
-            sinks.Subscribe(fakeSinks.OnNext);
+            foreach (var sink in sinks)
+            {
+                sink.Value.Subscribe(s => fakeSinks[sink.Key].OnNext(s));
+            }
         }
     }
 }
diff --git a/Cycle.NET/Runner1.cs b/Cycle.NET/Runner1.cs
new file mode 100644
index 0000000..78a28b5
--- /dev/null
+++ b/Cycle.NET/Runner1.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace Cycle.NET
+{
+    public static class Runner<TSources, TSinks>
+    {
+        public static void Run(
+            Func<IObservable<TSources>, IObservable<TSinks>> main,
+            Func<IObservable<TSinks>, IObservable<TSources>> drivers)
+        {
+            // Create fake sinks to use to call the drivers to get around the interdependency between
+            // main and the drivers.
+            var fakeSinks = new ReplaySubject<TSinks>();
+
+            // Call the drivers and collate the returned sources.
+            var sources = drivers(fakeSinks);
+
+            var sinks = main(sources);
+
+            // Update the sinks returned from main with the sinks used by the drivers.
+            sinks.Subscribe(fakeSinks.OnNext);
+        }
+    }
+}
diff --git a/Cycle.NET/Runner3.cs b/Cycle.NET/Runner3.cs
new file mode 100644
index 0000000..585d973
--- /dev/null
+++ b/Cycle.NET/Runner3.cs
@@ -0,0 +1,97 @@
+using System;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace Cycle.NET
+{
+    public class Streams<T1, T2, T3>
+    {
+        public Streams(
+            IObservable<T1> first,
+            IObservable<T2> second,
+            IObservable<T3> third)
+        {
+            First = first;
+            Second = second;
+            Third = third;
+        }
+
+        public IObservable<T1> First { get; }
+        public IObservable<T2> Second { get; }
+        public IObservable<T3> Third { get; }
+    }
+
+    public class Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
+    {
+        public Component(
+            Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> main)
+        {
+            Main = main;
+        }
+
+        public Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> Main { get; }
+    }
+
+    public class Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
+    {
+        public Drivers(
+            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
+            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond,
+            Func<IObservable<TSink3>, IObservable<TSource3>> onThird)
+        {
+            OnFirst = onFirst;
+            OnSecond = onSecond;
+            OnThird = onThird;
+        }
+
+        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
+        public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
+        public Func<IObservable<TSink3>, IObservable<TSource3>> OnThird { get; }
+    }
+
+    public static class Runner<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
+    {
+        public static void Run(
+            Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> component,
+            Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> drivers)
+        {
+            // Create fake sinks to use to call the drivers to get around the interdependency between
+            // main and the drivers.
+            var fakeSinks = new FakeSinks<TSink1, TSink2, TSink3>(
+                new ReplaySubject<TSink1>(),
+                new ReplaySubject<TSink2>(),
+                new ReplaySubject<TSink3>());
+
+            // Call the drivers and collate the returned sources.
+            var sources = new Streams<TSource1, TSource2, TSource3>(
+                drivers.OnFirst(fakeSinks.First),
+                drivers.OnSecond(fakeSinks.Second),
+                drivers.OnThird(fakeSinks.Third));
+
+            Streams<TSink1, TSink2, TSink3> sinks = component.Main(sources);
+
+            // Update the sinks returned from main with the sinks used by the drivers.
+            sinks.First.Subscribe(fakeSinks.First.OnNext);
+            sinks.Second.Subscribe(fakeSinks.Second.OnNext);
+            sinks.Third.Subscribe(fakeSinks.Third.OnNext);
+        }
+
+        private class FakeSinks<T1, T2, T3>
+        {
+            public FakeSinks(
+                ISubject<T1> first,
+                ISubject<T2> second,
+                ISubject<T3> third)
+            {
+                First = first;
+                Second = second;
+                Third = third;
+            }
+
+            public ISubject<T1> First { get; }
+            public ISubject<T2> Second { get; }
+            public ISubject<T3> Third { get; }
+        }
+
+    }
+}

From 88125fa5b51c68581d23637e3ab9222a45d541b4 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Thu, 20 Apr 2023 20:39:21 -0400
Subject: [PATCH 23/42] Rename kernel

---
 Cycle.NET.Demo/Program.cs           | 2 +-
 Cycle.NET/{Runner1.cs => Kernel.cs} | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename Cycle.NET/{Runner1.cs => Kernel.cs} (94%)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index bd4c984..fd0f106 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -35,7 +35,7 @@ private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int,
         }
         static void Main(string[] args)
         {
-            Runner<IUnion2<int, int>, IUnion2<int, int>>.Run(
+            Kernel<IUnion2<int, int>, IUnion2<int, int>>.Run(
                 CycleMain,
                 (IObservable<IUnion2<int, int>> sinks) => sinks.CallDrivers(
                     LogDriver,
diff --git a/Cycle.NET/Runner1.cs b/Cycle.NET/Kernel.cs
similarity index 94%
rename from Cycle.NET/Runner1.cs
rename to Cycle.NET/Kernel.cs
index 78a28b5..eebab10 100644
--- a/Cycle.NET/Runner1.cs
+++ b/Cycle.NET/Kernel.cs
@@ -4,7 +4,7 @@
 
 namespace Cycle.NET
 {
-    public static class Runner<TSources, TSinks>
+    public static class Kernel<TSources, TSinks>
     {
         public static void Run(
             Func<IObservable<TSources>, IObservable<TSinks>> main,

From 8a58d91537036d798dc8ea1249a05fcc0360e0ed Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Thu, 20 Apr 2023 20:58:49 -0400
Subject: [PATCH 24/42] Improve typing again

---
 Cycle.NET.Demo/Program.cs | 2 +-
 Cycle.NET/Kernel.cs       | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index fd0f106..3865c70 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -35,7 +35,7 @@ private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int,
         }
         static void Main(string[] args)
         {
-            Kernel<IUnion2<int, int>, IUnion2<int, int>>.Run(
+            Kernel.Run(
                 CycleMain,
                 (IObservable<IUnion2<int, int>> sinks) => sinks.CallDrivers(
                     LogDriver,
diff --git a/Cycle.NET/Kernel.cs b/Cycle.NET/Kernel.cs
index eebab10..b836d3d 100644
--- a/Cycle.NET/Kernel.cs
+++ b/Cycle.NET/Kernel.cs
@@ -4,9 +4,9 @@
 
 namespace Cycle.NET
 {
-    public static class Kernel<TSources, TSinks>
+    public static class Kernel
     {
-        public static void Run(
+        public static void Run<TSources, TSinks>(
             Func<IObservable<TSources>, IObservable<TSinks>> main,
             Func<IObservable<TSinks>, IObservable<TSources>> drivers)
         {

From 3ddb3d08d262c400277ce651cbc931f75faa530d Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Fri, 21 Apr 2023 16:00:04 -0400
Subject: [PATCH 25/42] Add object split/merge

---
 Cycle.NET/Extensions/ObservableUnionExtensions.cs | 14 ++++++++++++++
 Cycle.NET/ObservableUnion.cs                      | 10 ++++++++++
 2 files changed, 24 insertions(+)

diff --git a/Cycle.NET/Extensions/ObservableUnionExtensions.cs b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
index 36461e1..e0c9e00 100644
--- a/Cycle.NET/Extensions/ObservableUnionExtensions.cs
+++ b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Reactive;
 using System.Reactive.Linq;
 using SdgApps.Common.DotnetSealedUnions;
@@ -7,6 +9,18 @@ namespace Cycle.NET.Extensions
 {
     public static class ObservableUnionExtensions
     {
+        public static
+            IDictionary<string, IObservable<object>>
+            Split(
+            this IObservable<KeyValuePair<string, object>> source,
+            IEnumerable<string> keys) =>
+            keys
+            .Select(k => new KeyValuePair<string, IObservable<object>>(k, source
+            .Where(p => p.Key == k)
+            .Select(p => Observable
+            .Return(p.Value))))
+            .ToDictionary(p => p.Key, p => p.Value);
+
         public static
             IObservable<TFirst>
             Split<
diff --git a/Cycle.NET/ObservableUnion.cs b/Cycle.NET/ObservableUnion.cs
index f2c9afd..a74198d 100644
--- a/Cycle.NET/ObservableUnion.cs
+++ b/Cycle.NET/ObservableUnion.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Reactive;
 using System.Reactive.Linq;
 using SdgApps.Common.DotnetSealedUnions;
@@ -8,6 +10,14 @@ namespace Cycle.NET
 {
     public static class ObservableUnion
     {
+        public static IObservable<KeyValuePair<string, object>>
+            Merge(
+            IDictionary<string, IObservable<object>> streams) =>
+            Observable
+            .Merge(streams
+            .Select(p => p.Value
+            .Select(v => new KeyValuePair<string, object>(p.Key, v))));
+
         public static IObservable<IUnion0<
             TFirst>>
             Merge<

From a3093204b00d2d158410c19d814db33887261f0f Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Fri, 21 Apr 2023 16:27:54 -0400
Subject: [PATCH 26/42] Implement runner with kernel

---
 Cycle.NET/Extensions/RunnerExtensions.cs | 16 ++++++++++++
 Cycle.NET/Runner.cs                      | 32 +++++++++++++++---------
 2 files changed, 36 insertions(+), 12 deletions(-)

diff --git a/Cycle.NET/Extensions/RunnerExtensions.cs b/Cycle.NET/Extensions/RunnerExtensions.cs
index f96a4c2..385aabe 100644
--- a/Cycle.NET/Extensions/RunnerExtensions.cs
+++ b/Cycle.NET/Extensions/RunnerExtensions.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Reactive;
 using Cycle.NET.Extensions;
 using SdgApps.Common.DotnetSealedUnions;
@@ -7,6 +9,20 @@ namespace Cycle.NET
 {
     public static class RunnerExtensions
     {
+        public static IObservable<KeyValuePair<string, object>>
+            CallDrivers(
+            this IObservable<KeyValuePair<string, object>> sinks,
+            IDictionary<string, Func<IObservable<object>, IObservable<object>>> drivers)
+        {
+            var splitSinks = sinks.Split(drivers.Keys);
+
+            var splitSources = splitSinks
+                .ToDictionary(p => p.Key, p => drivers[p.Key](p.Value));
+
+            return ObservableUnion.Merge(
+                splitSources);
+        }
+
         public static IObservable<IUnion0<
             TFirstSource>>
             CallDrivers<
diff --git a/Cycle.NET/Runner.cs b/Cycle.NET/Runner.cs
index 07b668c..fbfd765 100644
--- a/Cycle.NET/Runner.cs
+++ b/Cycle.NET/Runner.cs
@@ -4,6 +4,7 @@
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using System.Linq;
+using Cycle.NET.Extensions;
 
 namespace Cycle.NET
 {
@@ -20,22 +21,29 @@ public Drivers() : base() { }
 
     public static class Runner
     {
-        public static void Run(Func<Streams, Streams> main, Drivers drivers)
+        private static IObservable<KeyValuePair<string, object>> CycleMain(
+            IObservable<KeyValuePair<string, object>> sources,
+            IEnumerable<string> keys,
+            Func<Streams, Streams> main)
         {
-            // Create fake sinks to use to call the drivers to get around the interdependency between
-            // main and the drivers.
-            var fakeSinks = drivers.ToDictionary(d => d.Key, d => new ReplaySubject<object>());
+            var sourceStreams = new Streams(sources
+                .Split(keys)
+                .ToDictionary(p => p.Key, p => p.Value));
 
-            // Call the drivers and collate the returned sources.
-            var sources = drivers.ToDictionary(d => d.Key, d => d.Value(fakeSinks[d.Key]));
+            var sinkStreams = main(sourceStreams);
 
-            Streams sinks = main(new Streams(sources));
+            return ObservableUnion
+                .Merge(sinkStreams);
+        }
 
-            // Update the sinks returned from main with the sinks used by the drivers.
-            foreach (var sink in sinks)
-            {
-                sink.Value.Subscribe(s => fakeSinks[sink.Key].OnNext(s));
-            }
+        public static void Run(Func<Streams, Streams> main, Drivers drivers)
+        {
+            Kernel.Run(
+                sources => CycleMain(
+                    sources,
+                    drivers.Keys,
+                    main),
+                (IObservable<KeyValuePair<string, object>> sinks) => sinks.CallDrivers(drivers));
         }
     }
 }

From 55c176db088e0c37562039a8caf46bfb7955c9ec Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Fri, 21 Apr 2023 21:20:31 -0400
Subject: [PATCH 27/42] Test old and new demos alongside

---
 Cycle.NET.Demo/Program.cs                     | 34 +++++++++++++++++--
 .../Extensions/ObservableUnionExtensions.cs   |  3 +-
 2 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 3865c70..5bca168 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -1,14 +1,20 @@
 using System;
-using System.Reactive;
+using System.Collections.Generic;
 using System.Reactive.Linq;
 using Cycle.NET.Extensions;
 using SdgApps.Common.DotnetSealedUnions;
-using SdgApps.Common.DotnetSealedUnions.Generic;
 
 namespace Cycle.NET.Demo
 {
     class Program
     {
+        private static IObservable<object> LogDriver(IObservable<object> sinks)
+        {
+            sinks.Cast<int>().Subscribe(i => Console.WriteLine("Log " + i.ToString()));
+
+            return Observable.Empty<object>();
+        }
+
         private static IObservable<int> LogDriver(IObservable<int> sinks)
         {
             sinks.Subscribe(i => Console.WriteLine("Log " + i.ToString()));
@@ -16,11 +22,26 @@ private static IObservable<int> LogDriver(IObservable<int> sinks)
             return Observable.Empty<int>();
         }
 
+        private static IObservable<object> KeyInputDriver(IObservable<object> sinks)
+        {
+            return Observable.Range(20, 5).Select(i => (object)i);
+        }
+
         private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
         {
             return Observable.Range(20, 5);
         }
 
+        private static Streams CycleMain(Streams sources)
+        {
+            var sinks = new Streams
+            {
+                { "log", sources["keys"] }
+            };
+
+            return sinks;
+        }
+
         private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int, int>> sources)
         {
             var (
@@ -33,13 +54,22 @@ private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int,
                 logSink,
                 Observable.Empty<int>());
         }
+
         static void Main(string[] args)
         {
+            var drivers = new Drivers
+            {
+                { "log", LogDriver },
+                { "keys", KeyInputDriver }
+            };
+            Runner.Run(CycleMain, drivers);
+
             Kernel.Run(
                 CycleMain,
                 (IObservable<IUnion2<int, int>> sinks) => sinks.CallDrivers(
                     LogDriver,
                     KeyInputDriver));
+
             Console.ReadLine();
         }
     }
diff --git a/Cycle.NET/Extensions/ObservableUnionExtensions.cs b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
index e0c9e00..44f4c84 100644
--- a/Cycle.NET/Extensions/ObservableUnionExtensions.cs
+++ b/Cycle.NET/Extensions/ObservableUnionExtensions.cs
@@ -17,8 +17,7 @@ public static
             keys
             .Select(k => new KeyValuePair<string, IObservable<object>>(k, source
             .Where(p => p.Key == k)
-            .Select(p => Observable
-            .Return(p.Value))))
+            .Select(p => p.Value)))
             .ToDictionary(p => p.Key, p => p.Value);
 
         public static

From d9872f1b0f24a628d8fbec4f43cb701fc3ccdf47 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Fri, 21 Apr 2023 21:28:26 -0400
Subject: [PATCH 28/42] Create runner2 from 3

---
 Cycle.NET/Runner2.cs | 85 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 Cycle.NET/Runner2.cs

diff --git a/Cycle.NET/Runner2.cs b/Cycle.NET/Runner2.cs
new file mode 100644
index 0000000..8ac5411
--- /dev/null
+++ b/Cycle.NET/Runner2.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace Cycle.NET
+{
+    public class Streams<T1, T2>
+    {
+        public Streams(
+            IObservable<T1> first,
+            IObservable<T2> second)
+        {
+            First = first;
+            Second = second;
+        }
+
+        public IObservable<T1> First { get; }
+        public IObservable<T2> Second { get; }
+    }
+
+    public class Component<TSource1, TSink1, TSource2, TSink2>
+    {
+        public Component(
+            Func<Streams<TSource1, TSource2>, Streams<TSink1, TSink2>> main)
+        {
+            Main = main;
+        }
+
+        public Func<Streams<TSource1, TSource2>, Streams<TSink1, TSink2>> Main { get; }
+    }
+
+    public class Drivers<TSource1, TSink1, TSource2, TSink2>
+    {
+        public Drivers(
+            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
+            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond)
+        {
+            OnFirst = onFirst;
+            OnSecond = onSecond;
+        }
+
+        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
+        public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
+    }
+
+    public static class Runner<TSource1, TSink1, TSource2, TSink2>
+    {
+        public static void Run(
+            Component<TSource1, TSink1, TSource2, TSink2> component,
+            Drivers<TSource1, TSink1, TSource2, TSink2> drivers)
+        {
+            // Create fake sinks to use to call the drivers to get around the interdependency between
+            // main and the drivers.
+            var fakeSinks = new FakeSinks<TSink1, TSink2>(
+                new ReplaySubject<TSink1>(),
+                new ReplaySubject<TSink2>());
+
+            // Call the drivers and collate the returned sources.
+            var sources = new Streams<TSource1, TSource2>(
+                drivers.OnFirst(fakeSinks.First),
+                drivers.OnSecond(fakeSinks.Second));
+
+            Streams<TSink1, TSink2> sinks = component.Main(sources);
+
+            // Update the sinks returned from main with the sinks used by the drivers.
+            sinks.First.Subscribe(fakeSinks.First.OnNext);
+            sinks.Second.Subscribe(fakeSinks.Second.OnNext);
+        }
+
+        private class FakeSinks<T1, T2>
+        {
+            public FakeSinks(
+                ISubject<T1> first,
+                ISubject<T2> second)
+            {
+                First = first;
+                Second = second;
+            }
+
+            public ISubject<T1> First { get; }
+            public ISubject<T2> Second { get; }
+        }
+
+    }
+}

From 146c78a806ebe5f347b9dc4a8253decdf6e455a0 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Fri, 21 Apr 2023 21:46:20 -0400
Subject: [PATCH 29/42] Implement runner2 with kernel

---
 Cycle.NET/Runner2.cs | 55 ++++++++++++++++++++++++++++++--------------
 1 file changed, 38 insertions(+), 17 deletions(-)

diff --git a/Cycle.NET/Runner2.cs b/Cycle.NET/Runner2.cs
index 8ac5411..2f517f2 100644
--- a/Cycle.NET/Runner2.cs
+++ b/Cycle.NET/Runner2.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
+using Cycle.NET.Extensions;
+using SdgApps.Common.DotnetSealedUnions;
 
 namespace Cycle.NET
 {
@@ -43,28 +45,47 @@ public Drivers(
         public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
     }
 
-    public static class Runner<TSource1, TSink1, TSource2, TSink2>
+    public static class Runner<
+        TSource1,
+        TSink1,
+        TSource2,
+        TSink2>
     {
-        public static void Run(
-            Component<TSource1, TSink1, TSource2, TSink2> component,
-            Drivers<TSource1, TSink1, TSource2, TSink2> drivers)
+        private static IObservable<IUnion2<
+            TSink1,
+            TSink2>>
+            CycleMain(
+            IObservable<IUnion2<
+                TSource1,
+                TSource2>> sources,
+            Func<
+                Streams<
+                    TSource1,
+                    TSource2>,
+                Streams<
+                    TSink1,
+                    TSink2>> main)
         {
-            // Create fake sinks to use to call the drivers to get around the interdependency between
-            // main and the drivers.
-            var fakeSinks = new FakeSinks<TSink1, TSink2>(
-                new ReplaySubject<TSink1>(),
-                new ReplaySubject<TSink2>());
+            var sourceStreams = sources.Split();
 
-            // Call the drivers and collate the returned sources.
-            var sources = new Streams<TSource1, TSource2>(
-                drivers.OnFirst(fakeSinks.First),
-                drivers.OnSecond(fakeSinks.Second));
+            var sinkStreams = main(new Streams<TSource1, TSource2>(
+                sourceStreams.Firsts,
+                sourceStreams.Seconds));
 
-            Streams<TSink1, TSink2> sinks = component.Main(sources);
+            return ObservableUnion.Merge(
+                sinkStreams.First,
+                sinkStreams.Second);
+        }
 
-            // Update the sinks returned from main with the sinks used by the drivers.
-            sinks.First.Subscribe(fakeSinks.First.OnNext);
-            sinks.Second.Subscribe(fakeSinks.Second.OnNext);
+        public static void Run(
+            Component<TSource1, TSink1, TSource2, TSink2> component,
+            Drivers<TSource1, TSink1, TSource2, TSink2> drivers)
+        {
+            Kernel.Run(
+                sources => CycleMain(sources, component.Main),
+                (IObservable<IUnion2<TSink1, TSink2>> sinks) => sinks.CallDrivers(
+                    drivers.OnFirst,
+                    drivers.OnSecond));
         }
 
         private class FakeSinks<T1, T2>

From 639b318142a6f85f486fcf9506565e8bfa1effc4 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Fri, 21 Apr 2023 21:57:21 -0400
Subject: [PATCH 30/42] Remove redundant types

---
 Cycle.NET/Runner2.cs | 89 ++++++++++----------------------------------
 1 file changed, 20 insertions(+), 69 deletions(-)

diff --git a/Cycle.NET/Runner2.cs b/Cycle.NET/Runner2.cs
index 2f517f2..487732b 100644
--- a/Cycle.NET/Runner2.cs
+++ b/Cycle.NET/Runner2.cs
@@ -6,45 +6,6 @@
 
 namespace Cycle.NET
 {
-    public class Streams<T1, T2>
-    {
-        public Streams(
-            IObservable<T1> first,
-            IObservable<T2> second)
-        {
-            First = first;
-            Second = second;
-        }
-
-        public IObservable<T1> First { get; }
-        public IObservable<T2> Second { get; }
-    }
-
-    public class Component<TSource1, TSink1, TSource2, TSink2>
-    {
-        public Component(
-            Func<Streams<TSource1, TSource2>, Streams<TSink1, TSink2>> main)
-        {
-            Main = main;
-        }
-
-        public Func<Streams<TSource1, TSource2>, Streams<TSink1, TSink2>> Main { get; }
-    }
-
-    public class Drivers<TSource1, TSink1, TSource2, TSink2>
-    {
-        public Drivers(
-            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
-            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond)
-        {
-            OnFirst = onFirst;
-            OnSecond = onSecond;
-        }
-
-        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
-        public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
-    }
-
     public static class Runner<
         TSource1,
         TSink1,
@@ -59,48 +20,38 @@ private static IObservable<IUnion2<
                 TSource1,
                 TSource2>> sources,
             Func<
-                Streams<
-                    TSource1,
-                    TSource2>,
-                Streams<
-                    TSink1,
-                    TSink2>> main)
+                IObservable<TSource1>,
+                IObservable<TSource2>,
+                (
+                    IObservable<TSink1>,
+                    IObservable<TSink2>)> main)
         {
             var sourceStreams = sources.Split();
 
-            var sinkStreams = main(new Streams<TSource1, TSource2>(
+            var sinkStreams = main(
                 sourceStreams.Firsts,
-                sourceStreams.Seconds));
+                sourceStreams.Seconds);
 
             return ObservableUnion.Merge(
-                sinkStreams.First,
-                sinkStreams.Second);
+                sinkStreams.Item1,
+                sinkStreams.Item2);
         }
 
         public static void Run(
-            Component<TSource1, TSink1, TSource2, TSink2> component,
-            Drivers<TSource1, TSink1, TSource2, TSink2> drivers)
+            Func<
+                IObservable<TSource1>,
+                IObservable<TSource2>,
+                (
+                    IObservable<TSink1>,
+                    IObservable<TSink2>)> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
+            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond)
         {
             Kernel.Run(
-                sources => CycleMain(sources, component.Main),
+                sources => CycleMain(sources, main),
                 (IObservable<IUnion2<TSink1, TSink2>> sinks) => sinks.CallDrivers(
-                    drivers.OnFirst,
-                    drivers.OnSecond));
+                    onFirst,
+                    onSecond));
         }
-
-        private class FakeSinks<T1, T2>
-        {
-            public FakeSinks(
-                ISubject<T1> first,
-                ISubject<T2> second)
-            {
-                First = first;
-                Second = second;
-            }
-
-            public ISubject<T1> First { get; }
-            public ISubject<T2> Second { get; }
-        }
-
     }
 }

From 8430fdec1484037d7824d5a9f57947ebdabf0f60 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Fri, 21 Apr 2023 22:01:22 -0400
Subject: [PATCH 31/42] Use runner2

---
 Cycle.NET.Demo/Program.cs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 5bca168..4c418f2 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -42,15 +42,16 @@ private static Streams CycleMain(Streams sources)
             return sinks;
         }
 
-        private static IObservable<IUnion2<int, int>> CycleMain(IObservable<IUnion2<int, int>> sources)
+        private static (
+            IObservable<int> LogSinks,
+            IObservable<int> KeyInputSinks)
+            CycleMain(
+            IObservable<int> logSources,
+            IObservable<int> keyInputSources)
         {
-            var (
-                _,
-                keyInputSources) = sources.Split();
-
             var logSink = keyInputSources;
 
-            return ObservableUnion.Merge(
+            return (
                 logSink,
                 Observable.Empty<int>());
         }
@@ -64,11 +65,10 @@ static void Main(string[] args)
             };
             Runner.Run(CycleMain, drivers);
 
-            Kernel.Run(
+            Runner<int, int, int, int>.Run(
                 CycleMain,
-                (IObservable<IUnion2<int, int>> sinks) => sinks.CallDrivers(
-                    LogDriver,
-                    KeyInputDriver));
+                LogDriver,
+                KeyInputDriver);
 
             Console.ReadLine();
         }

From 79eeacca332906bfa9deaa6818b8b3961a5a52e3 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Sat, 22 Apr 2023 14:06:22 -0400
Subject: [PATCH 32/42] Clean up runner2

---
 Cycle.NET/Runner2.cs | 60 ++++++++++++++++++--------------------------
 1 file changed, 25 insertions(+), 35 deletions(-)

diff --git a/Cycle.NET/Runner2.cs b/Cycle.NET/Runner2.cs
index 487732b..dd28f9a 100644
--- a/Cycle.NET/Runner2.cs
+++ b/Cycle.NET/Runner2.cs
@@ -12,46 +12,36 @@ public static class Runner<
         TSource2,
         TSink2>
     {
-        private static IObservable<IUnion2<
-            TSink1,
-            TSink2>>
-            CycleMain(
-            IObservable<IUnion2<
-                TSource1,
-                TSource2>> sources,
-            Func<
-                IObservable<TSource1>,
-                IObservable<TSource2>,
-                (
-                    IObservable<TSink1>,
-                    IObservable<TSink2>)> main)
-        {
-            var sourceStreams = sources.Split();
-
-            var sinkStreams = main(
-                sourceStreams.Firsts,
-                sourceStreams.Seconds);
-
-            return ObservableUnion.Merge(
-                sinkStreams.Item1,
-                sinkStreams.Item2);
-        }
-
         public static void Run(
             Func<
                 IObservable<TSource1>,
                 IObservable<TSource2>,
                 (
-                    IObservable<TSink1>,
-                    IObservable<TSink2>)> main,
-            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
-            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond)
-        {
+                    IObservable<TSink1> FirstSinks,
+                    IObservable<TSink2> SecondSinks)> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver,
+            Func<IObservable<TSink2>, IObservable<TSource2>> secondDriver) =>
             Kernel.Run(
-                sources => CycleMain(sources, main),
-                (IObservable<IUnion2<TSink1, TSink2>> sinks) => sinks.CallDrivers(
-                    onFirst,
-                    onSecond));
-        }
+                sources =>
+                {
+                    var (
+                        firstSources,
+                        secondSources) = sources.Split();
+
+                    var (
+                        firstSinks,
+                        secondSinks) = main(
+                            firstSources,
+                            secondSources);
+
+                    return ObservableUnion.Merge(
+                        firstSinks,
+                        secondSinks);
+                },
+                (IObservable<IUnion2<
+                    TSink1,
+                    TSink2>> sinks) => sinks.CallDrivers(
+                    firstDriver,
+                    secondDriver));
     }
 }

From 4dfa7ae617005a26a96f02851b562d9381fdc15c Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Sat, 22 Apr 2023 14:11:26 -0400
Subject: [PATCH 33/42] Merge runner2 into runner

---
 Cycle.NET.Demo/Program.cs |  8 +++++--
 Cycle.NET/Runner.cs       | 37 ++++++++++++++++++++++++++++++
 Cycle.NET/Runner2.cs      | 47 ---------------------------------------
 3 files changed, 43 insertions(+), 49 deletions(-)
 delete mode 100644 Cycle.NET/Runner2.cs

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 4c418f2..9f2fc01 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -65,8 +65,12 @@ static void Main(string[] args)
             };
             Runner.Run(CycleMain, drivers);
 
-            Runner<int, int, int, int>.Run(
-                CycleMain,
+            Runner.Run(
+                (
+                    IObservable<int> logSources,
+                    IObservable<int> keyInputSources) => CycleMain(
+                        logSources,
+                        keyInputSources),
                 LogDriver,
                 KeyInputDriver);
 
diff --git a/Cycle.NET/Runner.cs b/Cycle.NET/Runner.cs
index fbfd765..86779c9 100644
--- a/Cycle.NET/Runner.cs
+++ b/Cycle.NET/Runner.cs
@@ -5,6 +5,7 @@
 using System.Reactive.Subjects;
 using System.Linq;
 using Cycle.NET.Extensions;
+using SdgApps.Common.DotnetSealedUnions;
 
 namespace Cycle.NET
 {
@@ -45,5 +46,41 @@ public static void Run(Func<Streams, Streams> main, Drivers drivers)
                     main),
                 (IObservable<KeyValuePair<string, object>> sinks) => sinks.CallDrivers(drivers));
         }
+
+        public static void Run<
+            TSource1,
+            TSink1,
+            TSource2,
+            TSink2>(
+            Func<
+                IObservable<TSource1>,
+                IObservable<TSource2>,
+                (
+                    IObservable<TSink1> FirstSinks,
+                    IObservable<TSink2> SecondSinks)> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver,
+            Func<IObservable<TSink2>, IObservable<TSource2>> secondDriver) =>
+            Kernel.Run(
+                sources =>
+                {
+                    var (
+                        firstSources,
+                        secondSources) = sources.Split();
+
+                    var (
+                        firstSinks,
+                        secondSinks) = main(
+                            firstSources,
+                            secondSources);
+
+                    return ObservableUnion.Merge(
+                        firstSinks,
+                        secondSinks);
+                },
+                (IObservable<IUnion2<
+                    TSink1,
+                    TSink2>> sinks) => sinks.CallDrivers(
+                    firstDriver,
+                    secondDriver));
     }
 }
diff --git a/Cycle.NET/Runner2.cs b/Cycle.NET/Runner2.cs
deleted file mode 100644
index dd28f9a..0000000
--- a/Cycle.NET/Runner2.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-using System;
-using System.Reactive.Linq;
-using System.Reactive.Subjects;
-using Cycle.NET.Extensions;
-using SdgApps.Common.DotnetSealedUnions;
-
-namespace Cycle.NET
-{
-    public static class Runner<
-        TSource1,
-        TSink1,
-        TSource2,
-        TSink2>
-    {
-        public static void Run(
-            Func<
-                IObservable<TSource1>,
-                IObservable<TSource2>,
-                (
-                    IObservable<TSink1> FirstSinks,
-                    IObservable<TSink2> SecondSinks)> main,
-            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver,
-            Func<IObservable<TSink2>, IObservable<TSource2>> secondDriver) =>
-            Kernel.Run(
-                sources =>
-                {
-                    var (
-                        firstSources,
-                        secondSources) = sources.Split();
-
-                    var (
-                        firstSinks,
-                        secondSinks) = main(
-                            firstSources,
-                            secondSources);
-
-                    return ObservableUnion.Merge(
-                        firstSinks,
-                        secondSinks);
-                },
-                (IObservable<IUnion2<
-                    TSink1,
-                    TSink2>> sinks) => sinks.CallDrivers(
-                    firstDriver,
-                    secondDriver));
-    }
-}

From a155f25ee692cf7c28a8a4905fdb32b6ae3dabb0 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Sat, 22 Apr 2023 19:58:16 -0400
Subject: [PATCH 34/42] Merge in runner3

---
 Cycle.NET/Runner.cs  | 51 +++++++++++++++++++++--
 Cycle.NET/Runner3.cs | 97 --------------------------------------------
 2 files changed, 48 insertions(+), 100 deletions(-)
 delete mode 100644 Cycle.NET/Runner3.cs

diff --git a/Cycle.NET/Runner.cs b/Cycle.NET/Runner.cs
index 86779c9..f61ae55 100644
--- a/Cycle.NET/Runner.cs
+++ b/Cycle.NET/Runner.cs
@@ -37,15 +37,13 @@ private static IObservable<KeyValuePair<string, object>> CycleMain(
                 .Merge(sinkStreams);
         }
 
-        public static void Run(Func<Streams, Streams> main, Drivers drivers)
-        {
+        public static void Run(Func<Streams, Streams> main, Drivers drivers) =>
             Kernel.Run(
                 sources => CycleMain(
                     sources,
                     drivers.Keys,
                     main),
                 (IObservable<KeyValuePair<string, object>> sinks) => sinks.CallDrivers(drivers));
-        }
 
         public static void Run<
             TSource1,
@@ -82,5 +80,52 @@ public static void Run<
                     TSink2>> sinks) => sinks.CallDrivers(
                     firstDriver,
                     secondDriver));
+
+        public static void Run<
+            TSource1,
+            TSink1,
+            TSource2,
+            TSink2,
+            TSource3,
+            TSink3>(
+            Func<
+                IObservable<TSource1>,
+                IObservable<TSource2>,
+                IObservable<TSource3>,
+                (
+                    IObservable<TSink1> FirstSinks,
+                    IObservable<TSink2> SecondSinks,
+                    IObservable<TSink3> ThirdSinks)> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver,
+            Func<IObservable<TSink2>, IObservable<TSource2>> secondDriver,
+            Func<IObservable<TSink3>, IObservable<TSource3>> thirdDriver) =>
+            Kernel.Run(
+                sources =>
+                {
+                    var (
+                        firstSources,
+                        secondSources,
+                        thirdSources) = sources.Split();
+
+                    var (
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks) = main(
+                            firstSources,
+                            secondSources,
+                            thirdSources);
+
+                    return ObservableUnion.Merge(
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks);
+                },
+                (IObservable<IUnion3<
+                    TSink1,
+                    TSink2,
+                    TSink3>> sinks) => sinks.CallDrivers(
+                    firstDriver,
+                    secondDriver,
+                    thirdDriver));
     }
 }
diff --git a/Cycle.NET/Runner3.cs b/Cycle.NET/Runner3.cs
deleted file mode 100644
index 585d973..0000000
--- a/Cycle.NET/Runner3.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-using System;
-using System.Reactive.Linq;
-using System.Reactive.Subjects;
-
-namespace Cycle.NET
-{
-    public class Streams<T1, T2, T3>
-    {
-        public Streams(
-            IObservable<T1> first,
-            IObservable<T2> second,
-            IObservable<T3> third)
-        {
-            First = first;
-            Second = second;
-            Third = third;
-        }
-
-        public IObservable<T1> First { get; }
-        public IObservable<T2> Second { get; }
-        public IObservable<T3> Third { get; }
-    }
-
-    public class Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
-    {
-        public Component(
-            Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> main)
-        {
-            Main = main;
-        }
-
-        public Func<Streams<TSource1, TSource2, TSource3>, Streams<TSink1, TSink2, TSink3>> Main { get; }
-    }
-
-    public class Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
-    {
-        public Drivers(
-            Func<IObservable<TSink1>, IObservable<TSource1>> onFirst,
-            Func<IObservable<TSink2>, IObservable<TSource2>> onSecond,
-            Func<IObservable<TSink3>, IObservable<TSource3>> onThird)
-        {
-            OnFirst = onFirst;
-            OnSecond = onSecond;
-            OnThird = onThird;
-        }
-
-        public Func<IObservable<TSink1>, IObservable<TSource1>> OnFirst { get; }
-        public Func<IObservable<TSink2>, IObservable<TSource2>> OnSecond { get; }
-        public Func<IObservable<TSink3>, IObservable<TSource3>> OnThird { get; }
-    }
-
-    public static class Runner<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3>
-    {
-        public static void Run(
-            Component<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> component,
-            Drivers<TSource1, TSink1, TSource2, TSink2, TSource3, TSink3> drivers)
-        {
-            // Create fake sinks to use to call the drivers to get around the interdependency between
-            // main and the drivers.
-            var fakeSinks = new FakeSinks<TSink1, TSink2, TSink3>(
-                new ReplaySubject<TSink1>(),
-                new ReplaySubject<TSink2>(),
-                new ReplaySubject<TSink3>());
-
-            // Call the drivers and collate the returned sources.
-            var sources = new Streams<TSource1, TSource2, TSource3>(
-                drivers.OnFirst(fakeSinks.First),
-                drivers.OnSecond(fakeSinks.Second),
-                drivers.OnThird(fakeSinks.Third));
-
-            Streams<TSink1, TSink2, TSink3> sinks = component.Main(sources);
-
-            // Update the sinks returned from main with the sinks used by the drivers.
-            sinks.First.Subscribe(fakeSinks.First.OnNext);
-            sinks.Second.Subscribe(fakeSinks.Second.OnNext);
-            sinks.Third.Subscribe(fakeSinks.Third.OnNext);
-        }
-
-        private class FakeSinks<T1, T2, T3>
-        {
-            public FakeSinks(
-                ISubject<T1> first,
-                ISubject<T2> second,
-                ISubject<T3> third)
-            {
-                First = first;
-                Second = second;
-                Third = third;
-            }
-
-            public ISubject<T1> First { get; }
-            public ISubject<T2> Second { get; }
-            public ISubject<T3> Third { get; }
-        }
-
-    }
-}

From 6ca585fb4b13427964034343d261417bd4b271db Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Sat, 22 Apr 2023 21:37:13 -0400
Subject: [PATCH 35/42] Scale run arity

---
 Cycle.NET/Runner.cs | 596 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 578 insertions(+), 18 deletions(-)

diff --git a/Cycle.NET/Runner.cs b/Cycle.NET/Runner.cs
index f61ae55..aea62fe 100644
--- a/Cycle.NET/Runner.cs
+++ b/Cycle.NET/Runner.cs
@@ -22,28 +22,75 @@ public Drivers() : base() { }
 
     public static class Runner
     {
-        private static IObservable<KeyValuePair<string, object>> CycleMain(
-            IObservable<KeyValuePair<string, object>> sources,
-            IEnumerable<string> keys,
-            Func<Streams, Streams> main)
-        {
-            var sourceStreams = new Streams(sources
-                .Split(keys)
-                .ToDictionary(p => p.Key, p => p.Value));
+        public static void Run(Func<Streams, Streams> main, Drivers drivers) =>
+            Kernel.Run(
+                sources =>
+                {
+                    var sourceStreams = new Streams(sources
+                        .Split(drivers.Keys)
+                        .ToDictionary(p => p.Key, p => p.Value));
 
-            var sinkStreams = main(sourceStreams);
+                    var sinkStreams = main(sourceStreams);
 
-            return ObservableUnion
-                .Merge(sinkStreams);
-        }
+                    return ObservableUnion
+                        .Merge(sinkStreams);
+                },
+                (IObservable<KeyValuePair<string, object>> sinks) => sinks.CallDrivers(drivers));
 
-        public static void Run(Func<Streams, Streams> main, Drivers drivers) =>
+        public static void Run<
+            TSource1,
+            TSink1>(
+            Func<
+                IObservable<TSource1>,
+                IObservable<TSink1>> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver) =>
             Kernel.Run(
-                sources => CycleMain(
-                    sources,
-                    drivers.Keys,
-                    main),
-                (IObservable<KeyValuePair<string, object>> sinks) => sinks.CallDrivers(drivers));
+                sources =>
+                {
+                    var firstSources = sources.Split();
+
+                    var firstSinks = main(
+                        firstSources);
+
+                    return ObservableUnion.Merge(
+                        firstSinks);
+                },
+                (IObservable<IUnion0<
+                    TSink1>> sinks) => sinks.CallDrivers(
+                    firstDriver));
+
+        public static void Run<
+            TSource1,
+            TSink1>(
+            Func<
+                IObservable<Unit>,
+                IObservable<TSource1>,
+                (
+                    IObservable<Unit> NoneSinks,
+                    IObservable<TSink1> FirstSinks)> main,
+            Func<IObservable<Unit>, IObservable<Unit>> noneDriver,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver) =>
+            Kernel.Run(
+                sources =>
+                {
+                    var (
+                        noneSources,
+                        firstSources) = sources.Split();
+
+                    var (
+                        noneSinks,
+                        firstSinks) = main(
+                            noneSources,
+                            firstSources);
+
+                    return ObservableUnion.Merge(
+                        noneSinks,
+                        firstSinks);
+                },
+                (IObservable<IUnion1<
+                    TSink1>> sinks) => sinks.CallDrivers(
+                    noneDriver,
+                    firstDriver));
 
         public static void Run<
             TSource1,
@@ -127,5 +174,518 @@ public static void Run<
                     firstDriver,
                     secondDriver,
                     thirdDriver));
+
+        public static void Run<
+            TSource1,
+            TSink1,
+            TSource2,
+            TSink2,
+            TSource3,
+            TSink3,
+            TSource4,
+            TSink4>(
+            Func<
+                IObservable<TSource1>,
+                IObservable<TSource2>,
+                IObservable<TSource3>,
+                IObservable<TSource4>,
+                (
+                    IObservable<TSink1> FirstSinks,
+                    IObservable<TSink2> SecondSinks,
+                    IObservable<TSink3> ThirdSinks,
+                    IObservable<TSink4> FourthSinks)> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver,
+            Func<IObservable<TSink2>, IObservable<TSource2>> secondDriver,
+            Func<IObservable<TSink3>, IObservable<TSource3>> thirdDriver,
+            Func<IObservable<TSink4>, IObservable<TSource4>> fourthDriver) =>
+            Kernel.Run(
+                sources =>
+                {
+                    var (
+                        firstSources,
+                        secondSources,
+                        thirdSources,
+                        fourthSources) = sources.Split();
+
+                    var (
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks) = main(
+                            firstSources,
+                            secondSources,
+                            thirdSources,
+                            fourthSources);
+
+                    return ObservableUnion.Merge(
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks);
+                },
+                (IObservable<IUnion4<
+                    TSink1,
+                    TSink2,
+                    TSink3,
+                    TSink4>> sinks) => sinks.CallDrivers(
+                    firstDriver,
+                    secondDriver,
+                    thirdDriver,
+                    fourthDriver));
+
+        public static void Run<
+            TSource1,
+            TSink1,
+            TSource2,
+            TSink2,
+            TSource3,
+            TSink3,
+            TSource4,
+            TSink4,
+            TSource5,
+            TSink5>(
+            Func<
+                IObservable<TSource1>,
+                IObservable<TSource2>,
+                IObservable<TSource3>,
+                IObservable<TSource4>,
+                IObservable<TSource5>,
+                (
+                    IObservable<TSink1> FirstSinks,
+                    IObservable<TSink2> SecondSinks,
+                    IObservable<TSink3> ThirdSinks,
+                    IObservable<TSink4> FourthSinks,
+                    IObservable<TSink5> FifthSinks)> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver,
+            Func<IObservable<TSink2>, IObservable<TSource2>> secondDriver,
+            Func<IObservable<TSink3>, IObservable<TSource3>> thirdDriver,
+            Func<IObservable<TSink4>, IObservable<TSource4>> fourthDriver,
+            Func<IObservable<TSink5>, IObservable<TSource5>> fifthDriver) =>
+            Kernel.Run(
+                sources =>
+                {
+                    var (
+                        firstSources,
+                        secondSources,
+                        thirdSources,
+                        fourthSources,
+                        fifthSources) = sources.Split();
+
+                    var (
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks,
+                        fifthSinks) = main(
+                            firstSources,
+                            secondSources,
+                            thirdSources,
+                            fourthSources,
+                            fifthSources);
+
+                    return ObservableUnion.Merge(
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks,
+                        fifthSinks);
+                },
+                (IObservable<IUnion5<
+                    TSink1,
+                    TSink2,
+                    TSink3,
+                    TSink4,
+                    TSink5>> sinks) => sinks.CallDrivers(
+                    firstDriver,
+                    secondDriver,
+                    thirdDriver,
+                    fourthDriver,
+                    fifthDriver));
+
+        public static void Run<
+            TSource1,
+            TSink1,
+            TSource2,
+            TSink2,
+            TSource3,
+            TSink3,
+            TSource4,
+            TSink4,
+            TSource5,
+            TSink5,
+            TSource6,
+            TSink6>(
+            Func<
+                IObservable<TSource1>,
+                IObservable<TSource2>,
+                IObservable<TSource3>,
+                IObservable<TSource4>,
+                IObservable<TSource5>,
+                IObservable<TSource6>,
+                (
+                    IObservable<TSink1> FirstSinks,
+                    IObservable<TSink2> SecondSinks,
+                    IObservable<TSink3> ThirdSinks,
+                    IObservable<TSink4> FourthSinks,
+                    IObservable<TSink5> FifthSinks,
+                    IObservable<TSink6> SixthSinks)> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver,
+            Func<IObservable<TSink2>, IObservable<TSource2>> secondDriver,
+            Func<IObservable<TSink3>, IObservable<TSource3>> thirdDriver,
+            Func<IObservable<TSink4>, IObservable<TSource4>> fourthDriver,
+            Func<IObservable<TSink5>, IObservable<TSource5>> fifthDriver,
+            Func<IObservable<TSink6>, IObservable<TSource6>> sixthDriver) =>
+            Kernel.Run(
+                sources =>
+                {
+                    var (
+                        firstSources,
+                        secondSources,
+                        thirdSources,
+                        fourthSources,
+                        fifthSources,
+                        sixthSources) = sources.Split();
+
+                    var (
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks,
+                        fifthSinks,
+                        sixthSinks) = main(
+                            firstSources,
+                            secondSources,
+                            thirdSources,
+                            fourthSources,
+                            fifthSources,
+                            sixthSources);
+
+                    return ObservableUnion.Merge(
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks,
+                        fifthSinks,
+                        sixthSinks);
+                },
+                (IObservable<IUnion6<
+                    TSink1,
+                    TSink2,
+                    TSink3,
+                    TSink4,
+                    TSink5,
+                    TSink6>> sinks) => sinks.CallDrivers(
+                    firstDriver,
+                    secondDriver,
+                    thirdDriver,
+                    fourthDriver,
+                    fifthDriver,
+                    sixthDriver));
+
+        public static void Run<
+            TSource1,
+            TSink1,
+            TSource2,
+            TSink2,
+            TSource3,
+            TSink3,
+            TSource4,
+            TSink4,
+            TSource5,
+            TSink5,
+            TSource6,
+            TSink6,
+            TSource7,
+            TSink7>(
+            Func<
+                IObservable<TSource1>,
+                IObservable<TSource2>,
+                IObservable<TSource3>,
+                IObservable<TSource4>,
+                IObservable<TSource5>,
+                IObservable<TSource6>,
+                IObservable<TSource7>,
+                (
+                    IObservable<TSink1> FirstSinks,
+                    IObservable<TSink2> SecondSinks,
+                    IObservable<TSink3> ThirdSinks,
+                    IObservable<TSink4> FourthSinks,
+                    IObservable<TSink5> FifthSinks,
+                    IObservable<TSink6> SixthSinks,
+                    IObservable<TSink7> SeventhSinks)> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver,
+            Func<IObservable<TSink2>, IObservable<TSource2>> secondDriver,
+            Func<IObservable<TSink3>, IObservable<TSource3>> thirdDriver,
+            Func<IObservable<TSink4>, IObservable<TSource4>> fourthDriver,
+            Func<IObservable<TSink5>, IObservable<TSource5>> fifthDriver,
+            Func<IObservable<TSink6>, IObservable<TSource6>> sixthDriver,
+            Func<IObservable<TSink7>, IObservable<TSource7>> seventhDriver) =>
+            Kernel.Run(
+                sources =>
+                {
+                    var (
+                        firstSources,
+                        secondSources,
+                        thirdSources,
+                        fourthSources,
+                        fifthSources,
+                        sixthSources,
+                        seventhSources) = sources.Split();
+
+                    var (
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks,
+                        fifthSinks,
+                        sixthSinks,
+                        seventhSinks) = main(
+                            firstSources,
+                            secondSources,
+                            thirdSources,
+                            fourthSources,
+                            fifthSources,
+                            sixthSources,
+                            seventhSources);
+
+                    return ObservableUnion.Merge(
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks,
+                        fifthSinks,
+                        sixthSinks,
+                        seventhSinks);
+                },
+                (IObservable<IUnion7<
+                    TSink1,
+                    TSink2,
+                    TSink3,
+                    TSink4,
+                    TSink5,
+                    TSink6,
+                    TSink7>> sinks) => sinks.CallDrivers(
+                    firstDriver,
+                    secondDriver,
+                    thirdDriver,
+                    fourthDriver,
+                    fifthDriver,
+                    sixthDriver,
+                    seventhDriver));
+
+        public static void Run<
+            TSource1,
+            TSink1,
+            TSource2,
+            TSink2,
+            TSource3,
+            TSink3,
+            TSource4,
+            TSink4,
+            TSource5,
+            TSink5,
+            TSource6,
+            TSink6,
+            TSource7,
+            TSink7,
+            TSource8,
+            TSink8>(
+            Func<
+                IObservable<TSource1>,
+                IObservable<TSource2>,
+                IObservable<TSource3>,
+                IObservable<TSource4>,
+                IObservable<TSource5>,
+                IObservable<TSource6>,
+                IObservable<TSource7>,
+                IObservable<TSource8>,
+                (
+                    IObservable<TSink1> FirstSinks,
+                    IObservable<TSink2> SecondSinks,
+                    IObservable<TSink3> ThirdSinks,
+                    IObservable<TSink4> FourthSinks,
+                    IObservable<TSink5> FifthSinks,
+                    IObservable<TSink6> SixthSinks,
+                    IObservable<TSink7> SeventhSinks,
+                    IObservable<TSink8> EighthSinks)> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver,
+            Func<IObservable<TSink2>, IObservable<TSource2>> secondDriver,
+            Func<IObservable<TSink3>, IObservable<TSource3>> thirdDriver,
+            Func<IObservable<TSink4>, IObservable<TSource4>> fourthDriver,
+            Func<IObservable<TSink5>, IObservable<TSource5>> fifthDriver,
+            Func<IObservable<TSink6>, IObservable<TSource6>> sixthDriver,
+            Func<IObservable<TSink7>, IObservable<TSource7>> seventhDriver,
+            Func<IObservable<TSink8>, IObservable<TSource8>> eighthDriver) =>
+            Kernel.Run(
+                sources =>
+                {
+                    var (
+                        firstSources,
+                        secondSources,
+                        thirdSources,
+                        fourthSources,
+                        fifthSources,
+                        sixthSources,
+                        seventhSources,
+                        eighthSources) = sources.Split();
+
+                    var (
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks,
+                        fifthSinks,
+                        sixthSinks,
+                        seventhSinks,
+                        eighthSinks) = main(
+                            firstSources,
+                            secondSources,
+                            thirdSources,
+                            fourthSources,
+                            fifthSources,
+                            sixthSources,
+                            seventhSources,
+                            eighthSources);
+
+                    return ObservableUnion.Merge(
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks,
+                        fifthSinks,
+                        sixthSinks,
+                        seventhSinks,
+                        eighthSinks);
+                },
+                (IObservable<IUnion8<
+                    TSink1,
+                    TSink2,
+                    TSink3,
+                    TSink4,
+                    TSink5,
+                    TSink6,
+                    TSink7,
+                    TSink8>> sinks) => sinks.CallDrivers(
+                    firstDriver,
+                    secondDriver,
+                    thirdDriver,
+                    fourthDriver,
+                    fifthDriver,
+                    sixthDriver,
+                    seventhDriver,
+                    eighthDriver));
+
+        public static void Run<
+            TSource1,
+            TSink1,
+            TSource2,
+            TSink2,
+            TSource3,
+            TSink3,
+            TSource4,
+            TSink4,
+            TSource5,
+            TSink5,
+            TSource6,
+            TSink6,
+            TSource7,
+            TSink7,
+            TSource8,
+            TSink8,
+            TSource9,
+            TSink9>(
+            Func<
+                IObservable<TSource1>,
+                IObservable<TSource2>,
+                IObservable<TSource3>,
+                IObservable<TSource4>,
+                IObservable<TSource5>,
+                IObservable<TSource6>,
+                IObservable<TSource7>,
+                IObservable<TSource8>,
+                IObservable<TSource9>,
+                (
+                    IObservable<TSink1> FirstSinks,
+                    IObservable<TSink2> SecondSinks,
+                    IObservable<TSink3> ThirdSinks,
+                    IObservable<TSink4> FourthSinks,
+                    IObservable<TSink5> FifthSinks,
+                    IObservable<TSink6> SixthSinks,
+                    IObservable<TSink7> SeventhSinks,
+                    IObservable<TSink8> EighthSinks,
+                    IObservable<TSink9> NinthSinks)> main,
+            Func<IObservable<TSink1>, IObservable<TSource1>> firstDriver,
+            Func<IObservable<TSink2>, IObservable<TSource2>> secondDriver,
+            Func<IObservable<TSink3>, IObservable<TSource3>> thirdDriver,
+            Func<IObservable<TSink4>, IObservable<TSource4>> fourthDriver,
+            Func<IObservable<TSink5>, IObservable<TSource5>> fifthDriver,
+            Func<IObservable<TSink6>, IObservable<TSource6>> sixthDriver,
+            Func<IObservable<TSink7>, IObservable<TSource7>> seventhDriver,
+            Func<IObservable<TSink8>, IObservable<TSource8>> eighthDriver,
+            Func<IObservable<TSink9>, IObservable<TSource9>> ninthDriver) =>
+            Kernel.Run(
+                sources =>
+                {
+                    var (
+                        firstSources,
+                        secondSources,
+                        thirdSources,
+                        fourthSources,
+                        fifthSources,
+                        sixthSources,
+                        seventhSources,
+                        eighthSources,
+                        ninthSources) = sources.Split();
+
+                    var (
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks,
+                        fifthSinks,
+                        sixthSinks,
+                        seventhSinks,
+                        eighthSinks,
+                        ninthSinks) = main(
+                            firstSources,
+                            secondSources,
+                            thirdSources,
+                            fourthSources,
+                            fifthSources,
+                            sixthSources,
+                            seventhSources,
+                            eighthSources,
+                            ninthSources);
+
+                    return ObservableUnion.Merge(
+                        firstSinks,
+                        secondSinks,
+                        thirdSinks,
+                        fourthSinks,
+                        fifthSinks,
+                        sixthSinks,
+                        seventhSinks,
+                        eighthSinks,
+                        ninthSinks);
+                },
+                (IObservable<IUnion9<
+                    TSink1,
+                    TSink2,
+                    TSink3,
+                    TSink4,
+                    TSink5,
+                    TSink6,
+                    TSink7,
+                    TSink8,
+                    TSink9>> sinks) => sinks.CallDrivers(
+                    firstDriver,
+                    secondDriver,
+                    thirdDriver,
+                    fourthDriver,
+                    fifthDriver,
+                    sixthDriver,
+                    seventhDriver,
+                    eighthDriver,
+                    ninthDriver));
     }
 }

From 6a8bf24a8ea1263295ad378dc101876f09572b83 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Sat, 22 Apr 2023 21:46:51 -0400
Subject: [PATCH 36/42] Clean up issues

---
 Cycle.NET.Demo/Program.cs |  5 ++++-
 Cycle.NET/Runner.cs       | 12 ++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 9f2fc01..35bf0ae 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -6,7 +6,7 @@
 
 namespace Cycle.NET.Demo
 {
-    class Program
+    internal static class Program
     {
         private static IObservable<object> LogDriver(IObservable<object> sinks)
         {
@@ -24,6 +24,8 @@ private static IObservable<int> LogDriver(IObservable<int> sinks)
 
         private static IObservable<object> KeyInputDriver(IObservable<object> sinks)
         {
+            _ = sinks;
+
             return Observable.Range(20, 5).Select(i => (object)i);
         }
 
@@ -49,6 +51,7 @@ private static (
             IObservable<int> logSources,
             IObservable<int> keyInputSources)
         {
+            _ = logSources;
             var logSink = keyInputSources;
 
             return (
diff --git a/Cycle.NET/Runner.cs b/Cycle.NET/Runner.cs
index aea62fe..83ce79d 100644
--- a/Cycle.NET/Runner.cs
+++ b/Cycle.NET/Runner.cs
@@ -6,18 +6,30 @@
 using System.Linq;
 using Cycle.NET.Extensions;
 using SdgApps.Common.DotnetSealedUnions;
+using System.Runtime.Serialization;
 
 namespace Cycle.NET
 {
+    [Serializable]
     public class Streams : Dictionary<string, IObservable<object>>
     {
         public Streams() : base() { }
+
         public Streams(Dictionary<string, IObservable<object>> value) : base(value) { }
+
+        protected Streams(
+            SerializationInfo info,
+            StreamingContext context) : base(info, context) { }
     }
 
+    [Serializable]
     public class Drivers : Dictionary<string, Func<IObservable<object>, IObservable<object>>>
     {
         public Drivers() : base() { }
+
+        protected Drivers(
+            SerializationInfo info,
+            StreamingContext context) : base(info, context) { }
     }
 
     public static class Runner

From b0ffbfd0bfeff7a8d3122cbcb11bd5745907db9a Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Sat, 22 Apr 2023 21:52:00 -0400
Subject: [PATCH 37/42] Split demos

---
 Cycle.NET.Demo/Program.cs                     | 40 ----------------
 .../Cycle.NET.UnionDemo.csproj                | 16 +++++++
 Cycle.NET.UnionDemo/Program.cs                | 48 +++++++++++++++++++
 Cycle.NET.sln                                 | 14 ++++--
 4 files changed, 74 insertions(+), 44 deletions(-)
 create mode 100644 Cycle.NET.UnionDemo/Cycle.NET.UnionDemo.csproj
 create mode 100644 Cycle.NET.UnionDemo/Program.cs

diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 35bf0ae..4947afe 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Reactive.Linq;
-using Cycle.NET.Extensions;
-using SdgApps.Common.DotnetSealedUnions;
 
 namespace Cycle.NET.Demo
 {
@@ -15,13 +13,6 @@ private static IObservable<object> LogDriver(IObservable<object> sinks)
             return Observable.Empty<object>();
         }
 
-        private static IObservable<int> LogDriver(IObservable<int> sinks)
-        {
-            sinks.Subscribe(i => Console.WriteLine("Log " + i.ToString()));
-
-            return Observable.Empty<int>();
-        }
-
         private static IObservable<object> KeyInputDriver(IObservable<object> sinks)
         {
             _ = sinks;
@@ -29,11 +20,6 @@ private static IObservable<object> KeyInputDriver(IObservable<object> sinks)
             return Observable.Range(20, 5).Select(i => (object)i);
         }
 
-        private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
-        {
-            return Observable.Range(20, 5);
-        }
-
         private static Streams CycleMain(Streams sources)
         {
             var sinks = new Streams
@@ -43,22 +29,6 @@ private static Streams CycleMain(Streams sources)
 
             return sinks;
         }
-
-        private static (
-            IObservable<int> LogSinks,
-            IObservable<int> KeyInputSinks)
-            CycleMain(
-            IObservable<int> logSources,
-            IObservable<int> keyInputSources)
-        {
-            _ = logSources;
-            var logSink = keyInputSources;
-
-            return (
-                logSink,
-                Observable.Empty<int>());
-        }
-
         static void Main(string[] args)
         {
             var drivers = new Drivers
@@ -67,16 +37,6 @@ static void Main(string[] args)
                 { "keys", KeyInputDriver }
             };
             Runner.Run(CycleMain, drivers);
-
-            Runner.Run(
-                (
-                    IObservable<int> logSources,
-                    IObservable<int> keyInputSources) => CycleMain(
-                        logSources,
-                        keyInputSources),
-                LogDriver,
-                KeyInputDriver);
-
             Console.ReadLine();
         }
     }
diff --git a/Cycle.NET.UnionDemo/Cycle.NET.UnionDemo.csproj b/Cycle.NET.UnionDemo/Cycle.NET.UnionDemo.csproj
new file mode 100644
index 0000000..6ac46b6
--- /dev/null
+++ b/Cycle.NET.UnionDemo/Cycle.NET.UnionDemo.csproj
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net7.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Cycle.NET\Cycle.NET.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/Cycle.NET.UnionDemo/Program.cs b/Cycle.NET.UnionDemo/Program.cs
new file mode 100644
index 0000000..5efda0b
--- /dev/null
+++ b/Cycle.NET.UnionDemo/Program.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Reactive.Linq;
+
+namespace Cycle.NET.Demo
+{
+    internal static class Program
+    {
+        private static IObservable<int> LogDriver(IObservable<int> sinks)
+        {
+            sinks.Subscribe(i => Console.WriteLine("Log " + i.ToString()));
+
+            return Observable.Empty<int>();
+        }
+
+        private static IObservable<int> KeyInputDriver(IObservable<int> sinks)
+        {
+            return Observable.Range(20, 5);
+        }
+
+        private static (
+            IObservable<int> LogSinks,
+            IObservable<int> KeyInputSinks)
+            CycleMain(
+            IObservable<int> logSources,
+            IObservable<int> keyInputSources)
+        {
+            _ = logSources;
+            var logSink = keyInputSources;
+
+            return (
+                logSink,
+                Observable.Empty<int>());
+        }
+        static void Main(string[] args)
+        {
+            Runner.Run(
+                (
+                    IObservable<int> logSources,
+                    IObservable<int> keyInputSources) => CycleMain(
+                        logSources,
+                        keyInputSources),
+                LogDriver,
+                KeyInputDriver);
+            Console.ReadLine();
+        }
+    }
+}
diff --git a/Cycle.NET.sln b/Cycle.NET.sln
index 5cc5ff2..4463e49 100644
--- a/Cycle.NET.sln
+++ b/Cycle.NET.sln
@@ -1,11 +1,13 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.26621.2
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.33516.290
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Cycle.NET", "Cycle.NET\Cycle.NET.csproj", "{6A0D9074-CE78-4217-A7D6-07554439A5BF}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Cycle.NET", "Cycle.NET\Cycle.NET.csproj", "{6A0D9074-CE78-4217-A7D6-07554439A5BF}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Cycle.NET.Demo", "Cycle.NET.Demo\Cycle.NET.Demo.csproj", "{E0B049E9-C963-4627-872B-56F6BCE5728C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Cycle.NET.Demo", "Cycle.NET.Demo\Cycle.NET.Demo.csproj", "{E0B049E9-C963-4627-872B-56F6BCE5728C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Cycle.NET.UnionDemo", "Cycle.NET.UnionDemo\Cycle.NET.UnionDemo.csproj", "{65F17018-1196-4153-A2D4-9711768A030B}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -21,6 +23,10 @@ Global
 		{E0B049E9-C963-4627-872B-56F6BCE5728C}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E0B049E9-C963-4627-872B-56F6BCE5728C}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E0B049E9-C963-4627-872B-56F6BCE5728C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{65F17018-1196-4153-A2D4-9711768A030B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{65F17018-1196-4153-A2D4-9711768A030B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{65F17018-1196-4153-A2D4-9711768A030B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{65F17018-1196-4153-A2D4-9711768A030B}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

From dfb7041af7520e62e0ae59a09abef75159862926 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Tue, 25 Apr 2023 02:57:45 -0400
Subject: [PATCH 38/42] Add toggle demo

---
 Cycle.NET.UnionDemo/Program.cs | 37 ++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/Cycle.NET.UnionDemo/Program.cs b/Cycle.NET.UnionDemo/Program.cs
index 5efda0b..077c15a 100644
--- a/Cycle.NET.UnionDemo/Program.cs
+++ b/Cycle.NET.UnionDemo/Program.cs
@@ -6,6 +6,7 @@ namespace Cycle.NET.Demo
 {
     internal static class Program
     {
+#if ORIG_DEMO
         private static IObservable<int> LogDriver(IObservable<int> sinks)
         {
             sinks.Subscribe(i => Console.WriteLine("Log " + i.ToString()));
@@ -44,5 +45,41 @@ static void Main(string[] args)
                 KeyInputDriver);
             Console.ReadLine();
         }
+#else
+        private static IObservable<bool> DomDriver(IObservable<string> sinks)
+        {
+            sinks.Subscribe(Console.WriteLine);
+
+            return new List<bool>
+            {
+                false,
+                true,
+                false,
+                true,
+            }
+            .ToObservable();
+        }
+
+        private static
+            IObservable<string>
+            CycleMain(
+            IObservable<bool> domSources)
+        {
+            var domSink =
+                domSources
+                .Select(toggled => toggled ? "ON" : "off");
+
+            return domSink;
+        }
+        static void Main(string[] args)
+        {
+            Runner.Run(
+                (
+                    IObservable<bool> domSources) => CycleMain(
+                        domSources),
+                DomDriver);
+            Console.ReadLine();
+        }
+#endif
     }
 }

From f79ec21f2d69c3ae322205ab58f812743b96ae04 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Wed, 26 Apr 2023 00:54:04 -0400
Subject: [PATCH 39/42] Add demo app project

---
 Cycle.NET.ToggleDemo/App.xaml                 |  14 +
 Cycle.NET.ToggleDemo/App.xaml.cs              |  12 +
 Cycle.NET.ToggleDemo/AppShell.xaml            |  14 +
 Cycle.NET.ToggleDemo/AppShell.xaml.cs         |  10 +
 .../Cycle.NET.ToggleDemo.csproj               |  55 +++
 Cycle.NET.ToggleDemo/MainPage.xaml            |  41 ++
 Cycle.NET.ToggleDemo/MainPage.xaml.cs         |  24 ++
 Cycle.NET.ToggleDemo/MauiProgram.cs           |  25 ++
 .../Platforms/Android/AndroidManifest.xml     |   6 +
 .../Platforms/Android/MainActivity.cs         |  11 +
 .../Platforms/Android/MainApplication.cs      |  16 +
 .../Android/Resources/values/colors.xml       |   6 +
 .../Platforms/MacCatalyst/AppDelegate.cs      |  10 +
 .../Platforms/MacCatalyst/Info.plist          |  30 ++
 .../Platforms/MacCatalyst/Program.cs          |  16 +
 Cycle.NET.ToggleDemo/Platforms/Tizen/Main.cs  |  17 +
 .../Platforms/Tizen/tizen-manifest.xml        |  15 +
 .../Platforms/Windows/App.xaml                |   8 +
 .../Platforms/Windows/App.xaml.cs             |  24 ++
 .../Platforms/Windows/Package.appxmanifest    |  46 ++
 .../Platforms/Windows/app.manifest            |  15 +
 .../Platforms/iOS/AppDelegate.cs              |  10 +
 Cycle.NET.ToggleDemo/Platforms/iOS/Info.plist |  32 ++
 Cycle.NET.ToggleDemo/Platforms/iOS/Program.cs |  16 +
 .../Properties/launchSettings.json            |   8 +
 .../Resources/AppIcon/appicon.svg             |   4 +
 .../Resources/AppIcon/appiconfg.svg           |   8 +
 .../Resources/Fonts/OpenSans-Regular.ttf      | Bin 0 -> 107140 bytes
 .../Resources/Fonts/OpenSans-Semibold.ttf     | Bin 0 -> 111068 bytes
 .../Resources/Images/dotnet_bot.svg           |  93 ++++
 .../Resources/Raw/AboutAssets.txt             |  15 +
 .../Resources/Splash/splash.svg               |   8 +
 .../Resources/Styles/Colors.xaml              |  44 ++
 .../Resources/Styles/Styles.xaml              | 405 ++++++++++++++++++
 Cycle.NET.sln                                 |  10 +-
 35 files changed, 1067 insertions(+), 1 deletion(-)
 create mode 100644 Cycle.NET.ToggleDemo/App.xaml
 create mode 100644 Cycle.NET.ToggleDemo/App.xaml.cs
 create mode 100644 Cycle.NET.ToggleDemo/AppShell.xaml
 create mode 100644 Cycle.NET.ToggleDemo/AppShell.xaml.cs
 create mode 100644 Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
 create mode 100644 Cycle.NET.ToggleDemo/MainPage.xaml
 create mode 100644 Cycle.NET.ToggleDemo/MainPage.xaml.cs
 create mode 100644 Cycle.NET.ToggleDemo/MauiProgram.cs
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/Android/AndroidManifest.xml
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/Android/MainActivity.cs
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/Android/MainApplication.cs
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/Android/Resources/values/colors.xml
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/MacCatalyst/AppDelegate.cs
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Info.plist
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Program.cs
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/Tizen/Main.cs
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/Tizen/tizen-manifest.xml
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/Windows/App.xaml
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/Windows/App.xaml.cs
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/Windows/Package.appxmanifest
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/Windows/app.manifest
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/iOS/AppDelegate.cs
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/iOS/Info.plist
 create mode 100644 Cycle.NET.ToggleDemo/Platforms/iOS/Program.cs
 create mode 100644 Cycle.NET.ToggleDemo/Properties/launchSettings.json
 create mode 100644 Cycle.NET.ToggleDemo/Resources/AppIcon/appicon.svg
 create mode 100644 Cycle.NET.ToggleDemo/Resources/AppIcon/appiconfg.svg
 create mode 100644 Cycle.NET.ToggleDemo/Resources/Fonts/OpenSans-Regular.ttf
 create mode 100644 Cycle.NET.ToggleDemo/Resources/Fonts/OpenSans-Semibold.ttf
 create mode 100644 Cycle.NET.ToggleDemo/Resources/Images/dotnet_bot.svg
 create mode 100644 Cycle.NET.ToggleDemo/Resources/Raw/AboutAssets.txt
 create mode 100644 Cycle.NET.ToggleDemo/Resources/Splash/splash.svg
 create mode 100644 Cycle.NET.ToggleDemo/Resources/Styles/Colors.xaml
 create mode 100644 Cycle.NET.ToggleDemo/Resources/Styles/Styles.xaml

diff --git a/Cycle.NET.ToggleDemo/App.xaml b/Cycle.NET.ToggleDemo/App.xaml
new file mode 100644
index 0000000..f1e7bf1
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/App.xaml
@@ -0,0 +1,14 @@
+<?xml version = "1.0" encoding = "UTF-8" ?>
+<Application xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             xmlns:local="clr-namespace:Cycle.NET.ToggleDemo"
+             x:Class="Cycle.NET.ToggleDemo.App">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceDictionary Source="Resources/Styles/Colors.xaml" />
+                <ResourceDictionary Source="Resources/Styles/Styles.xaml" />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>
diff --git a/Cycle.NET.ToggleDemo/App.xaml.cs b/Cycle.NET.ToggleDemo/App.xaml.cs
new file mode 100644
index 0000000..3afe14b
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/App.xaml.cs
@@ -0,0 +1,12 @@
+namespace Cycle.NET.ToggleDemo
+{
+    public partial class App : Application
+    {
+        public App()
+        {
+            InitializeComponent();
+
+            MainPage = new AppShell();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/AppShell.xaml b/Cycle.NET.ToggleDemo/AppShell.xaml
new file mode 100644
index 0000000..28dfa95
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/AppShell.xaml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<Shell
+    x:Class="Cycle.NET.ToggleDemo.AppShell"
+    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+    xmlns:local="clr-namespace:Cycle.NET.ToggleDemo"
+    Shell.FlyoutBehavior="Disabled">
+
+    <ShellContent
+        Title="Home"
+        ContentTemplate="{DataTemplate local:MainPage}"
+        Route="MainPage" />
+
+</Shell>
diff --git a/Cycle.NET.ToggleDemo/AppShell.xaml.cs b/Cycle.NET.ToggleDemo/AppShell.xaml.cs
new file mode 100644
index 0000000..ec2f41c
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/AppShell.xaml.cs
@@ -0,0 +1,10 @@
+namespace Cycle.NET.ToggleDemo
+{
+    public partial class AppShell : Shell
+    {
+        public AppShell()
+        {
+            InitializeComponent();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj b/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
new file mode 100644
index 0000000..a2765a8
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
@@ -0,0 +1,55 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFrameworks>net7.0-android;net7.0-ios;net7.0-maccatalyst</TargetFrameworks>
+		<TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">$(TargetFrameworks);net7.0-windows10.0.19041.0</TargetFrameworks>
+		<!-- Uncomment to also build the tizen app. You will need to install tizen by following this: https://github.com/Samsung/Tizen.NET -->
+		<!-- <TargetFrameworks>$(TargetFrameworks);net7.0-tizen</TargetFrameworks> -->
+		<OutputType>Exe</OutputType>
+		<RootNamespace>Cycle.NET.ToggleDemo</RootNamespace>
+		<UseMaui>true</UseMaui>
+		<SingleProject>true</SingleProject>
+		<ImplicitUsings>enable</ImplicitUsings>
+
+		<!-- Display name -->
+		<ApplicationTitle>Cycle.NET.ToggleDemo</ApplicationTitle>
+
+		<!-- App Identifier -->
+		<ApplicationId>com.companyname.cycle.net.toggledemo</ApplicationId>
+		<ApplicationIdGuid>890c6119-9c69-4ea5-9c90-82044e4cd5d2</ApplicationIdGuid>
+
+		<!-- Versions -->
+		<ApplicationDisplayVersion>1.0</ApplicationDisplayVersion>
+		<ApplicationVersion>1</ApplicationVersion>
+
+		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'ios'">11.0</SupportedOSPlatformVersion>
+		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'maccatalyst'">13.1</SupportedOSPlatformVersion>
+		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">21.0</SupportedOSPlatformVersion>
+		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">10.0.17763.0</SupportedOSPlatformVersion>
+		<TargetPlatformMinVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">10.0.17763.0</TargetPlatformMinVersion>
+		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'tizen'">6.5</SupportedOSPlatformVersion>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<!-- App Icon -->
+		<MauiIcon Include="Resources\AppIcon\appicon.svg" ForegroundFile="Resources\AppIcon\appiconfg.svg" Color="#512BD4" />
+
+		<!-- Splash Screen -->
+		<MauiSplashScreen Include="Resources\Splash\splash.svg" Color="#512BD4" BaseSize="128,128" />
+
+		<!-- Images -->
+		<MauiImage Include="Resources\Images\*" />
+		<MauiImage Update="Resources\Images\dotnet_bot.svg" BaseSize="168,208" />
+
+		<!-- Custom Fonts -->
+		<MauiFont Include="Resources\Fonts\*" />
+
+		<!-- Raw Assets (also remove the "Resources\Raw" prefix) -->
+		<MauiAsset Include="Resources\Raw\**" LogicalName="%(RecursiveDir)%(Filename)%(Extension)" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="7.0.0" />
+	</ItemGroup>
+
+</Project>
diff --git a/Cycle.NET.ToggleDemo/MainPage.xaml b/Cycle.NET.ToggleDemo/MainPage.xaml
new file mode 100644
index 0000000..357fc94
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/MainPage.xaml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             x:Class="Cycle.NET.ToggleDemo.MainPage">
+
+    <ScrollView>
+        <VerticalStackLayout
+            Spacing="25"
+            Padding="30,0"
+            VerticalOptions="Center">
+
+            <Image
+                Source="dotnet_bot.png"
+                SemanticProperties.Description="Cute dot net bot waving hi to you!"
+                HeightRequest="200"
+                HorizontalOptions="Center" />
+
+            <Label
+                Text="Hello, World!"
+                SemanticProperties.HeadingLevel="Level1"
+                FontSize="32"
+                HorizontalOptions="Center" />
+
+            <Label
+                Text="Welcome to .NET Multi-platform App UI"
+                SemanticProperties.HeadingLevel="Level2"
+                SemanticProperties.Description="Welcome to dot net Multi platform App U I"
+                FontSize="18"
+                HorizontalOptions="Center" />
+
+            <Button
+                x:Name="CounterBtn"
+                Text="Click me"
+                SemanticProperties.Hint="Counts the number of times you click"
+                Clicked="OnCounterClicked"
+                HorizontalOptions="Center" />
+
+        </VerticalStackLayout>
+    </ScrollView>
+
+</ContentPage>
diff --git a/Cycle.NET.ToggleDemo/MainPage.xaml.cs b/Cycle.NET.ToggleDemo/MainPage.xaml.cs
new file mode 100644
index 0000000..f7e017e
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/MainPage.xaml.cs
@@ -0,0 +1,24 @@
+namespace Cycle.NET.ToggleDemo
+{
+    public partial class MainPage : ContentPage
+    {
+        int count = 0;
+
+        public MainPage()
+        {
+            InitializeComponent();
+        }
+
+        private void OnCounterClicked(object sender, EventArgs e)
+        {
+            count++;
+
+            if (count == 1)
+                CounterBtn.Text = $"Clicked {count} time";
+            else
+                CounterBtn.Text = $"Clicked {count} times";
+
+            SemanticScreenReader.Announce(CounterBtn.Text);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/MauiProgram.cs b/Cycle.NET.ToggleDemo/MauiProgram.cs
new file mode 100644
index 0000000..5589048
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/MauiProgram.cs
@@ -0,0 +1,25 @@
+using Microsoft.Extensions.Logging;
+
+namespace Cycle.NET.ToggleDemo
+{
+    public static class MauiProgram
+    {
+        public static MauiApp CreateMauiApp()
+        {
+            var builder = MauiApp.CreateBuilder();
+            builder
+                .UseMauiApp<App>()
+                .ConfigureFonts(fonts =>
+                {
+                    fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
+                    fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
+                });
+
+#if DEBUG
+		builder.Logging.AddDebug();
+#endif
+
+            return builder.Build();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/Android/AndroidManifest.xml b/Cycle.NET.ToggleDemo/Platforms/Android/AndroidManifest.xml
new file mode 100644
index 0000000..e9937ad
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/Android/AndroidManifest.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+	<application android:allowBackup="true" android:icon="@mipmap/appicon" android:roundIcon="@mipmap/appicon_round" android:supportsRtl="true"></application>
+	<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+	<uses-permission android:name="android.permission.INTERNET" />
+</manifest>
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/Android/MainActivity.cs b/Cycle.NET.ToggleDemo/Platforms/Android/MainActivity.cs
new file mode 100644
index 0000000..551c556
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/Android/MainActivity.cs
@@ -0,0 +1,11 @@
+using Android.App;
+using Android.Content.PM;
+using Android.OS;
+
+namespace Cycle.NET.ToggleDemo
+{
+    [Activity(Theme = "@style/Maui.SplashTheme", MainLauncher = true, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode | ConfigChanges.ScreenLayout | ConfigChanges.SmallestScreenSize | ConfigChanges.Density)]
+    public class MainActivity : MauiAppCompatActivity
+    {
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/Android/MainApplication.cs b/Cycle.NET.ToggleDemo/Platforms/Android/MainApplication.cs
new file mode 100644
index 0000000..71268ec
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/Android/MainApplication.cs
@@ -0,0 +1,16 @@
+using Android.App;
+using Android.Runtime;
+
+namespace Cycle.NET.ToggleDemo
+{
+    [Application]
+    public class MainApplication : MauiApplication
+    {
+        public MainApplication(IntPtr handle, JniHandleOwnership ownership)
+            : base(handle, ownership)
+        {
+        }
+
+        protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/Android/Resources/values/colors.xml b/Cycle.NET.ToggleDemo/Platforms/Android/Resources/values/colors.xml
new file mode 100644
index 0000000..c04d749
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/Android/Resources/values/colors.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="colorPrimary">#512BD4</color>
+    <color name="colorPrimaryDark">#2B0B98</color>
+    <color name="colorAccent">#2B0B98</color>
+</resources>
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/AppDelegate.cs b/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/AppDelegate.cs
new file mode 100644
index 0000000..35ae98f
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/AppDelegate.cs
@@ -0,0 +1,10 @@
+using Foundation;
+
+namespace Cycle.NET.ToggleDemo
+{
+    [Register("AppDelegate")]
+    public class AppDelegate : MauiUIApplicationDelegate
+    {
+        protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Info.plist b/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Info.plist
new file mode 100644
index 0000000..c96dd0a
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Info.plist
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>UIDeviceFamily</key>
+	<array>
+		<integer>1</integer>
+		<integer>2</integer>
+	</array>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>arm64</string>
+	</array>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>XSAppIconAssets</key>
+	<string>Assets.xcassets/appicon.appiconset</string>
+</dict>
+</plist>
diff --git a/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Program.cs b/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Program.cs
new file mode 100644
index 0000000..8a085b2
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Program.cs
@@ -0,0 +1,16 @@
+using ObjCRuntime;
+using UIKit;
+
+namespace Cycle.NET.ToggleDemo
+{
+    public class Program
+    {
+        // This is the main entry point of the application.
+        static void Main(string[] args)
+        {
+            // if you want to use a different Application Delegate class from "AppDelegate"
+            // you can specify it here.
+            UIApplication.Main(args, null, typeof(AppDelegate));
+        }
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/Tizen/Main.cs b/Cycle.NET.ToggleDemo/Platforms/Tizen/Main.cs
new file mode 100644
index 0000000..232ff56
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/Tizen/Main.cs
@@ -0,0 +1,17 @@
+using System;
+using Microsoft.Maui;
+using Microsoft.Maui.Hosting;
+
+namespace Cycle.NET.ToggleDemo
+{
+    internal class Program : MauiApplication
+    {
+        protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
+
+        static void Main(string[] args)
+        {
+            var app = new Program();
+            app.Run(args);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/Tizen/tizen-manifest.xml b/Cycle.NET.ToggleDemo/Platforms/Tizen/tizen-manifest.xml
new file mode 100644
index 0000000..002f1ca
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/Tizen/tizen-manifest.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="maui-application-id-placeholder" version="0.0.0" api-version="7" xmlns="http://tizen.org/ns/packages">
+  <profile name="common" />
+  <ui-application appid="maui-application-id-placeholder" exec="Cycle.NET.ToggleDemo.dll" multiple="false" nodisplay="false" taskmanage="true" type="dotnet" launch_mode="single">
+    <label>maui-application-title-placeholder</label>
+    <icon>maui-appicon-placeholder</icon>
+    <metadata key="http://tizen.org/metadata/prefer_dotnet_aot" value="true" />
+  </ui-application>
+  <shortcut-list />
+  <privileges>
+    <privilege>http://tizen.org/privilege/internet</privilege>
+  </privileges> 
+  <dependencies />
+  <provides-appdefined-privileges />
+</manifest>
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/Windows/App.xaml b/Cycle.NET.ToggleDemo/Platforms/Windows/App.xaml
new file mode 100644
index 0000000..a2375e1
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/Windows/App.xaml
@@ -0,0 +1,8 @@
+<maui:MauiWinUIApplication
+    x:Class="Cycle.NET.ToggleDemo.WinUI.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:maui="using:Microsoft.Maui"
+    xmlns:local="using:Cycle.NET.ToggleDemo.WinUI">
+
+</maui:MauiWinUIApplication>
diff --git a/Cycle.NET.ToggleDemo/Platforms/Windows/App.xaml.cs b/Cycle.NET.ToggleDemo/Platforms/Windows/App.xaml.cs
new file mode 100644
index 0000000..a2304a5
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/Windows/App.xaml.cs
@@ -0,0 +1,24 @@
+using Microsoft.UI.Xaml;
+
+// To learn more about WinUI, the WinUI project structure,
+// and more about our project templates, see: http://aka.ms/winui-project-info.
+
+namespace Cycle.NET.ToggleDemo.WinUI
+{
+    /// <summary>
+    /// Provides application-specific behavior to supplement the default Application class.
+    /// </summary>
+    public partial class App : MauiWinUIApplication
+    {
+        /// <summary>
+        /// Initializes the singleton application object.  This is the first line of authored code
+        /// executed, and as such is the logical equivalent of main() or WinMain().
+        /// </summary>
+        public App()
+        {
+            this.InitializeComponent();
+        }
+
+        protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/Windows/Package.appxmanifest b/Cycle.NET.ToggleDemo/Platforms/Windows/Package.appxmanifest
new file mode 100644
index 0000000..d6714fd
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/Windows/Package.appxmanifest
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package
+  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
+  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
+  xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
+  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
+  IgnorableNamespaces="uap rescap">
+
+  <Identity Name="maui-package-name-placeholder" Publisher="CN=User Name" Version="0.0.0.0" />
+
+  <mp:PhoneIdentity PhoneProductId="E0B2BA9F-47F9-4F4C-917F-BC40379BED1A" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
+
+  <Properties>
+    <DisplayName>$placeholder$</DisplayName>
+    <PublisherDisplayName>User Name</PublisherDisplayName>
+    <Logo>$placeholder$.png</Logo>
+  </Properties>
+
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.17763.0" MaxVersionTested="10.0.19041.0" />
+    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.19041.0" />
+  </Dependencies>
+
+  <Resources>
+    <Resource Language="x-generate" />
+  </Resources>
+
+  <Applications>
+    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="$targetentrypoint$">
+      <uap:VisualElements
+        DisplayName="$placeholder$"
+        Description="$placeholder$"
+        Square150x150Logo="$placeholder$.png"
+        Square44x44Logo="$placeholder$.png"
+        BackgroundColor="transparent">
+        <uap:DefaultTile Square71x71Logo="$placeholder$.png" Wide310x150Logo="$placeholder$.png" Square310x310Logo="$placeholder$.png" />
+        <uap:SplashScreen Image="$placeholder$.png" />
+      </uap:VisualElements>
+    </Application>
+  </Applications>
+
+  <Capabilities>
+    <rescap:Capability Name="runFullTrust" />
+  </Capabilities>
+
+</Package>
diff --git a/Cycle.NET.ToggleDemo/Platforms/Windows/app.manifest b/Cycle.NET.ToggleDemo/Platforms/Windows/app.manifest
new file mode 100644
index 0000000..95bbeaf
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/Windows/app.manifest
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="1.0.0.0" name="Cycle.NET.ToggleDemo.WinUI.app"/>
+
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <!-- The combination of below two tags have the following effect:
+           1) Per-Monitor for >= Windows 10 Anniversary Update
+           2) System < Windows 10 Anniversary Update
+      -->
+      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/PM</dpiAware>
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2, PerMonitor</dpiAwareness>
+    </windowsSettings>
+  </application>
+</assembly>
diff --git a/Cycle.NET.ToggleDemo/Platforms/iOS/AppDelegate.cs b/Cycle.NET.ToggleDemo/Platforms/iOS/AppDelegate.cs
new file mode 100644
index 0000000..35ae98f
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/iOS/AppDelegate.cs
@@ -0,0 +1,10 @@
+using Foundation;
+
+namespace Cycle.NET.ToggleDemo
+{
+    [Register("AppDelegate")]
+    public class AppDelegate : MauiUIApplicationDelegate
+    {
+        protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Platforms/iOS/Info.plist b/Cycle.NET.ToggleDemo/Platforms/iOS/Info.plist
new file mode 100644
index 0000000..0004a4f
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/iOS/Info.plist
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UIDeviceFamily</key>
+	<array>
+		<integer>1</integer>
+		<integer>2</integer>
+	</array>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>arm64</string>
+	</array>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>XSAppIconAssets</key>
+	<string>Assets.xcassets/appicon.appiconset</string>
+</dict>
+</plist>
diff --git a/Cycle.NET.ToggleDemo/Platforms/iOS/Program.cs b/Cycle.NET.ToggleDemo/Platforms/iOS/Program.cs
new file mode 100644
index 0000000..8a085b2
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Platforms/iOS/Program.cs
@@ -0,0 +1,16 @@
+using ObjCRuntime;
+using UIKit;
+
+namespace Cycle.NET.ToggleDemo
+{
+    public class Program
+    {
+        // This is the main entry point of the application.
+        static void Main(string[] args)
+        {
+            // if you want to use a different Application Delegate class from "AppDelegate"
+            // you can specify it here.
+            UIApplication.Main(args, null, typeof(AppDelegate));
+        }
+    }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Properties/launchSettings.json b/Cycle.NET.ToggleDemo/Properties/launchSettings.json
new file mode 100644
index 0000000..edf8aad
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Properties/launchSettings.json
@@ -0,0 +1,8 @@
+{
+  "profiles": {
+    "Windows Machine": {
+      "commandName": "MsixPackage",
+      "nativeDebugging": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Resources/AppIcon/appicon.svg b/Cycle.NET.ToggleDemo/Resources/AppIcon/appicon.svg
new file mode 100644
index 0000000..9d63b65
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Resources/AppIcon/appicon.svg
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg width="456" height="456" viewBox="0 0 456 456" version="1.1" xmlns="http://www.w3.org/2000/svg">
+    <rect x="0" y="0" width="456" height="456" fill="#512BD4" />
+</svg>
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Resources/AppIcon/appiconfg.svg b/Cycle.NET.ToggleDemo/Resources/AppIcon/appiconfg.svg
new file mode 100644
index 0000000..21dfb25
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Resources/AppIcon/appiconfg.svg
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="456" height="456" viewBox="0 0 456 456" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
+    <path d="m 105.50037,281.60863 c -2.70293,0 -5.00091,-0.90042 -6.893127,-2.70209 -1.892214,-1.84778 -2.837901,-4.04181 -2.837901,-6.58209 0,-2.58722 0.945687,-4.80389 2.837901,-6.65167 1.892217,-1.84778 4.190197,-2.77167 6.893127,-2.77167 2.74819,0 5.06798,0.92389 6.96019,2.77167 1.93749,1.84778 2.90581,4.06445 2.90581,6.65167 0,2.54028 -0.96832,4.73431 -2.90581,6.58209 -1.89221,1.80167 -4.212,2.70209 -6.96019,2.70209 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
+    <path d="M 213.56111,280.08446 H 195.99044 L 149.69953,207.0544 c -1.17121,-1.84778 -2.14037,-3.76515 -2.90581,-5.75126 h -0.40578 c 0.36051,2.12528 0.54076,6.67515 0.54076,13.6496 v 65.13172 h -15.54349 v -99.36009 h 18.71925 l 44.7374,71.29798 c 1.89222,2.95695 3.1087,4.98917 3.64945,6.09751 h 0.26996 c -0.45021,-2.6325 -0.67573,-7.09015 -0.67573,-13.37293 v -64.02256 h 15.47557 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
+    <path d="m 289.25134,280.08446 h -54.40052 v -99.36009 h 52.23835 v 13.99669 h -36.15411 v 28.13085 h 33.31621 v 13.9271 h -33.31621 v 29.37835 h 38.31628 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
+    <path d="M 366.56466,194.72106 H 338.7222 v 85.3634 h -16.08423 v -85.3634 h -27.77455 v -13.99669 h 71.70124 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
+</svg>
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Resources/Fonts/OpenSans-Regular.ttf b/Cycle.NET.ToggleDemo/Resources/Fonts/OpenSans-Regular.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..e248a957a2468879843aba732c915439039cd21d
GIT binary patch
literal 107140
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
MHy!IDX^4XIKi~)<xBvhE

literal 0
HcmV?d00001

diff --git a/Cycle.NET.ToggleDemo/Resources/Fonts/OpenSans-Semibold.ttf b/Cycle.NET.ToggleDemo/Resources/Fonts/OpenSans-Semibold.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..dbc957252e01deb54d2c5c7a5bf4bf5934051b1c
GIT binary patch
literal 111068
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%0DO3
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

literal 0
HcmV?d00001

diff --git a/Cycle.NET.ToggleDemo/Resources/Images/dotnet_bot.svg b/Cycle.NET.ToggleDemo/Resources/Images/dotnet_bot.svg
new file mode 100644
index 0000000..abfaff2
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Resources/Images/dotnet_bot.svg
@@ -0,0 +1,93 @@
+<svg width="419" height="519" viewBox="0 0 419 519" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M284.432 247.568L284.004 221.881C316.359 221.335 340.356 211.735 355.308 193.336C382.408 159.996 372.893 108.183 372.786 107.659L398.013 102.831C398.505 105.432 409.797 167.017 375.237 209.53C355.276 234.093 324.719 246.894 284.432 247.568Z" fill="#8A6FE8"/>
+<path d="M331.954 109.36L361.826 134.245C367.145 138.676 375.055 137.959 379.497 132.639C383.928 127.32 383.211 119.41 377.891 114.969L348.019 90.0842C342.7 85.6531 334.79 86.3702 330.348 91.6896C325.917 97.0197 326.634 104.929 331.954 109.36Z" fill="#8A6FE8"/>
+<path d="M407.175 118.062L417.92 94.2263C420.735 87.858 417.856 80.4087 411.488 77.5831C405.12 74.7682 397.67 77.6473 394.845 84.0156L383.831 108.461L407.175 118.062Z" fill="#8A6FE8"/>
+<path d="M401.363 105.175L401.234 69.117C401.181 62.1493 395.498 56.541 388.53 56.5945C381.562 56.648 375.954 62.3313 376.007 69.2989L376.018 96.11L401.363 105.175Z" fill="#8A6FE8"/>
+<path d="M386.453 109.071L378.137 73.9548C376.543 67.169 369.757 62.9628 362.971 64.5575C356.185 66.1523 351.979 72.938 353.574 79.7237L362.04 115.482L386.453 109.071Z" fill="#8A6FE8"/>
+<path d="M381.776 142.261C396.359 142.261 408.181 130.44 408.181 115.857C408.181 101.274 396.359 89.4527 381.776 89.4527C367.194 89.4527 355.372 101.274 355.372 115.857C355.372 130.44 367.194 142.261 381.776 142.261Z" fill="url(#paint0_radial)"/>
+<path d="M248.267 406.979C248.513 384.727 245.345 339.561 222.376 301.736L199.922 315.372C220.76 349.675 222.323 389.715 221.841 407.182C221.798 408.627 235.263 409.933 248.267 406.979Z" fill="url(#paint1_linear)"/>
+<path d="M221.841 406.936L242.637 406.84L262.052 518.065L220.311 518.258C217.132 518.269 214.724 515.711 214.938 512.532L221.841 406.936Z" fill="#522CD5"/>
+<path d="M306.566 488.814C310.173 491.661 310.109 495.782 309.831 500.127L308.964 513.452C308.803 515.839 306.727 517.798 304.34 517.809L260.832 518.012C258.125 518.023 256.08 515.839 256.262 513.142L256.551 499.335C256.883 494.315 255.192 492.474 251.307 487.744C244.649 479.663 224.967 435.62 226.84 406.925L248.256 406.829C249.691 423.858 272.167 461.682 306.566 488.814Z" fill="url(#paint2_linear)"/>
+<path d="M309.82 500.127C310.023 497.088 310.077 494.176 308.889 491.715L254.635 491.961C256.134 494.166 256.765 496.092 256.562 499.314L256.273 513.121C256.091 515.828 258.146 518.012 260.843 517.99L304.34 517.798C306.727 517.787 308.803 515.828 308.964 513.442L309.82 500.127Z" fill="url(#paint3_radial)"/>
+<path d="M133.552 407.471C133.103 385.22 135.864 340.021 158.49 301.993L181.073 315.425C160.545 349.921 159.346 389.972 159.989 407.428C160.042 408.884 146.578 410.318 133.552 407.471Z" fill="url(#paint4_linear)"/>
+<path d="M110.798 497.152C110.765 494.187 111.204 491.575 112.457 487.23C131.882 434.132 133.52 407.364 133.52 407.364L159.999 407.246C159.999 407.246 161.819 433.512 181.716 486.427C183.289 490.195 183.471 493.641 183.674 496.831L183.792 513.816C183.803 516.374 181.716 518.483 179.158 518.494L177.873 518.504L116.781 518.782L115.496 518.793C112.927 518.804 110.83 516.728 110.819 514.159L110.798 497.152Z" fill="url(#paint5_linear)"/>
+<path d="M110.798 497.152C110.798 496.67 110.808 496.199 110.83 495.739C110.969 494.262 111.643 492.603 114.875 492.582L180.207 492.282C182.561 492.367 183.343 494.176 183.589 495.311C183.621 495.814 183.664 496.328 183.696 496.82L183.813 513.806C183.824 515.411 183.011 516.824 181.769 517.669C181.031 518.172 180.132 518.472 179.179 518.483L177.895 518.494L116.802 518.772L115.528 518.782C114.244 518.793 113.077 518.269 112.232 517.434C111.386 516.599 110.862 515.432 110.851 514.148L110.798 497.152Z" fill="url(#paint6_radial)"/>
+<path d="M314.979 246.348C324.162 210.407 318.008 181.777 318.008 181.777L326.452 181.734L326.656 181.574C314.262 115.75 256.326 66.0987 186.949 66.4198C108.796 66.773 45.7233 130.424 46.0765 208.577C46.4297 286.731 110.08 349.803 188.234 349.45C249.905 349.172 302.178 309.474 321.304 254.343C321.872 251.999 321.797 247.804 314.979 246.348Z" fill="url(#paint7_radial)"/>
+<path d="M310.237 279.035L65.877 280.148C71.3998 289.428 77.95 298.012 85.3672 305.761L290.972 304.829C298.336 297.005 304.8 288.368 310.237 279.035Z" fill="#D8CFF7"/>
+<path d="M235.062 312.794L280.924 312.585L280.74 272.021L234.877 272.23L235.062 312.794Z" fill="#512BD4"/>
+<path d="M243.001 297.626C242.691 297.626 242.434 297.53 242.22 297.327C242.006 297.123 241.899 296.866 241.899 296.588C241.899 296.299 242.006 296.042 242.22 295.839C242.434 295.625 242.691 295.528 243.001 295.528C243.312 295.528 243.568 295.635 243.782 295.839C243.996 296.042 244.114 296.299 244.114 296.588C244.114 296.877 244.007 297.123 243.793 297.327C243.568 297.519 243.312 297.626 243.001 297.626Z" fill="white"/>
+<path d="M255.192 297.434H253.212L247.967 289.203C247.839 289 247.721 288.775 247.636 288.55H247.593C247.636 288.786 247.657 289.299 247.657 290.091L247.668 297.444H245.912L245.891 286.228H247.999L253.062 294.265C253.276 294.597 253.415 294.833 253.479 294.95H253.511C253.458 294.651 253.437 294.148 253.437 293.441L253.426 286.217H255.17L255.192 297.434Z" fill="white"/>
+<path d="M263.733 297.412L257.589 297.423L257.568 286.206L263.465 286.195V287.779L259.387 287.79L259.398 290.969L263.155 290.958V292.532L259.398 292.542L259.409 295.86L263.733 295.85V297.412Z" fill="white"/>
+<path d="M272.445 287.758L269.298 287.769L269.32 297.401H267.5L267.479 287.769L264.343 287.779V286.195L272.434 286.174L272.445 287.758Z" fill="white"/>
+<path d="M315.279 246.337C324.355 210.836 318.457 182.483 318.308 181.798L171.484 182.462C171.484 182.462 162.226 181.563 162.268 190.018C162.311 198.463 162.761 222.341 162.878 248.746C162.9 254.172 167.363 256.773 170.863 256.751C170.874 256.751 311.618 252.213 315.279 246.337Z" fill="url(#paint8_radial)"/>
+<path d="M227.685 246.798C227.685 246.798 250.183 228.827 254.571 225.499C258.959 222.17 262.812 221.977 266.869 225.445C270.925 228.913 293.616 246.498 293.616 246.498L227.685 246.798Z" fill="#A08BE8"/>
+<path d="M320.748 256.141C320.748 256.141 324.943 248.414 315.279 246.348C315.289 246.305 170.927 246.894 170.927 246.894C167.566 246.905 163.232 244.925 162.846 241.671C162.857 244.004 162.878 246.369 162.889 248.756C162.91 253.68 166.582 256.27 169.878 256.698C170.21 256.73 170.542 256.773 170.874 256.773L180.742 256.73L320.748 256.141Z" fill="#512BD4"/>
+<path d="M206.4 233.214C212.511 233.095 217.302 224.667 217.102 214.39C216.901 204.112 211.785 195.878 205.674 195.997C199.563 196.116 194.772 204.544 194.973 214.821C195.173 225.099 200.289 233.333 206.4 233.214Z" fill="#512BD4"/>
+<path d="M306.249 214.267C306.356 203.989 301.488 195.605 295.377 195.541C289.266 195.478 284.225 203.758 284.118 214.037C284.011 224.315 288.878 232.699 294.99 232.763C301.101 232.826 306.142 224.545 306.249 214.267Z" fill="#512BD4"/>
+<path d="M205.905 205.291C208.152 203.022 211.192 202.016 214.157 202.262C215.912 205.495 217.014 209.733 217.111 214.389C217.164 217.3 216.811 220.04 216.158 222.513C212.669 223.519 208.752 222.662 205.979 219.922C201.912 215.909 201.88 209.348 205.905 205.291Z" fill="#8065E0"/>
+<path d="M294.996 204.285C297.255 202.016 300.294 200.999 303.259 201.256C305.164 204.628 306.309 209.209 306.256 214.239C306.224 216.808 305.892 219.259 305.303 221.485C301.793 222.523 297.843 221.678 295.061 218.916C291.004 214.892 290.972 208.342 294.996 204.285Z" fill="#8065E0"/>
+<path d="M11.6342 357.017C10.9171 354.716 -5.72611 300.141 21.3204 258.903C36.9468 235.078 63.3083 221.035 99.6664 217.15L102.449 243.276C74.3431 246.273 54.4676 256.345 43.3579 273.202C23.0971 303.941 36.5722 348.733 36.7113 349.183L11.6342 357.017Z" fill="url(#paint9_linear)"/>
+<path d="M95.1498 252.802C109.502 252.802 121.137 241.167 121.137 226.815C121.137 212.463 109.502 200.828 95.1498 200.828C80.7976 200.828 69.1628 212.463 69.1628 226.815C69.1628 241.167 80.7976 252.802 95.1498 252.802Z" fill="url(#paint10_radial)"/>
+<path d="M72.0098 334.434L33.4683 329.307C26.597 328.397 20.2929 333.214 19.3725 340.085C18.4627 346.956 23.279 353.26 30.1504 354.181L68.6919 359.308C75.5632 360.217 81.8673 355.401 82.7878 348.53C83.6975 341.658 78.8705 335.344 72.0098 334.434Z" fill="#8A6FE8"/>
+<path d="M3.73535 367.185L7.35297 393.076C8.36975 399.968 14.7702 404.731 21.6629 403.725C28.5556 402.708 33.3185 396.308 32.3124 389.415L28.5984 362.861L3.73535 367.185Z" fill="#8A6FE8"/>
+<path d="M15.5194 374.988L34.849 405.427C38.6058 411.292 46.4082 413.005 52.2735 409.248C58.1387 405.491 59.8512 397.689 56.0945 391.823L41.7953 369.144L15.5194 374.988Z" fill="#8A6FE8"/>
+<path d="M26.0511 363.739L51.8026 389.019C56.7688 393.911 64.7532 393.846 69.6445 388.88C74.5358 383.914 74.4715 375.929 69.516 371.038L43.2937 345.297L26.0511 363.739Z" fill="#8A6FE8"/>
+<path d="M26.4043 381.912C40.987 381.912 52.8086 370.091 52.8086 355.508C52.8086 340.925 40.987 329.104 26.4043 329.104C11.8216 329.104 0 340.925 0 355.508C0 370.091 11.8216 381.912 26.4043 381.912Z" fill="url(#paint11_radial)"/>
+<path d="M184.73 63.6308L157.819 66.5892L158.561 38.5412L177.888 36.4178L184.73 63.6308Z" fill="#8A6FE8"/>
+<path d="M170.018 41.647C180.455 39.521 187.193 29.3363 185.067 18.8988C182.941 8.46126 172.757 1.72345 162.319 3.84944C151.882 5.97543 145.144 16.1601 147.27 26.5976C149.396 37.0351 159.58 43.773 170.018 41.647Z" fill="#D8CFF7"/>
+<path d="M196.885 79.385C198.102 79.2464 198.948 78.091 198.684 76.8997C195.851 64.2818 183.923 55.5375 170.773 56.9926C157.622 58.4371 147.886 69.5735 147.865 82.4995C147.863 83.7232 148.949 84.6597 150.168 84.5316L196.885 79.385Z" fill="url(#paint12_radial)"/>
+<defs>
+<radialGradient id="paint0_radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(382.004 103.457) scale(26.4058)">
+<stop stop-color="#8065E0"/>
+<stop offset="1" stop-color="#512BD4"/>
+</radialGradient>
+<linearGradient id="paint1_linear" x1="214.439" y1="303.482" x2="236.702" y2="409.505" gradientUnits="userSpaceOnUse">
+<stop stop-color="#522CD5"/>
+<stop offset="0.4397" stop-color="#8A6FE8"/>
+</linearGradient>
+<linearGradient id="paint2_linear" x1="231.673" y1="404.144" x2="297.805" y2="522.048" gradientUnits="userSpaceOnUse">
+<stop stop-color="#522CD5"/>
+<stop offset="0.4397" stop-color="#8A6FE8"/>
+</linearGradient>
+<radialGradient id="paint3_radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(280.957 469.555) rotate(-0.260742) scale(45.8326)">
+<stop offset="0.034" stop-color="#522CD5"/>
+<stop offset="0.9955" stop-color="#8A6FE8"/>
+</radialGradient>
+<linearGradient id="paint4_linear" x1="166.061" y1="303.491" x2="144.763" y2="409.709" gradientUnits="userSpaceOnUse">
+<stop stop-color="#522CD5"/>
+<stop offset="0.4397" stop-color="#8A6FE8"/>
+</linearGradient>
+<linearGradient id="paint5_linear" x1="146.739" y1="407.302" x2="147.246" y2="518.627" gradientUnits="userSpaceOnUse">
+<stop stop-color="#522CD5"/>
+<stop offset="0.4397" stop-color="#8A6FE8"/>
+</linearGradient>
+<radialGradient id="paint6_radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(148.63 470.023) rotate(179.739) scale(50.2476)">
+<stop offset="0.034" stop-color="#522CD5"/>
+<stop offset="0.9955" stop-color="#8A6FE8"/>
+</radialGradient>
+<radialGradient id="paint7_radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(219.219 153.929) rotate(179.739) scale(140.935)">
+<stop offset="0.4744" stop-color="#A08BE8"/>
+<stop offset="0.8618" stop-color="#8065E0"/>
+</radialGradient>
+<radialGradient id="paint8_radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(314.861 158.738) rotate(179.739) scale(146.053)">
+<stop offset="0.0933" stop-color="#E1DFDD"/>
+<stop offset="0.6573" stop-color="white"/>
+</radialGradient>
+<linearGradient id="paint9_linear" x1="54.1846" y1="217.159" x2="54.1846" y2="357.022" gradientUnits="userSpaceOnUse">
+<stop offset="0.3344" stop-color="#9780E6"/>
+<stop offset="0.8488" stop-color="#8A6FE8"/>
+</linearGradient>
+<radialGradient id="paint10_radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(90.3494 218.071) rotate(-0.260742) scale(25.9924)">
+<stop stop-color="#8065E0"/>
+<stop offset="1" stop-color="#512BD4"/>
+</radialGradient>
+<radialGradient id="paint11_radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(25.805 345.043) scale(26.4106)">
+<stop stop-color="#8065E0"/>
+<stop offset="1" stop-color="#512BD4"/>
+</radialGradient>
+<radialGradient id="paint12_radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(169.113 67.3662) rotate(-32.2025) scale(21.0773)">
+<stop stop-color="#8065E0"/>
+<stop offset="1" stop-color="#512BD4"/>
+</radialGradient>
+</defs>
+</svg>
diff --git a/Cycle.NET.ToggleDemo/Resources/Raw/AboutAssets.txt b/Cycle.NET.ToggleDemo/Resources/Raw/AboutAssets.txt
new file mode 100644
index 0000000..15d6244
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Resources/Raw/AboutAssets.txt
@@ -0,0 +1,15 @@
+Any raw assets you want to be deployed with your application can be placed in
+this directory (and child directories). Deployment of the asset to your application
+is automatically handled by the following `MauiAsset` Build Action within your `.csproj`.
+
+	<MauiAsset Include="Resources\Raw\**" LogicalName="%(RecursiveDir)%(Filename)%(Extension)" />
+
+These files will be deployed with you package and will be accessible using Essentials:
+
+	async Task LoadMauiAsset()
+	{
+		using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
+		using var reader = new StreamReader(stream);
+
+		var contents = reader.ReadToEnd();
+	}
diff --git a/Cycle.NET.ToggleDemo/Resources/Splash/splash.svg b/Cycle.NET.ToggleDemo/Resources/Splash/splash.svg
new file mode 100644
index 0000000..21dfb25
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Resources/Splash/splash.svg
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="456" height="456" viewBox="0 0 456 456" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
+    <path d="m 105.50037,281.60863 c -2.70293,0 -5.00091,-0.90042 -6.893127,-2.70209 -1.892214,-1.84778 -2.837901,-4.04181 -2.837901,-6.58209 0,-2.58722 0.945687,-4.80389 2.837901,-6.65167 1.892217,-1.84778 4.190197,-2.77167 6.893127,-2.77167 2.74819,0 5.06798,0.92389 6.96019,2.77167 1.93749,1.84778 2.90581,4.06445 2.90581,6.65167 0,2.54028 -0.96832,4.73431 -2.90581,6.58209 -1.89221,1.80167 -4.212,2.70209 -6.96019,2.70209 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
+    <path d="M 213.56111,280.08446 H 195.99044 L 149.69953,207.0544 c -1.17121,-1.84778 -2.14037,-3.76515 -2.90581,-5.75126 h -0.40578 c 0.36051,2.12528 0.54076,6.67515 0.54076,13.6496 v 65.13172 h -15.54349 v -99.36009 h 18.71925 l 44.7374,71.29798 c 1.89222,2.95695 3.1087,4.98917 3.64945,6.09751 h 0.26996 c -0.45021,-2.6325 -0.67573,-7.09015 -0.67573,-13.37293 v -64.02256 h 15.47557 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
+    <path d="m 289.25134,280.08446 h -54.40052 v -99.36009 h 52.23835 v 13.99669 h -36.15411 v 28.13085 h 33.31621 v 13.9271 h -33.31621 v 29.37835 h 38.31628 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
+    <path d="M 366.56466,194.72106 H 338.7222 v 85.3634 h -16.08423 v -85.3634 h -27.77455 v -13.99669 h 71.70124 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
+</svg>
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Resources/Styles/Colors.xaml b/Cycle.NET.ToggleDemo/Resources/Styles/Colors.xaml
new file mode 100644
index 0000000..245758b
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Resources/Styles/Colors.xaml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<?xaml-comp compile="true" ?>
+<ResourceDictionary 
+    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
+
+    <Color x:Key="Primary">#512BD4</Color>
+    <Color x:Key="Secondary">#DFD8F7</Color>
+    <Color x:Key="Tertiary">#2B0B98</Color>
+    <Color x:Key="White">White</Color>
+    <Color x:Key="Black">Black</Color>
+    <Color x:Key="Gray100">#E1E1E1</Color>
+    <Color x:Key="Gray200">#C8C8C8</Color>
+    <Color x:Key="Gray300">#ACACAC</Color>
+    <Color x:Key="Gray400">#919191</Color>
+    <Color x:Key="Gray500">#6E6E6E</Color>
+    <Color x:Key="Gray600">#404040</Color>
+    <Color x:Key="Gray900">#212121</Color>
+    <Color x:Key="Gray950">#141414</Color>
+    <SolidColorBrush x:Key="PrimaryBrush" Color="{StaticResource Primary}"/>
+    <SolidColorBrush x:Key="SecondaryBrush" Color="{StaticResource Secondary}"/>
+    <SolidColorBrush x:Key="TertiaryBrush" Color="{StaticResource Tertiary}"/>
+    <SolidColorBrush x:Key="WhiteBrush" Color="{StaticResource White}"/>
+    <SolidColorBrush x:Key="BlackBrush" Color="{StaticResource Black}"/>
+    <SolidColorBrush x:Key="Gray100Brush" Color="{StaticResource Gray100}"/>
+    <SolidColorBrush x:Key="Gray200Brush" Color="{StaticResource Gray200}"/>
+    <SolidColorBrush x:Key="Gray300Brush" Color="{StaticResource Gray300}"/>
+    <SolidColorBrush x:Key="Gray400Brush" Color="{StaticResource Gray400}"/>
+    <SolidColorBrush x:Key="Gray500Brush" Color="{StaticResource Gray500}"/>
+    <SolidColorBrush x:Key="Gray600Brush" Color="{StaticResource Gray600}"/>
+    <SolidColorBrush x:Key="Gray900Brush" Color="{StaticResource Gray900}"/>
+    <SolidColorBrush x:Key="Gray950Brush" Color="{StaticResource Gray950}"/>
+
+    <Color x:Key="Yellow100Accent">#F7B548</Color>
+    <Color x:Key="Yellow200Accent">#FFD590</Color>
+    <Color x:Key="Yellow300Accent">#FFE5B9</Color>
+    <Color x:Key="Cyan100Accent">#28C2D1</Color>
+    <Color x:Key="Cyan200Accent">#7BDDEF</Color>
+    <Color x:Key="Cyan300Accent">#C3F2F4</Color>
+    <Color x:Key="Blue100Accent">#3E8EED</Color>
+    <Color x:Key="Blue200Accent">#72ACF1</Color>
+    <Color x:Key="Blue300Accent">#A7CBF6</Color>
+
+</ResourceDictionary>
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Resources/Styles/Styles.xaml b/Cycle.NET.ToggleDemo/Resources/Styles/Styles.xaml
new file mode 100644
index 0000000..dc4a034
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Resources/Styles/Styles.xaml
@@ -0,0 +1,405 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<?xaml-comp compile="true" ?>
+<ResourceDictionary 
+    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
+
+    <Style TargetType="ActivityIndicator">
+        <Setter Property="Color" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+    </Style>
+
+    <Style TargetType="IndicatorView">
+        <Setter Property="IndicatorColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray500}}"/>
+        <Setter Property="SelectedIndicatorColor" Value="{AppThemeBinding Light={StaticResource Gray950}, Dark={StaticResource Gray100}}"/>
+    </Style>
+
+    <Style TargetType="Border">
+        <Setter Property="Stroke" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray500}}" />
+        <Setter Property="StrokeShape" Value="Rectangle"/>
+        <Setter Property="StrokeThickness" Value="1"/>
+    </Style>
+
+    <Style TargetType="BoxView">
+        <Setter Property="Color" Value="{AppThemeBinding Light={StaticResource Gray950}, Dark={StaticResource Gray200}}" />
+    </Style>
+
+    <Style TargetType="Button">
+        <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource White}, Dark={StaticResource Primary}}" />
+        <Setter Property="BackgroundColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+        <Setter Property="FontFamily" Value="OpenSansRegular"/>
+        <Setter Property="FontSize" Value="14"/>
+        <Setter Property="CornerRadius" Value="8"/>
+        <Setter Property="Padding" Value="14,10"/>
+        <Setter Property="MinimumHeightRequest" Value="44"/>
+        <Setter Property="MinimumWidthRequest" Value="44"/>
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray950}, Dark={StaticResource Gray200}}" />
+                            <Setter Property="BackgroundColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="CheckBox">
+        <Setter Property="Color" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+        <Setter Property="MinimumHeightRequest" Value="44"/>
+        <Setter Property="MinimumWidthRequest" Value="44"/>
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="Color" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="DatePicker">
+        <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray900}, Dark={StaticResource White}}" />
+        <Setter Property="BackgroundColor" Value="Transparent" />
+        <Setter Property="FontFamily" Value="OpenSansRegular"/>
+        <Setter Property="FontSize" Value="14"/>
+        <Setter Property="MinimumHeightRequest" Value="44"/>
+        <Setter Property="MinimumWidthRequest" Value="44"/>
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray500}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="Editor">
+        <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Black}, Dark={StaticResource White}}" />
+        <Setter Property="BackgroundColor" Value="Transparent" />
+        <Setter Property="FontFamily" Value="OpenSansRegular"/>
+        <Setter Property="FontSize" Value="14" />
+        <Setter Property="PlaceholderColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray500}}" />
+        <Setter Property="MinimumHeightRequest" Value="44"/>
+        <Setter Property="MinimumWidthRequest" Value="44"/>
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="Entry">
+        <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Black}, Dark={StaticResource White}}" />
+        <Setter Property="BackgroundColor" Value="Transparent" />
+        <Setter Property="FontFamily" Value="OpenSansRegular"/>
+        <Setter Property="FontSize" Value="14" />
+        <Setter Property="PlaceholderColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray500}}" />
+        <Setter Property="MinimumHeightRequest" Value="44"/>
+        <Setter Property="MinimumWidthRequest" Value="44"/>
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="Frame">
+        <Setter Property="HasShadow" Value="False" />
+        <Setter Property="BorderColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray950}}" />
+        <Setter Property="CornerRadius" Value="8" />
+    </Style>
+
+    <Style TargetType="ImageButton">
+        <Setter Property="Opacity" Value="1" />
+        <Setter Property="BorderColor" Value="Transparent"/>
+        <Setter Property="BorderWidth" Value="0"/>
+        <Setter Property="CornerRadius" Value="0"/>
+        <Setter Property="MinimumHeightRequest" Value="44"/>
+        <Setter Property="MinimumWidthRequest" Value="44"/>
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="Opacity" Value="0.5" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="Label">
+        <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray900}, Dark={StaticResource White}}" />
+        <Setter Property="BackgroundColor" Value="Transparent" />
+        <Setter Property="FontFamily" Value="OpenSansRegular" />
+        <Setter Property="FontSize" Value="14" />
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="ListView">
+        <Setter Property="SeparatorColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray500}}" />
+        <Setter Property="RefreshControlColor" Value="{AppThemeBinding Light={StaticResource Gray900}, Dark={StaticResource Gray200}}" />
+    </Style>
+
+    <Style TargetType="Picker">
+        <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray900}, Dark={StaticResource White}}" />
+        <Setter Property="TitleColor" Value="{AppThemeBinding Light={StaticResource Gray900}, Dark={StaticResource Gray200}}" />
+        <Setter Property="BackgroundColor" Value="Transparent" />
+        <Setter Property="FontFamily" Value="OpenSansRegular"/>
+        <Setter Property="FontSize" Value="14"/>
+        <Setter Property="MinimumHeightRequest" Value="44"/>
+        <Setter Property="MinimumWidthRequest" Value="44"/>
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                            <Setter Property="TitleColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="ProgressBar">
+        <Setter Property="ProgressColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="ProgressColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="RadioButton">
+        <Setter Property="BackgroundColor" Value="Transparent"/>
+        <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Black}, Dark={StaticResource White}}" />
+        <Setter Property="FontFamily" Value="OpenSansRegular"/>
+        <Setter Property="FontSize" Value="14"/>
+        <Setter Property="MinimumHeightRequest" Value="44"/>
+        <Setter Property="MinimumWidthRequest" Value="44"/>
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="RefreshView">
+        <Setter Property="RefreshColor" Value="{AppThemeBinding Light={StaticResource Gray900}, Dark={StaticResource Gray200}}" />
+    </Style>
+
+    <Style TargetType="SearchBar">
+        <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray900}, Dark={StaticResource White}}" />
+        <Setter Property="PlaceholderColor" Value="{StaticResource Gray500}" />
+        <Setter Property="CancelButtonColor" Value="{StaticResource Gray500}" />
+        <Setter Property="BackgroundColor" Value="Transparent" />
+        <Setter Property="FontFamily" Value="OpenSansRegular" />
+        <Setter Property="FontSize" Value="14" />
+        <Setter Property="MinimumHeightRequest" Value="44"/>
+        <Setter Property="MinimumWidthRequest" Value="44"/>
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                            <Setter Property="PlaceholderColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="SearchHandler">
+        <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray900}, Dark={StaticResource White}}" />
+        <Setter Property="PlaceholderColor" Value="{StaticResource Gray500}" />
+        <Setter Property="BackgroundColor" Value="Transparent" />
+        <Setter Property="FontFamily" Value="OpenSansRegular" />
+        <Setter Property="FontSize" Value="14" />
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                            <Setter Property="PlaceholderColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="Shadow">
+        <Setter Property="Radius" Value="15" />
+        <Setter Property="Opacity" Value="0.5" />
+        <Setter Property="Brush" Value="{AppThemeBinding Light={StaticResource White}, Dark={StaticResource White}}" />
+        <Setter Property="Offset" Value="10,10" />
+    </Style>
+
+    <Style TargetType="Slider">
+        <Setter Property="MinimumTrackColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+        <Setter Property="MaximumTrackColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray600}}" />
+        <Setter Property="ThumbColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="MinimumTrackColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}"/>
+                            <Setter Property="MaximumTrackColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}"/>
+                            <Setter Property="ThumbColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}"/>
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="SwipeItem">
+        <Setter Property="BackgroundColor" Value="{AppThemeBinding Light={StaticResource White}, Dark={StaticResource Black}}" />
+    </Style>
+
+    <Style TargetType="Switch">
+        <Setter Property="OnColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+        <Setter Property="ThumbColor" Value="{StaticResource White}" />
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="OnColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                            <Setter Property="ThumbColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                    <VisualState x:Name="On">
+                        <VisualState.Setters>
+                            <Setter Property="OnColor" Value="{AppThemeBinding Light={StaticResource Secondary}, Dark={StaticResource Gray200}}" />
+                            <Setter Property="ThumbColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                    <VisualState x:Name="Off">
+                        <VisualState.Setters>
+                            <Setter Property="ThumbColor" Value="{AppThemeBinding Light={StaticResource Gray400}, Dark={StaticResource Gray500}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="TimePicker">
+        <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray900}, Dark={StaticResource White}}" />
+        <Setter Property="BackgroundColor" Value="Transparent"/>
+        <Setter Property="FontFamily" Value="OpenSansRegular"/>
+        <Setter Property="FontSize" Value="14"/>
+        <Setter Property="MinimumHeightRequest" Value="44"/>
+        <Setter Property="MinimumWidthRequest" Value="44"/>
+        <Setter Property="VisualStateManager.VisualStateGroups">
+            <VisualStateGroupList>
+                <VisualStateGroup x:Name="CommonStates">
+                    <VisualState x:Name="Normal" />
+                    <VisualState x:Name="Disabled">
+                        <VisualState.Setters>
+                            <Setter Property="TextColor" Value="{AppThemeBinding Light={StaticResource Gray300}, Dark={StaticResource Gray600}}" />
+                        </VisualState.Setters>
+                    </VisualState>
+                </VisualStateGroup>
+            </VisualStateGroupList>
+        </Setter>
+    </Style>
+
+    <Style TargetType="Page" ApplyToDerivedTypes="True">
+        <Setter Property="Padding" Value="0"/>
+        <Setter Property="BackgroundColor" Value="{AppThemeBinding Light={StaticResource White}, Dark={StaticResource Black}}" />
+    </Style>
+
+    <Style TargetType="Shell" ApplyToDerivedTypes="True">
+        <Setter Property="Shell.BackgroundColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource Gray950}}" />
+        <Setter Property="Shell.ForegroundColor" Value="{OnPlatform WinUI={StaticResource Primary}, Default={StaticResource White}}" />
+        <Setter Property="Shell.TitleColor" Value="{AppThemeBinding Light={StaticResource White}, Dark={StaticResource White}}" />
+        <Setter Property="Shell.DisabledColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray950}}" />
+        <Setter Property="Shell.UnselectedColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray200}}" />
+        <Setter Property="Shell.NavBarHasShadow" Value="False" />
+        <Setter Property="Shell.TabBarBackgroundColor" Value="{AppThemeBinding Light={StaticResource White}, Dark={StaticResource Black}}" />
+        <Setter Property="Shell.TabBarForegroundColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+        <Setter Property="Shell.TabBarTitleColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+        <Setter Property="Shell.TabBarUnselectedColor" Value="{AppThemeBinding Light={StaticResource Gray900}, Dark={StaticResource Gray200}}" />
+    </Style>
+
+    <Style TargetType="NavigationPage">
+        <Setter Property="BarBackgroundColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource Gray950}}" />
+        <Setter Property="BarTextColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource White}}" />
+        <Setter Property="IconColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource White}}" />
+    </Style>
+
+    <Style TargetType="TabbedPage">
+        <Setter Property="BarBackgroundColor" Value="{AppThemeBinding Light={StaticResource White}, Dark={StaticResource Gray950}}" />
+        <Setter Property="BarTextColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource White}}" />
+        <Setter Property="UnselectedTabColor" Value="{AppThemeBinding Light={StaticResource Gray200}, Dark={StaticResource Gray950}}" />
+        <Setter Property="SelectedTabColor" Value="{AppThemeBinding Light={StaticResource Gray950}, Dark={StaticResource Gray200}}" />
+    </Style>
+
+</ResourceDictionary>
diff --git a/Cycle.NET.sln b/Cycle.NET.sln
index 4463e49..005cafc 100644
--- a/Cycle.NET.sln
+++ b/Cycle.NET.sln
@@ -7,7 +7,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Cycle.NET", "Cycle.NET\Cycl
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Cycle.NET.Demo", "Cycle.NET.Demo\Cycle.NET.Demo.csproj", "{E0B049E9-C963-4627-872B-56F6BCE5728C}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Cycle.NET.UnionDemo", "Cycle.NET.UnionDemo\Cycle.NET.UnionDemo.csproj", "{65F17018-1196-4153-A2D4-9711768A030B}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Cycle.NET.UnionDemo", "Cycle.NET.UnionDemo\Cycle.NET.UnionDemo.csproj", "{65F17018-1196-4153-A2D4-9711768A030B}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Cycle.NET.ToggleDemo", "Cycle.NET.ToggleDemo\Cycle.NET.ToggleDemo.csproj", "{17CB7110-4CB9-48DA-B31D-7ED8E8EF0660}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -27,6 +29,12 @@ Global
 		{65F17018-1196-4153-A2D4-9711768A030B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{65F17018-1196-4153-A2D4-9711768A030B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{65F17018-1196-4153-A2D4-9711768A030B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{17CB7110-4CB9-48DA-B31D-7ED8E8EF0660}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{17CB7110-4CB9-48DA-B31D-7ED8E8EF0660}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{17CB7110-4CB9-48DA-B31D-7ED8E8EF0660}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{17CB7110-4CB9-48DA-B31D-7ED8E8EF0660}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{17CB7110-4CB9-48DA-B31D-7ED8E8EF0660}.Release|Any CPU.Build.0 = Release|Any CPU
+		{17CB7110-4CB9-48DA-B31D-7ED8E8EF0660}.Release|Any CPU.Deploy.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

From 3f7c7c8200960168956d7b2316c8a6cfb67ac497 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Fri, 5 May 2023 17:22:51 -0400
Subject: [PATCH 40/42] Target .NET 6.0

---
 Cycle.NET.Demo/Cycle.NET.Demo.csproj             |  4 ++--
 Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj | 13 +++++++------
 Cycle.NET.ToggleDemo/MauiProgram.cs              |  4 ----
 Cycle.NET.UnionDemo/Cycle.NET.UnionDemo.csproj   |  4 ++--
 Cycle.NET/Cycle.NET.csproj                       |  4 ++--
 5 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/Cycle.NET.Demo/Cycle.NET.Demo.csproj b/Cycle.NET.Demo/Cycle.NET.Demo.csproj
index 6ac46b6..fd1486f 100644
--- a/Cycle.NET.Demo/Cycle.NET.Demo.csproj
+++ b/Cycle.NET.Demo/Cycle.NET.Demo.csproj
@@ -2,11 +2,11 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.0" />
+    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj b/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
index a2765a8..a9af22f 100644
--- a/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
+++ b/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<TargetFrameworks>net7.0-android;net7.0-ios;net7.0-maccatalyst</TargetFrameworks>
-		<TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">$(TargetFrameworks);net7.0-windows10.0.19041.0</TargetFrameworks>
+		<TargetFrameworks>net6.0-android;net6.0-ios;net6.0-maccatalyst</TargetFrameworks>
+		<TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">$(TargetFrameworks);net6.0-windows10.0.19041.0</TargetFrameworks>
 		<!-- Uncomment to also build the tizen app. You will need to install tizen by following this: https://github.com/Samsung/Tizen.NET -->
-		<!-- <TargetFrameworks>$(TargetFrameworks);net7.0-tizen</TargetFrameworks> -->
+		<!-- <TargetFrameworks>$(TargetFrameworks);net6.0-tizen</TargetFrameworks> -->
 		<OutputType>Exe</OutputType>
 		<RootNamespace>Cycle.NET.ToggleDemo</RootNamespace>
 		<UseMaui>true</UseMaui>
@@ -22,8 +22,8 @@
 		<ApplicationDisplayVersion>1.0</ApplicationDisplayVersion>
 		<ApplicationVersion>1</ApplicationVersion>
 
-		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'ios'">11.0</SupportedOSPlatformVersion>
-		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'maccatalyst'">13.1</SupportedOSPlatformVersion>
+		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'ios'">14.2</SupportedOSPlatformVersion>
+		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'maccatalyst'">14.0</SupportedOSPlatformVersion>
 		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">21.0</SupportedOSPlatformVersion>
 		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">10.0.17763.0</SupportedOSPlatformVersion>
 		<TargetPlatformMinVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">10.0.17763.0</TargetPlatformMinVersion>
@@ -49,7 +49,8 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="7.0.0" />
+		<PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.22621.755" />
+		<PackageReference Include="ReactiveUI.Maui" Version="18.4.20" />
 	</ItemGroup>
 
 </Project>
diff --git a/Cycle.NET.ToggleDemo/MauiProgram.cs b/Cycle.NET.ToggleDemo/MauiProgram.cs
index 5589048..98c40f7 100644
--- a/Cycle.NET.ToggleDemo/MauiProgram.cs
+++ b/Cycle.NET.ToggleDemo/MauiProgram.cs
@@ -15,10 +15,6 @@ public static MauiApp CreateMauiApp()
                     fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
                 });
 
-#if DEBUG
-		builder.Logging.AddDebug();
-#endif
-
             return builder.Build();
         }
     }
diff --git a/Cycle.NET.UnionDemo/Cycle.NET.UnionDemo.csproj b/Cycle.NET.UnionDemo/Cycle.NET.UnionDemo.csproj
index 6ac46b6..fd1486f 100644
--- a/Cycle.NET.UnionDemo/Cycle.NET.UnionDemo.csproj
+++ b/Cycle.NET.UnionDemo/Cycle.NET.UnionDemo.csproj
@@ -2,11 +2,11 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.0" />
+    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Cycle.NET/Cycle.NET.csproj b/Cycle.NET/Cycle.NET.csproj
index ce9389a..2021f00 100644
--- a/Cycle.NET/Cycle.NET.csproj
+++ b/Cycle.NET/Cycle.NET.csproj
@@ -1,11 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.0" />
+    <PackageReference Include="SdgApps.Common.DotnetSealedUnions" Version="1.0.1" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 

From 7585dddb113bb0d78ec6891daece140c9879df55 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Fri, 5 May 2023 17:26:32 -0400
Subject: [PATCH 41/42] Update MAUI

---
 Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj b/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
index a9af22f..3c9229b 100644
--- a/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
+++ b/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
@@ -49,8 +49,8 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.22621.755" />
-		<PackageReference Include="ReactiveUI.Maui" Version="18.4.20" />
+		<PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.22621.756" />
+		<PackageReference Include="ReactiveUI.Maui" Version="18.4.34" />
 	</ItemGroup>
 
 </Project>

From 00e80a57fc9d58452be09d55b2d93586099da8c0 Mon Sep 17 00:00:00 2001
From: Nathaniel Bond <nabond251@gmail.com>
Date: Fri, 5 May 2023 18:00:44 -0400
Subject: [PATCH 42/42] Add toggle demo

---
 .editorconfig                                 | 18 +++---
 Cycle.NET.Demo/Program.cs                     |  2 +-
 Cycle.NET.ToggleDemo/App.xaml.cs              |  6 +-
 Cycle.NET.ToggleDemo/AppBootstrapper.cs       | 62 +++++++++++++++++++
 Cycle.NET.ToggleDemo/AppShell.xaml            | 14 -----
 Cycle.NET.ToggleDemo/AppShell.xaml.cs         | 10 ---
 .../Cycle.NET.ToggleDemo.csproj               |  4 ++
 Cycle.NET.ToggleDemo/MainPage.xaml            | 41 ------------
 Cycle.NET.ToggleDemo/MainPage.xaml.cs         | 24 -------
 Cycle.NET.ToggleDemo/MauiProgram.cs           |  7 +--
 .../Platforms/MacCatalyst/Program.cs          |  2 +-
 Cycle.NET.ToggleDemo/Platforms/iOS/Program.cs |  2 +-
 .../ViewModels/ToggleDemoViewModel.cs         | 62 +++++++++++++++++++
 .../ViewModels/ViewModelBase.cs               | 54 ++++++++++++++++
 Cycle.NET.ToggleDemo/Views/ContentPageBase.cs | 20 ++++++
 .../Views/ToggleDemoView.xaml                 | 31 ++++++++++
 .../Views/ToggleDemoView.xaml.cs              | 34 ++++++++++
 Cycle.NET.UnionDemo/Program.cs                |  2 +-
 18 files changed, 286 insertions(+), 109 deletions(-)
 create mode 100644 Cycle.NET.ToggleDemo/AppBootstrapper.cs
 delete mode 100644 Cycle.NET.ToggleDemo/AppShell.xaml
 delete mode 100644 Cycle.NET.ToggleDemo/AppShell.xaml.cs
 delete mode 100644 Cycle.NET.ToggleDemo/MainPage.xaml
 delete mode 100644 Cycle.NET.ToggleDemo/MainPage.xaml.cs
 create mode 100644 Cycle.NET.ToggleDemo/ViewModels/ToggleDemoViewModel.cs
 create mode 100644 Cycle.NET.ToggleDemo/ViewModels/ViewModelBase.cs
 create mode 100644 Cycle.NET.ToggleDemo/Views/ContentPageBase.cs
 create mode 100644 Cycle.NET.ToggleDemo/Views/ToggleDemoView.xaml
 create mode 100644 Cycle.NET.ToggleDemo/Views/ToggleDemoView.xaml.cs

diff --git a/.editorconfig b/.editorconfig
index 1ea2ffe..56c91c6 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -25,10 +25,10 @@ indent_size = 2
 dotnet_sort_system_directives_first = true
 
 # Avoid "this." and "Me." if not necessary
-dotnet_style_qualification_for_field = false:suggestion
-dotnet_style_qualification_for_property = false:suggestion
-dotnet_style_qualification_for_method = false:suggestion
-dotnet_style_qualification_for_event = false:suggestion
+dotnet_style_qualification_for_field = true:suggestion
+dotnet_style_qualification_for_property = true:suggestion
+dotnet_style_qualification_for_method = true:suggestion
+dotnet_style_qualification_for_event = true:suggestion
 
 # Use language keywords instead of framework type names for type references
 dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
@@ -44,14 +44,14 @@ dotnet_style_explicit_tuple_names = true:suggestion
 # CSharp code style settings:
 [*.cs]
 # Prefer "var" where the type is apparent
-csharp_style_var_for_built_in_types = false:suggestion
+csharp_style_var_for_built_in_types = true:suggestion
 csharp_style_var_when_type_is_apparent = true:suggestion
-csharp_style_var_elsewhere = false:suggestion
+csharp_style_var_elsewhere = true:suggestion
 
 # Prefer method-like constructs to have a block body
-csharp_style_expression_bodied_methods = false:none
-csharp_style_expression_bodied_constructors = false:none
-csharp_style_expression_bodied_operators = false:none
+csharp_style_expression_bodied_methods = true:none
+csharp_style_expression_bodied_constructors = true:none
+csharp_style_expression_bodied_operators = true:none
 
 # Prefer property-like constructs to have an expression-body
 csharp_style_expression_bodied_properties = true:none
diff --git a/Cycle.NET.Demo/Program.cs b/Cycle.NET.Demo/Program.cs
index 4947afe..f6d3fde 100644
--- a/Cycle.NET.Demo/Program.cs
+++ b/Cycle.NET.Demo/Program.cs
@@ -29,7 +29,7 @@ private static Streams CycleMain(Streams sources)
 
             return sinks;
         }
-        static void Main(string[] args)
+        static void Main()
         {
             var drivers = new Drivers
             {
diff --git a/Cycle.NET.ToggleDemo/App.xaml.cs b/Cycle.NET.ToggleDemo/App.xaml.cs
index 3afe14b..95f90ab 100644
--- a/Cycle.NET.ToggleDemo/App.xaml.cs
+++ b/Cycle.NET.ToggleDemo/App.xaml.cs
@@ -4,9 +4,9 @@ public partial class App : Application
     {
         public App()
         {
-            InitializeComponent();
+            this.InitializeComponent();
 
-            MainPage = new AppShell();
+            this.MainPage = AppBootstrapper.CreateMainPage();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Cycle.NET.ToggleDemo/AppBootstrapper.cs b/Cycle.NET.ToggleDemo/AppBootstrapper.cs
new file mode 100644
index 0000000..2053d7c
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/AppBootstrapper.cs
@@ -0,0 +1,62 @@
+using Cycle.NET.ToggleDemo.ViewModels;
+using Cycle.NET.ToggleDemo.Views;
+using ReactiveUI;
+using Splat;
+
+namespace Cycle.NET.ToggleDemo
+{
+    /// <summary>
+    /// The app bootstrapper which is used to register everything with the Splat service locator.
+    /// </summary>
+    public static class AppBootstrapper
+    {
+        /// <summary>
+        /// Registers everything with the Splat service locator.
+        /// </summary>
+        public static MauiAppBuilder UseAppBootstrapper(this MauiAppBuilder builder)
+        {
+            var router = new RoutingState();
+            var screen = new AppBootstrapScreen(router);
+            Locator.CurrentMutable.RegisterConstant(screen, typeof(IScreen));
+            Locator.CurrentMutable.Register(() => new ToggleDemoView(), typeof(IViewFor<ToggleDemoViewModel>));
+
+            router
+                .NavigateAndReset
+                .Execute(new ToggleDemoViewModel())
+                .Subscribe();
+
+            return builder;
+        }
+
+        /// <summary>
+        /// Creates the first main page used within the application.
+        /// </summary>
+        /// <returns>The page generated.</returns>
+        public static Page CreateMainPage()
+        {
+            // NB: This returns the opening page that the platform-specific
+            // boilerplate code will look for. It will know to find us because
+            // we've registered our AppBootstrapScreen.
+            return new ReactiveUI.Maui.RoutedViewHost();
+        }
+
+        /// <summary>
+        /// The app bootstrap screen is the central location for the RoutingState used for routing between views.
+        /// </summary>
+        private sealed class AppBootstrapScreen : ReactiveObject, IScreen
+        {
+            /// <summary>
+            /// Initializes a new instance of the <see cref="AppBootstrapScreen"/> class.
+            /// </summary>
+            public AppBootstrapScreen(RoutingState router)
+            {
+                this.Router = router;
+            }
+
+            /// <summary>
+            /// Gets or sets the router which is used to navigate between views.
+            /// </summary>
+            public RoutingState Router { get; set; }
+        }
+    }
+}
diff --git a/Cycle.NET.ToggleDemo/AppShell.xaml b/Cycle.NET.ToggleDemo/AppShell.xaml
deleted file mode 100644
index 28dfa95..0000000
--- a/Cycle.NET.ToggleDemo/AppShell.xaml
+++ /dev/null
@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<Shell
-    x:Class="Cycle.NET.ToggleDemo.AppShell"
-    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
-    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
-    xmlns:local="clr-namespace:Cycle.NET.ToggleDemo"
-    Shell.FlyoutBehavior="Disabled">
-
-    <ShellContent
-        Title="Home"
-        ContentTemplate="{DataTemplate local:MainPage}"
-        Route="MainPage" />
-
-</Shell>
diff --git a/Cycle.NET.ToggleDemo/AppShell.xaml.cs b/Cycle.NET.ToggleDemo/AppShell.xaml.cs
deleted file mode 100644
index ec2f41c..0000000
--- a/Cycle.NET.ToggleDemo/AppShell.xaml.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-namespace Cycle.NET.ToggleDemo
-{
-    public partial class AppShell : Shell
-    {
-        public AppShell()
-        {
-            InitializeComponent();
-        }
-    }
-}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj b/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
index 3c9229b..d537e29 100644
--- a/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
+++ b/Cycle.NET.ToggleDemo/Cycle.NET.ToggleDemo.csproj
@@ -53,4 +53,8 @@
 		<PackageReference Include="ReactiveUI.Maui" Version="18.4.34" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <ProjectReference Include="..\Cycle.NET\Cycle.NET.csproj" />
+	</ItemGroup>
+
 </Project>
diff --git a/Cycle.NET.ToggleDemo/MainPage.xaml b/Cycle.NET.ToggleDemo/MainPage.xaml
deleted file mode 100644
index 357fc94..0000000
--- a/Cycle.NET.ToggleDemo/MainPage.xaml
+++ /dev/null
@@ -1,41 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
-             x:Class="Cycle.NET.ToggleDemo.MainPage">
-
-    <ScrollView>
-        <VerticalStackLayout
-            Spacing="25"
-            Padding="30,0"
-            VerticalOptions="Center">
-
-            <Image
-                Source="dotnet_bot.png"
-                SemanticProperties.Description="Cute dot net bot waving hi to you!"
-                HeightRequest="200"
-                HorizontalOptions="Center" />
-
-            <Label
-                Text="Hello, World!"
-                SemanticProperties.HeadingLevel="Level1"
-                FontSize="32"
-                HorizontalOptions="Center" />
-
-            <Label
-                Text="Welcome to .NET Multi-platform App UI"
-                SemanticProperties.HeadingLevel="Level2"
-                SemanticProperties.Description="Welcome to dot net Multi platform App U I"
-                FontSize="18"
-                HorizontalOptions="Center" />
-
-            <Button
-                x:Name="CounterBtn"
-                Text="Click me"
-                SemanticProperties.Hint="Counts the number of times you click"
-                Clicked="OnCounterClicked"
-                HorizontalOptions="Center" />
-
-        </VerticalStackLayout>
-    </ScrollView>
-
-</ContentPage>
diff --git a/Cycle.NET.ToggleDemo/MainPage.xaml.cs b/Cycle.NET.ToggleDemo/MainPage.xaml.cs
deleted file mode 100644
index f7e017e..0000000
--- a/Cycle.NET.ToggleDemo/MainPage.xaml.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-namespace Cycle.NET.ToggleDemo
-{
-    public partial class MainPage : ContentPage
-    {
-        int count = 0;
-
-        public MainPage()
-        {
-            InitializeComponent();
-        }
-
-        private void OnCounterClicked(object sender, EventArgs e)
-        {
-            count++;
-
-            if (count == 1)
-                CounterBtn.Text = $"Clicked {count} time";
-            else
-                CounterBtn.Text = $"Clicked {count} times";
-
-            SemanticScreenReader.Announce(CounterBtn.Text);
-        }
-    }
-}
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/MauiProgram.cs b/Cycle.NET.ToggleDemo/MauiProgram.cs
index 98c40f7..b6575bc 100644
--- a/Cycle.NET.ToggleDemo/MauiProgram.cs
+++ b/Cycle.NET.ToggleDemo/MauiProgram.cs
@@ -1,6 +1,4 @@
-using Microsoft.Extensions.Logging;
-
-namespace Cycle.NET.ToggleDemo
+namespace Cycle.NET.ToggleDemo
 {
     public static class MauiProgram
     {
@@ -9,6 +7,7 @@ public static MauiApp CreateMauiApp()
             var builder = MauiApp.CreateBuilder();
             builder
                 .UseMauiApp<App>()
+                .UseAppBootstrapper()
                 .ConfigureFonts(fonts =>
                 {
                     fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
@@ -18,4 +17,4 @@ public static MauiApp CreateMauiApp()
             return builder.Build();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Program.cs b/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Program.cs
index 8a085b2..a0b8c62 100644
--- a/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Program.cs
+++ b/Cycle.NET.ToggleDemo/Platforms/MacCatalyst/Program.cs
@@ -3,7 +3,7 @@
 
 namespace Cycle.NET.ToggleDemo
 {
-    public class Program
+    public static class Program
     {
         // This is the main entry point of the application.
         static void Main(string[] args)
diff --git a/Cycle.NET.ToggleDemo/Platforms/iOS/Program.cs b/Cycle.NET.ToggleDemo/Platforms/iOS/Program.cs
index 8a085b2..a0b8c62 100644
--- a/Cycle.NET.ToggleDemo/Platforms/iOS/Program.cs
+++ b/Cycle.NET.ToggleDemo/Platforms/iOS/Program.cs
@@ -3,7 +3,7 @@
 
 namespace Cycle.NET.ToggleDemo
 {
-    public class Program
+    public static class Program
     {
         // This is the main entry point of the application.
         static void Main(string[] args)
diff --git a/Cycle.NET.ToggleDemo/ViewModels/ToggleDemoViewModel.cs b/Cycle.NET.ToggleDemo/ViewModels/ToggleDemoViewModel.cs
new file mode 100644
index 0000000..6521471
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/ViewModels/ToggleDemoViewModel.cs
@@ -0,0 +1,62 @@
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using ReactiveUI;
+
+namespace Cycle.NET.ToggleDemo.ViewModels
+{
+    /// <summary>
+    /// A view model that contains a toggled checkbox.
+    /// </summary>
+    public class ToggleDemoViewModel : ViewModelBase
+    {
+        private ObservableAsPropertyHelper<string> _status;
+        private bool _toggled;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ToggleDemoViewModel"/> class.
+        /// </summary>
+        /// <param name="mainThreadScheduler">The scheduler to use for main thread operations.</param>
+        /// <param name="taskPoolScheduler">The scheduler to use for task pool operations.</param>
+        /// <param name="hostScreen">The screen to use for routing operations.</param>
+        public ToggleDemoViewModel(
+                IScheduler mainThreadScheduler = null,
+                IScheduler taskPoolScheduler = null,
+                IScreen hostScreen = null)
+            : base("Toggle a Checkbox", mainThreadScheduler, taskPoolScheduler, hostScreen)
+        {
+            Func<IObservable<string>, IObservable<bool>> domDriver = (IObservable<string> sinks) =>
+            {
+                sinks.ToProperty(this, x => x.Status, out this._status);
+
+                return this.WhenAnyValue(x => x.Toggled);
+            };
+
+            Runner.Run(
+                CycleMain,
+                domDriver);
+        }
+
+        private static IObservable<string> CycleMain(IObservable<bool> domSources)
+        {
+            var domSink =
+                domSources
+                .Select(toggled => toggled ? "ON" : "off");
+
+            return domSink;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicaying whether the toggle is toggled.
+        /// </summary>
+        public bool Toggled
+        {
+            get { return this._toggled; }
+            set { this.RaiseAndSetIfChanged(ref this._toggled, value); }
+        }
+
+        /// <summary>
+        /// Gets status text.
+        /// </summary>
+        public string Status => this._status.Value;
+    }
+}
diff --git a/Cycle.NET.ToggleDemo/ViewModels/ViewModelBase.cs b/Cycle.NET.ToggleDemo/ViewModels/ViewModelBase.cs
new file mode 100644
index 0000000..520d8b7
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/ViewModels/ViewModelBase.cs
@@ -0,0 +1,54 @@
+using System.Reactive.Concurrency;
+using ReactiveUI;
+using Splat;
+
+namespace Cycle.NET.ToggleDemo.ViewModels
+{
+    /// <summary>
+    /// A base for all the different view models used throughout the application.
+    /// </summary>
+    public abstract class ViewModelBase : ReactiveObject, IRoutableViewModel, IActivatableViewModel
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ViewModelBase"/> class.
+        /// </summary>
+        /// <param name="title">The title of the view model for routing purposes.</param>
+        /// <param name="mainThreadScheduler">The scheduler to use to schedule operations on the main thread.</param>
+        /// <param name="taskPoolScheduler">The scheduler to use to schedule operations on the task pool.</param>
+        /// <param name="hostScreen">The screen used for routing purposes.</param>
+        protected ViewModelBase(string title, IScheduler mainThreadScheduler = null, IScheduler taskPoolScheduler = null, IScreen hostScreen = null)
+        {
+            this.UrlPathSegment = title;
+            this.HostScreen = hostScreen ?? Locator.Current.GetService<IScreen>();
+
+            // Set the schedulers like this so we can inject the test scheduler later on when doing VM unit tests
+            this.MainThreadScheduler = mainThreadScheduler ?? RxApp.MainThreadScheduler;
+            this.TaskPoolScheduler = taskPoolScheduler ?? RxApp.TaskpoolScheduler;
+        }
+
+        /// <summary>
+        /// Gets the current page path.
+        /// </summary>
+        public string UrlPathSegment { get; }
+
+        /// <summary>
+        /// Gets the screen used for routing operations.
+        /// </summary>
+        public IScreen HostScreen { get; }
+
+        /// <summary>
+        /// Gets the activator which contains context information for use in activation of the view model.
+        /// </summary>
+        public ViewModelActivator Activator { get; } = new ViewModelActivator();
+
+        /// <summary>
+        /// Gets the scheduler for scheduling operations on the main thread.
+        /// </summary>
+        protected IScheduler MainThreadScheduler { get; }
+
+        /// <summary>
+        /// Gets the scheduler for scheduling operations on the task pool.
+        /// </summary>
+        protected IScheduler TaskPoolScheduler { get; }
+    }
+}
diff --git a/Cycle.NET.ToggleDemo/Views/ContentPageBase.cs b/Cycle.NET.ToggleDemo/Views/ContentPageBase.cs
new file mode 100644
index 0000000..d57dd08
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Views/ContentPageBase.cs
@@ -0,0 +1,20 @@
+using Cycle.NET.ToggleDemo.ViewModels;
+using ReactiveUI.Maui;
+
+namespace Cycle.NET.ToggleDemo.Views
+{
+    /// <summary>
+    /// A base page used for all our content pages. It is mainly used for interaction registrations.
+    /// </summary>
+    /// <typeparam name="TViewModel">The view model which the page contains.</typeparam>
+    public class ContentPageBase<TViewModel> : ReactiveContentPage<TViewModel>
+        where TViewModel : ViewModelBase
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ContentPageBase{TViewModel}"/> class.
+        /// </summary>
+        public ContentPageBase()
+        {
+        }
+    }
+}
diff --git a/Cycle.NET.ToggleDemo/Views/ToggleDemoView.xaml b/Cycle.NET.ToggleDemo/Views/ToggleDemoView.xaml
new file mode 100644
index 0000000..c9ffc34
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Views/ToggleDemoView.xaml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<ui:ContentPageBase x:Class="Cycle.NET.ToggleDemo.Views.ToggleDemoView"
+                    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+                    xmlns:rxui="clr-namespace:ReactiveUI.Maui;assembly=ReactiveUI.Maui"
+                    xmlns:ui="clr-namespace:Cycle.NET.ToggleDemo.Views"
+                    xmlns:vms="clr-namespace:Cycle.NET.ToggleDemo.ViewModels"
+                    x:TypeArguments="vms:ToggleDemoViewModel"
+                    x:DataType="vms:ToggleDemoViewModel">
+
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="Auto" />
+            <ColumnDefinition Width="Auto" />
+        </Grid.ColumnDefinitions>
+        <CheckBox
+            x:Name="Toggled" />
+        <Label
+            Grid.Column="1"
+            Text="Toggle me"
+            VerticalTextAlignment="Center" />
+        <Label
+            x:Name="Status"
+            Grid.Row="1"
+            Grid.ColumnSpan="2" />
+    </Grid>
+</ui:ContentPageBase>
\ No newline at end of file
diff --git a/Cycle.NET.ToggleDemo/Views/ToggleDemoView.xaml.cs b/Cycle.NET.ToggleDemo/Views/ToggleDemoView.xaml.cs
new file mode 100644
index 0000000..08d57aa
--- /dev/null
+++ b/Cycle.NET.ToggleDemo/Views/ToggleDemoView.xaml.cs
@@ -0,0 +1,34 @@
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using Cycle.NET.ToggleDemo.ViewModels;
+using ReactiveUI;
+
+namespace Cycle.NET.ToggleDemo.Views
+{
+    /// <summary>
+    /// Contains a toggled checkbox.
+    /// </summary>
+    public partial class ToggleDemoView : ContentPageBase<ToggleDemoViewModel>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ToggleDemoView"/> class.
+        /// </summary>
+        public ToggleDemoView()
+        {
+            this.InitializeComponent();
+
+            this.WhenActivated(disposables =>
+            {
+                Observable.FromEventPattern<CheckedChangedEventArgs>(
+                    handler => this.Toggled.CheckedChanged += handler,
+                    handler => this.Toggled.CheckedChanged -= handler)
+                    .Select(p => p.EventArgs)
+                    .Select(e => e.Value)
+                    .BindTo(this, x => x.ViewModel.Toggled)
+                    .DisposeWith(disposables);
+
+                this.OneWayBind(this.ViewModel, vm => vm.Status, v => v.Status.Text).DisposeWith(disposables);
+            });
+        }
+    }
+}
diff --git a/Cycle.NET.UnionDemo/Program.cs b/Cycle.NET.UnionDemo/Program.cs
index 077c15a..f1d5360 100644
--- a/Cycle.NET.UnionDemo/Program.cs
+++ b/Cycle.NET.UnionDemo/Program.cs
@@ -71,7 +71,7 @@ private static
 
             return domSink;
         }
-        static void Main(string[] args)
+        static void Main()
         {
             Runner.Run(
                 (