diff --git a/LanguageExt.Pipes/Client/Client.cs b/LanguageExt.Pipes/Client/Client.cs
deleted file mode 100644
index 5a7c88c3b..000000000
--- a/LanguageExt.Pipes/Client/Client.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-using System.Diagnostics.Contracts;
-using System.Runtime.CompilerServices;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// `Client` sends requests of type `REQ` and receives responses of type `RES`.
-/// 
-/// Clients only `request` and never `respond`.
-/// </summary>
-/// <remarks>
-/// 
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     REQ 〈==      〈== Unit
-///           |         |
-///     RES  ==〉      ==〉Void
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public class Client
-{
-    /// <summary>
-    /// Monad return / pure
-    /// </summary>
-    [Pure, MethodImpl(Proxy.mops)]
-    public static Client<REQ, RES, M, R> Pure<REQ, RES, M, R>(R value)
-        where M : Monad<M> =>
-        new Pure<REQ, RES, Unit, Void, M, R>(value).ToClient();
-
-    /// <summary>
-    /// Send a value of type `RES` downstream and block waiting for a reply of type `REQ`
-    /// </summary>
-    /// <remarks>
-    /// `respond` is the identity of the respond category.
-    /// </remarks>
-    [Pure, MethodImpl(Proxy.mops)]
-    public static Client<REQ, RES, M, RES> request<REQ, M, RES>(REQ value)
-        where M : Monad<M> =>
-        new Request<REQ, RES, Unit, Void, M, RES>(value, r => new Pure<REQ, RES, Unit, Void, M, RES>(r)).ToClient();
-
-    /// <summary>
-    /// Lift am IO monad into the `Proxy` monad transformer
-    /// </summary>
-    [Pure, MethodImpl(Proxy.mops)]
-    public static Client<REQ, RES, M, R> lift<REQ, RES, M, R>(K<M, R> ma) 
-        where M : Monad<M> =>
-        new ProxyM<REQ, RES, Unit, Void, M, R>(M.Map(Proxy.Pure<REQ, RES, Unit, Void, M, R>, ma)).ToClient();
-
-    /// <summary>
-    /// Lift am IO monad into the `Proxy` monad transformer
-    /// </summary>
-    [Pure, MethodImpl(Proxy.mops)]
-    public static Client<REQ, RES, M, R> liftIO<REQ, RES, M, R>(IO<R> ma) 
-        where M : Monad<M> =>
-        new ProxyM<REQ, RES, Unit, Void, M, R>(M.Map(Proxy.Pure<REQ, RES, Unit, Void, M, R>, M.LiftIO(ma))).ToClient();
-}
diff --git a/LanguageExt.Pipes/Client/CoreTypes.cs b/LanguageExt.Pipes/Client/CoreTypes.cs
deleted file mode 100644
index 93937f49c..000000000
--- a/LanguageExt.Pipes/Client/CoreTypes.cs
+++ /dev/null
@@ -1,237 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// `Client` sends requests of type `REQ` and receives responses of type `RES`.
-/// 
-/// Clients only `request` and never `respond`.
-/// </summary>
-/// <remarks>
-/// 
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     REQ 〈==      〈== Unit
-///           |         |
-///     RES  ==〉      ==〉Void
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public record Client<REQ, RES, M, A> : Proxy<REQ, RES, Unit, Void, M, A>
-    where M : Monad<M>
-{
-    public readonly Proxy<REQ, RES, Unit, Void, M, A> Value;
-
-    /// <summary>
-    /// Constructor
-    /// </summary>
-    /// <param name="value">Correctly shaped `Proxy` that represents a `Client`</param>
-    public Client(Proxy<REQ, RES, Unit, Void, M, A> value) =>
-        Value = value;
-                
-    /// <summary>
-    /// Calling this will effectively cast the subtype to the base.
-    /// </summary>
-    /// <remarks>This type wraps up a `Proxy` for convenience, and so it's a `Proxy` proxy.  So calling this method
-    /// isn't exactly the same as a cast operation, as it unwraps the `Proxy` from within.  It has the same effect
-    /// however, and removes a level of indirection</remarks>
-    /// <returns>A general `Proxy` type from a more specialised type</returns>
-    [Pure]
-    public override Proxy<REQ, RES, Unit, Void, M, A> ToProxy() =>
-        Value.ToProxy();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public override Proxy<REQ, RES, Unit, Void, M, B> Bind<B>(Func<A, Proxy<REQ, RES, Unit, Void, M, B>> f) =>
-        Value.Bind(f);
-  
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<REQ, RES, Unit, Void, M, B> Map<B>(Func<A, B> f) =>
-        Value.Map(f);
-        
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<REQ, RES, Unit, Void, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
-        Value.MapM(f);
-                    
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<REQ, RES, Unit, Void, M, IO<A>> ToIO() =>
-        Value.ToIO();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Client` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Client<REQ, RES, M, B> Bind<B>(Func<A, Client<REQ, RES, M, B>> f) => 
-        Value.Bind(f).ToClient();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Client` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Client<REQ, RES, M, B> SelectMany<B>(Func<A, Client<REQ, RES, M, B>> f) => 
-        Value.Bind(f).ToClient();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Client` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Client<REQ, RES, M, C> SelectMany<B, C>(Func<A, Client<REQ, RES, M, B>> f, Func<A, B, C> project) => 
-        Value.Bind(a => f(a).Map(b => project(a, b))).ToClient();
-        
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public new Client<REQ, RES, M, B> Select<B>(Func<A, B> f) => 
-        Value.Map(f).ToClient();        
-        
-    /// <summary>
-    /// `For(body)` loops over the `Proxy p` replacing each `yield` with `body`
-    /// </summary>
-    /// <param name="body">Any `yield` found in the `Proxy` will be replaced with this function.  It will be composed so
-    /// that the value yielded will be passed to the argument of the function.  That returns a `Proxy` to continue the
-    /// processing of the computation</param>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the function provided</returns>
-    [Pure]
-    public override Proxy<REQ, RES, C1, C, M, A> For<C1, C>(Func<Void, Proxy<REQ, RES, C1, C, M, Unit>> body) =>
-        Value.For(body);
-
-    /// <summary>
-    /// Applicative action
-    ///
-    /// Invokes this `Proxy`, then the `Proxy r` 
-    /// </summary>
-    /// <param name="r">`Proxy` to run after this one</param>
-    [Pure]
-    public override Proxy<REQ, RES, Unit, Void, M, S> Action<S>(Proxy<REQ, RES, Unit, Void, M, S> r) =>
-        Value.Action(r);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, Void, M, A> PairEachRequestWithRespond<UOutA, AUInA>(Func<REQ, Proxy<UOutA, AUInA, REQ, RES, M, A>> lhs) =>
-        Value.PairEachRequestWithRespond(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, Void, M, A> ReplaceRequest<UOutA, AUInA>(Func<REQ, Proxy<UOutA, AUInA, Unit, Void, M, RES>> lhs) =>
-        Value.ReplaceRequest(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<REQ, RES, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(Func<Void, Proxy<Unit, Void, DInC, DOutC, M, A>> rhs) =>
-        Value.PairEachRespondWithRequest(rhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<REQ, RES, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(Func<Void, Proxy<REQ, RES, DInC, DOutC, M, Unit>> rhs) =>
-        Value.ReplaceRespond(rhs);
-
-    /// <summary>
-    /// Reverse the arrows of the `Proxy` to find its dual.  
-    /// </summary>
-    /// <returns>The dual of `this`</returns>
-    [Pure]
-    public override Proxy<Void, Unit, RES, REQ, M, A> Reflect() =>
-        Value.Reflect();
-
-    /// <summary>
-    /// 
-    ///     Observe(lift (Pure(r))) = Observe(Pure(r))
-    ///     Observe(lift (m.Bind(f))) = Observe(lift(m.Bind(x => lift(f(x)))))
-    /// 
-    /// This correctness comes at a small cost to performance, so use this function sparingly.
-    /// This function is a convenience for low-level pipes implementers.  You do not need to
-    /// use observe if you stick to the safe API.        
-    /// </summary>
-    [Pure]
-    public override Proxy<REQ, RES, Unit, Void, M, A> Observe() =>
-        Value.Observe();
-
-    [Pure]
-    public void Deconstruct(out Proxy<REQ, RES, Unit, Void, M, A> value) =>
-        value = Value;
-
-    /// <summary>
-    /// Compose a `Server` and a `Client` together into an `Effect`.  Note the `Server` is provided as a function
-    /// that takes a value of `REQ`.  This is how we model the request coming into the `Server`.  The resulting
-    /// `Server` computation can then call `Server.respond(response)` to reply to the `Client`.
-    ///
-    /// The `Client` simply calls `Client.request(req)` to post a request to the `Server`, it is like an `awaiting`
-    /// that also posts.  It will await the response from the `Server`. 
-    /// </summary>
-    /// <param name="x">`Server`</param>
-    /// <param name="y">`Client`</param>
-    /// <returns>`Effect`</returns>
-    [Pure]
-    public static Effect<M, A> operator |(Func<REQ, Server<REQ, RES, M, A>> x, Client<REQ, RES, M, A> y) =>
-        y.PairEachRequestWithRespond(x).ToEffect();
-        
-    /// <summary>
-    /// Chain one client after another
-    /// </summary>
-    [Pure]
-    public static Client<REQ, RES, M, A> operator &(
-        Client<REQ, RES, M, A> lhs,
-        Client<REQ, RES, M, A> rhs) =>
-        lhs.Bind(_ => rhs);
-    
-    [Pure]
-    public override string ToString() => 
-        "client";
-}
diff --git a/Samples/PipesExamples/Concurrent/Buffer.cs b/LanguageExt.Pipes/Concurrent/Buffer.cs
similarity index 97%
rename from Samples/PipesExamples/Concurrent/Buffer.cs
rename to LanguageExt.Pipes/Concurrent/Buffer.cs
index 731b83590..7d8ef078e 100644
--- a/Samples/PipesExamples/Concurrent/Buffer.cs
+++ b/LanguageExt.Pipes/Concurrent/Buffer.cs
@@ -1,4 +1,4 @@
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 /// <summary>
 /// Settings for `Mailbox` channels
diff --git a/Samples/PipesExamples/Concurrent/Inbox/Inbox.CoFunctor.cs b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.CoFunctor.cs
similarity index 92%
rename from Samples/PipesExamples/Concurrent/Inbox/Inbox.CoFunctor.cs
rename to LanguageExt.Pipes/Concurrent/Inbox/Inbox.CoFunctor.cs
index 14b233f0f..4ba6cf859 100644
--- a/Samples/PipesExamples/Concurrent/Inbox/Inbox.CoFunctor.cs
+++ b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.CoFunctor.cs
@@ -1,6 +1,7 @@
+using System;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 public class Inbox : Decidable<Inbox>
 {
diff --git a/Samples/PipesExamples/Concurrent/Inbox/Inbox.DSL.cs b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.DSL.cs
similarity index 98%
rename from Samples/PipesExamples/Concurrent/Inbox/Inbox.DSL.cs
rename to LanguageExt.Pipes/Concurrent/Inbox/Inbox.DSL.cs
index 69f566cfa..632b3e531 100644
--- a/Samples/PipesExamples/Concurrent/Inbox/Inbox.DSL.cs
+++ b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.DSL.cs
@@ -1,8 +1,9 @@
+using System;
 using System.Threading.Channels;
 using LanguageExt.Common;
 using static LanguageExt.Prelude;
 
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 record InboxWriter<A>(ChannelWriter<A> Writer) : Inbox<A>
 {
diff --git a/Samples/PipesExamples/Concurrent/Inbox/Inbox.Extensions.cs b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.Extensions.cs
similarity index 83%
rename from Samples/PipesExamples/Concurrent/Inbox/Inbox.Extensions.cs
rename to LanguageExt.Pipes/Concurrent/Inbox/Inbox.Extensions.cs
index 2e5dda100..f2c7670fa 100644
--- a/Samples/PipesExamples/Concurrent/Inbox/Inbox.Extensions.cs
+++ b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.Extensions.cs
@@ -1,6 +1,6 @@
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 public static class InboxExtensions
 {
diff --git a/Samples/PipesExamples/Concurrent/Inbox/Inbox.cs b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.cs
similarity index 98%
rename from Samples/PipesExamples/Concurrent/Inbox/Inbox.cs
rename to LanguageExt.Pipes/Concurrent/Inbox/Inbox.cs
index dfa29d54c..2ce767fa2 100644
--- a/Samples/PipesExamples/Concurrent/Inbox/Inbox.cs
+++ b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.cs
@@ -1,7 +1,8 @@
+using System;
 using LanguageExt.Common;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 /// <summary>
 /// Entry point to a channel.  Inboxes receive values and propagate them through the
diff --git a/Samples/PipesExamples/Concurrent/Mailbox/Mailbox.Module.cs b/LanguageExt.Pipes/Concurrent/Mailbox/Mailbox.Module.cs
similarity index 97%
rename from Samples/PipesExamples/Concurrent/Mailbox/Mailbox.Module.cs
rename to LanguageExt.Pipes/Concurrent/Mailbox/Mailbox.Module.cs
index 9842b9e29..9d88b2928 100644
--- a/Samples/PipesExamples/Concurrent/Mailbox/Mailbox.Module.cs
+++ b/LanguageExt.Pipes/Concurrent/Mailbox/Mailbox.Module.cs
@@ -1,5 +1,6 @@
+using System;
 using Ch = System.Threading.Channels;
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 public static class Mailbox
 {
diff --git a/Samples/PipesExamples/Concurrent/Mailbox/Mailbox.cs b/LanguageExt.Pipes/Concurrent/Mailbox/Mailbox.cs
similarity index 99%
rename from Samples/PipesExamples/Concurrent/Mailbox/Mailbox.cs
rename to LanguageExt.Pipes/Concurrent/Mailbox/Mailbox.cs
index 61e6f2112..621b8a10f 100644
--- a/Samples/PipesExamples/Concurrent/Mailbox/Mailbox.cs
+++ b/LanguageExt.Pipes/Concurrent/Mailbox/Mailbox.cs
@@ -1,7 +1,8 @@
+using System;
 using LanguageExt.Common;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 /// <summary>
 /// Represents a channel.  A channel has:
diff --git a/Samples/PipesExamples/Concurrent/Outbox/Outbox.DSL.cs b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.DSL.cs
similarity index 97%
rename from Samples/PipesExamples/Concurrent/Outbox/Outbox.DSL.cs
rename to LanguageExt.Pipes/Concurrent/Outbox/Outbox.DSL.cs
index ed047035f..a0a2801e2 100644
--- a/Samples/PipesExamples/Concurrent/Outbox/Outbox.DSL.cs
+++ b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.DSL.cs
@@ -1,7 +1,10 @@
+using System;
+using System.Threading;
 using System.Threading.Channels;
+using System.Threading.Tasks;
 using LanguageExt.Common;
 
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 record OutboxPure<A>(A Value) : Outbox<A>
 {
diff --git a/Samples/PipesExamples/Concurrent/Outbox/Outbox.Extensions.cs b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.Extensions.cs
similarity index 83%
rename from Samples/PipesExamples/Concurrent/Outbox/Outbox.Extensions.cs
rename to LanguageExt.Pipes/Concurrent/Outbox/Outbox.Extensions.cs
index 3aac2c4e1..7f6ce7d2e 100644
--- a/Samples/PipesExamples/Concurrent/Outbox/Outbox.Extensions.cs
+++ b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.Extensions.cs
@@ -1,6 +1,6 @@
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 public static class OutboxExtensions
 {
diff --git a/Samples/PipesExamples/Concurrent/Outbox/Outbox.Internal.cs b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.Internal.cs
similarity index 97%
rename from Samples/PipesExamples/Concurrent/Outbox/Outbox.Internal.cs
rename to LanguageExt.Pipes/Concurrent/Outbox/Outbox.Internal.cs
index a2e2246e5..30932b5f2 100644
--- a/Samples/PipesExamples/Concurrent/Outbox/Outbox.Internal.cs
+++ b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.Internal.cs
@@ -1,6 +1,8 @@
+using System.Threading;
+using System.Threading.Tasks;
 using LanguageExt.Common;
 
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 internal class OutboxInternal
 {
diff --git a/LanguageExt.Pipes/Concurrent/Outbox/Outbox.Module.cs b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.Module.cs
new file mode 100644
index 000000000..ab5748c1c
--- /dev/null
+++ b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.Module.cs
@@ -0,0 +1,6 @@
+namespace LanguageExt.Pipes.Concurrent;
+
+public partial class Outbox
+{
+    
+}
diff --git a/Samples/PipesExamples/Concurrent/Outbox/Outbox.Monad.cs b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.Monad.cs
similarity index 94%
rename from Samples/PipesExamples/Concurrent/Outbox/Outbox.Monad.cs
rename to LanguageExt.Pipes/Concurrent/Outbox/Outbox.Monad.cs
index e2c6215d7..e2725f21c 100644
--- a/Samples/PipesExamples/Concurrent/Outbox/Outbox.Monad.cs
+++ b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.Monad.cs
@@ -1,6 +1,7 @@
+using System;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 public partial class Outbox : 
     Monad<Outbox>, 
diff --git a/Samples/PipesExamples/Concurrent/Outbox/Outbox.cs b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.cs
similarity index 97%
rename from Samples/PipesExamples/Concurrent/Outbox/Outbox.cs
rename to LanguageExt.Pipes/Concurrent/Outbox/Outbox.cs
index c0787d48d..f5d5a8718 100644
--- a/Samples/PipesExamples/Concurrent/Outbox/Outbox.cs
+++ b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.cs
@@ -1,7 +1,10 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
 using LanguageExt.Traits;
 using static LanguageExt.Prelude;
 
-namespace LanguageExt.Pipes2.Concurrent;
+namespace LanguageExt.Pipes.Concurrent;
 
 public abstract record Outbox<A> : 
     K<Outbox, A>, 
diff --git a/LanguageExt.Pipes/Consumer/Consumer.cs b/LanguageExt.Pipes/Consumer/Consumer.cs
deleted file mode 100644
index 16c508331..000000000
--- a/LanguageExt.Pipes/Consumer/Consumer.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-using System;
-using LanguageExt.Traits;
-using System.Diagnostics.Contracts;
-using System.Runtime.CompilerServices;
-using static LanguageExt.Pipes.Proxy;
-using static LanguageExt.Prelude;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// Consumers both can only be `awaiting` 
-/// </summary>
-/// <remarks>
-/// 
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     Unit〈==      〈== Unit
-///           |         |
-///      IN  ==〉      ==〉Void
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public static class Consumer
-{
-    /// <summary>
-    /// Monad return / pure
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<A, M, R> Pure<A, M, R>(R value)
-        where M : Monad<M> =>
-        new Pure<Unit, A, Unit, Void, M, R>(value).ToConsumer();
-        
-    /// <summary>
-    /// Wait for a value from upstream (whilst in a consumer)
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<A, M, A> awaiting<M, A>() 
-        where M : Monad<M> =>
-        request<Unit, A, Unit, Void, M>(unit).ToConsumer();
-
-    /// <summary>
-    /// Lift the IO monad into the Consumer monad transformer (a specialism of the Proxy monad transformer)
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<A, M, R> lift<A, M, R>(K<M, R> ma)
-        where M : Monad<M>  =>
-        lift<Unit, A, Unit, Void, M, R>(ma).ToConsumer();
-
-    /// <summary>
-    /// Lift the IO monad into the Consumer monad transformer (a specialism of the Proxy monad transformer)
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<A, M, R> liftIO<A, M, R>(IO<R> ma) 
-        where M : Monad<M> =>
-        liftIO<Unit, A, Unit, Void, M, R>(ma).ToConsumer();
-        
-    /// <summary>
-    /// Consume all values using a monadic function
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<A, M, R> mapM<A, M, R>(Func<A, K<M, Unit>> f) 
-        where M : Monad<M> =>
-        cat<A, M, R>().ForEach(a => lift<A, M, Unit>(f(a)));
-        
-    /// <summary>
-    /// Consume all values using a monadic function
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<A, M, R> mapM<A, M, R>(Func<A, IO<Unit>> f) 
-        where M : Monad<M> =>
-        cat<A, M, R>().ForEach(a => lift<A, M, Unit>(M.LiftIO(f(a))));
-    
-}
diff --git a/LanguageExt.Pipes/Consumer/CoreTypes.cs b/LanguageExt.Pipes/Consumer/CoreTypes.cs
deleted file mode 100644
index 3803c09ff..000000000
--- a/LanguageExt.Pipes/Consumer/CoreTypes.cs
+++ /dev/null
@@ -1,272 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// Consumers both can only be `awaiting` 
-/// </summary>
-/// <remarks>
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     Unit〈==      〈== Unit
-///           |         |
-///      IN  ==〉      ==〉Void
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public record Consumer<IN, M, A> : Proxy<Unit, IN, Unit, Void, M, A>
-    where M : Monad<M>
-{
-    public readonly Proxy<Unit, IN, Unit, Void, M, A> Value;
-        
-    /// <summary>
-    /// Constructor
-    /// </summary>
-    /// <param name="value">Correctly shaped `Proxy` that represents a `Consumer`</param>
-    public Consumer(Proxy<Unit, IN, Unit, Void, M, A> value) =>
-        Value = value;
-
-    /// <summary>
-    /// Calling this will effectively cast the sub-type to the base.
-    /// </summary>
-    /// <remarks>This type wraps up a `Proxy` for convenience, and so it's a `Proxy` proxy.  So calling this method
-    /// isn't exactly the same as a cast operation, as it unwraps the `Proxy` from within.  It has the same effect
-    /// however, and removes a level of indirection</remarks>
-    /// <returns>A general `Proxy` type from a more specialised type</returns>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, Void, M, A> ToProxy() =>
-        Value.ToProxy();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, Void, M, S> Bind<S>(Func<A, Proxy<Unit, IN, Unit, Void, M, S>> f) =>
-        Value.Bind(f);
-
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, Void, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
-        Value.MapM(f);
-                    
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, Void, M, IO<A>> ToIO() =>
-        Value.ToIO();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Consumer<IN, M, B> Bind<B>(Func<A, Consumer<IN, M, B>> f) => 
-        Value.Bind(f).ToConsumer();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Consumer<IN, M, B> Bind<B>(Func<A, K<M, B>> f) => 
-        Value.Bind(x => Consumer.lift<IN, M, B>(f(x))).ToConsumer();
-
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, Void, M, S> Map<S>(Func<A, S> f) =>
-        Value.Map(f);
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Consumer<IN, M, C> SelectMany<B, C>(Func<A, Consumer<IN, M, B>> f, Func<A, B, C> project) => 
-        Value.Bind(a => f(a).Map(b => project(a, b))).ToConsumer();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Consumer<IN, M, C> SelectMany<B, C>(Func<A, K<M, B>> f, Func<A, B, C> project) => 
-        Value.Bind(x => Consumer.lift<IN, M, C>(M.Map(y => project(x, y), f(x)))).ToConsumer();
-    
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public new Consumer<IN, M, B> Select<B>(Func<A, B> f) => 
-        Value.Map(f).ToConsumer();        
-
-    /// <summary>
-    /// `For(body)` loops over the `Proxy p` replacing each `yield` with `body`
-    /// </summary>
-    /// <param name="body">Any `yield` found in the `Proxy` will be replaced with this function.  It will be composed so
-    /// that the value yielded will be passed to the argument of the function.  That returns a `Proxy` to continue the
-    /// processing of the computation</param>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the function provided</returns>
-    [Pure]
-    public override Proxy<Unit, IN, C1, C, M, A> For<C1, C>(Func<Void, Proxy<Unit, IN, C1, C, M, Unit>> body) =>
-        Value.For(body);
-
-    /// <summary>
-    /// Applicative action
-    ///
-    /// Invokes this `Proxy`, then the `Proxy r` 
-    /// </summary>
-    /// <param name="r">`Proxy` to run after this one</param>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, Void, M, S> Action<S>(Proxy<Unit, IN, Unit, Void, M, S> r) =>
-        Value.Action(r);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, Void, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<Unit, Proxy<UOutA, AUInA, Unit, IN, M, A>> lhs) =>
-        Value.PairEachRequestWithRespond(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, Void, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<Unit, Proxy<UOutA, AUInA, Unit, Void, M, IN>> lhs) =>
-        Value.ReplaceRequest(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<Unit, IN, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<Void, Proxy<Unit, Void, DInC, DOutC, M, A>> rhs) =>
-        Value.PairEachRespondWithRequest(rhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<Unit, IN, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<Void, Proxy<Unit, IN, DInC, DOutC, M, Unit>> rhs) =>
-        Value.ReplaceRespond(rhs);
-        
-    /// <summary>
-    /// Reverse the arrows of the `Proxy` to find its dual.  
-    /// </summary>
-    /// <returns>The dual of `this`</returns>
-    [Pure]
-    public override Proxy<Void, Unit, IN, Unit, M, A> Reflect() =>
-        Value.Reflect();
-
-    /// <summary>
-    /// 
-    ///     Observe(lift (Pure(r))) = Observe(Pure(r))
-    ///     Observe(lift (m.Bind(f))) = Observe(lift(m.Bind(x => lift(f(x)))))
-    /// 
-    /// This correctness comes at a small cost to performance, so use this function sparingly.
-    /// This function is a convenience for low-level pipes implementers.  You do not need to
-    /// use observe if you stick to the safe API.        
-    /// </summary>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, Void, M, A> Observe() =>
-        Value.Observe();
-
-    [Pure]
-    public void Deconstruct(out Proxy<Unit, IN, Unit, Void, M, A> value) =>
-        value = Value;
-
-    /// <summary>
-    /// Conversion operator from the _pure_ `Consumer` type, to the monad transformer version of the `Consumer`
-    /// </summary>
-    /// <param name="p">Pure `Consumer`</param>
-    /// <returns>Monad transformer version of the `Consumer`</returns>
-    [Pure]
-    public static implicit operator Consumer<IN, M, A>(Consumer<IN, A> c) =>
-        c.Interpret<M>();
-
-    /// <summary>
-    /// Conversion operator from the `Pure` type, to the monad transformer version of the `Consumer`
-    /// </summary>
-    /// <param name="p">`Pure` value</param>
-    /// <returns>Monad transformer version of the `Consumer`</returns>
-    [Pure]
-    public static implicit operator Consumer<IN, M, A>(Pure<A> p) =>
-        Consumer.Pure<IN, M, A>(p.Value);
-
-    /// <summary>
-    /// Compose an `IN` and a `Consumer` together into an `Effect`.  This effectively creates a singleton `Producer`
-    /// from the `IN` value, and composes it with the `Consumer` into an `Effect` that can be run. 
-    /// </summary>
-    /// <param name="p1">Single input value</param>
-    /// <param name="p2">`Consumer`</param>
-    /// <returns>`Effect`</returns>
-    [Pure]
-    public static Effect<M, A?> operator |(IN p1, Consumer<IN, M, A?> p2) => 
-        Proxy.compose(Producer.yield<IN, M>(p1).Map(_ => default(A)), p2).ToEffect();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Consumer<IN, M, C> SelectMany<B, C>(Func<A, Consumer<IN, B>> bind, Func<A, B, C> project) =>
-        Value.Bind(a =>  bind(a).Interpret<M>().Map(b => project(a, b))).ToConsumer();
-
-    /// <summary>
-    /// Chain one consumer's set of awaits after another
-    /// </summary>
-    [Pure]
-    public static Consumer<IN, M, A> operator &(
-        Consumer<IN, M, A> lhs,
-        Consumer<IN, M, A> rhs) =>
-        lhs.Bind(_ => rhs);
-    
-    [Pure]
-    public override string ToString() => 
-        "consumer";
-}
diff --git a/Samples/PipesExamples/ConsumerT/ConsumerT.Extensions.cs b/LanguageExt.Pipes/ConsumerT/ConsumerT.Extensions.cs
similarity index 98%
rename from Samples/PipesExamples/ConsumerT/ConsumerT.Extensions.cs
rename to LanguageExt.Pipes/ConsumerT/ConsumerT.Extensions.cs
index 07debd41f..9c8a95e57 100644
--- a/Samples/PipesExamples/ConsumerT/ConsumerT.Extensions.cs
+++ b/LanguageExt.Pipes/ConsumerT/ConsumerT.Extensions.cs
@@ -1,6 +1,7 @@
+using System;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 public static class ConsumerTExtensions
 {
diff --git a/Samples/PipesExamples/ConsumerT/ConsumerT.Module.cs b/LanguageExt.Pipes/ConsumerT/ConsumerT.Module.cs
similarity index 99%
rename from Samples/PipesExamples/ConsumerT/ConsumerT.Module.cs
rename to LanguageExt.Pipes/ConsumerT/ConsumerT.Module.cs
index 7f2a4c9dc..76f97195f 100644
--- a/Samples/PipesExamples/ConsumerT/ConsumerT.Module.cs
+++ b/LanguageExt.Pipes/ConsumerT/ConsumerT.Module.cs
@@ -1,7 +1,9 @@
+using System;
+using System.Threading.Tasks;
 using LanguageExt.Common;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 /// <summary>
 /// `ConsumerT` streaming consumer monad-transformer
diff --git a/Samples/PipesExamples/ConsumerT/ConsumerT.Monad.cs b/LanguageExt.Pipes/ConsumerT/ConsumerT.Monad.cs
similarity index 95%
rename from Samples/PipesExamples/ConsumerT/ConsumerT.Monad.cs
rename to LanguageExt.Pipes/ConsumerT/ConsumerT.Monad.cs
index 357b2957f..cdf36cdfb 100644
--- a/Samples/PipesExamples/ConsumerT/ConsumerT.Monad.cs
+++ b/LanguageExt.Pipes/ConsumerT/ConsumerT.Monad.cs
@@ -1,7 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using LanguageExt.Async.Linq;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 public class ConsumerT<IN, M> : MonadT<ConsumerT<IN, M>, M>
     where M : Monad<M>
diff --git a/Samples/PipesExamples/ConsumerT/ConsumerT.cs b/LanguageExt.Pipes/ConsumerT/ConsumerT.cs
similarity index 98%
rename from Samples/PipesExamples/ConsumerT/ConsumerT.cs
rename to LanguageExt.Pipes/ConsumerT/ConsumerT.cs
index cc231362b..ac6e1aa81 100644
--- a/Samples/PipesExamples/ConsumerT/ConsumerT.cs
+++ b/LanguageExt.Pipes/ConsumerT/ConsumerT.cs
@@ -1,7 +1,8 @@
+using System;
 using System.Diagnostics.Contracts;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 /// <summary>
 /// `ConsumerT` streaming consumer monad-transformer instance
diff --git a/LanguageExt.Pipes/Effect/CoreTypes.cs b/LanguageExt.Pipes/Effect/CoreTypes.cs
deleted file mode 100644
index a18d275f4..000000000
--- a/LanguageExt.Pipes/Effect/CoreTypes.cs
+++ /dev/null
@@ -1,238 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// Effects represent a 'fused' set of producer, pipes, and consumer into one type.
-/// 
-/// It neither can neither `yield` nor be `awaiting`, it represents an entirely closed effect system.
-/// </summary>
-/// <remarks>
-/// 
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     Void〈==      〈== Unit
-///           |         |
-///     Unit ==〉      ==〉Void
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// 
-/// </remarks>
-public record Effect<M, A> : Proxy<Void, Unit, Unit, Void, M, A> 
-    where M : Monad<M> 
-{
-    public readonly Proxy<Void, Unit, Unit, Void, M, A> Value;
-
-    /// <summary>
-    /// Constructor
-    /// </summary>
-    /// <param name="value">Correctly shaped `Proxy` that represents an `Effect`</param>
-    public Effect(Proxy<Void, Unit, Unit, Void, M, A> value) =>
-        Value = value;
-        
-    /// <summary>
-    /// Calling this will effectively cast the sub-type to the base.
-    /// </summary>
-    /// <remarks>This type wraps up a `Proxy` for convenience, and so it's a `Proxy` proxy.  So calling this method
-    /// isn't exactly the same as a cast operation, as it unwraps the `Proxy` from within.  It has the same effect
-    /// however, and removes a level of indirection</remarks>
-    /// <returns>A general `Proxy` type from a more specialised type</returns>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, Void, M, A> ToProxy() =>
-        Value.ToProxy();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, Void, M, S> Bind<S>(
-        Func<A, Proxy<Void, Unit, Unit, Void, M, S>> f) =>
-        Value.Bind(f);
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Effect<M, S> Bind<S>(Func<A, Effect<M, S>> f) =>
-        Value.Bind(f).ToEffect();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Effect<M, B> Bind<B>(Func<A, K<M, B>> f) => 
-        Value.Bind(x => Effect.lift(f(x))).ToEffect();
-            
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, Void, M, B> Map<B>(Func<A, B> f) =>
-        Value.Map(f);
-
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, Void, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
-        Value.MapM(f);
-
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, Void, M, IO<A>> ToIO() =>
-        Value.ToIO();
-
-    /// <summary>
-    /// `For(body)` loops over the `Proxy p` replacing each `yield` with `body`
-    /// </summary>
-    /// <param name="body">Any `yield` found in the `Proxy` will be replaced with this function.  It will be composed so
-    /// that the value yielded will be passed to the argument of the function.  That returns a `Proxy` to continue the
-    /// processing of the computation</param>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the function provided</returns>
-    [Pure]
-    public override Proxy<Void, Unit, C1, C, M, A> For<C1, C>(Func<Void, Proxy<Void, Unit, C1, C, M, Unit>> body) =>
-        Value.For(body);
-
-    /// <summary>
-    /// Applicative action
-    ///
-    /// Invokes this `Proxy`, then the `Proxy r` 
-    /// </summary>
-    /// <param name="r">`Proxy` to run after this one</param>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, Void, M, S> Action<S>(Proxy<Void, Unit, Unit, Void, M, S> r) =>
-        Value.Action(r);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, Void, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<Void, Proxy<UOutA, AUInA, Void, Unit, M, A>> lhs) =>
-        Value.PairEachRequestWithRespond(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, Void, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<Void, Proxy<UOutA, AUInA, Unit, Void, M, Unit>> lhs) =>
-        Value.ReplaceRequest(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<Void, Unit, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<Void, Proxy<Unit, Void, DInC, DOutC, M, A>> rhs) =>
-        Value.PairEachRespondWithRequest(rhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<Void, Unit, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<Void, Proxy<Void, Unit, DInC, DOutC, M, Unit>> rhs) =>
-        Value.ReplaceRespond(rhs);
-
-    /// <summary>
-    /// Reverse the arrows of the `Proxy` to find its dual.  
-    /// </summary>
-    /// <returns>The dual of `this`</returns>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, Void, M, A> Reflect() =>
-        Value.Reflect();
-
-    /// <summary>
-    /// 
-    ///     Observe(lift (Pure(r))) = Observe(Pure(r))
-    ///     Observe(lift (m.Bind(f))) = Observe(lift(m.Bind(x => lift(f(x)))))
-    /// 
-    /// This correctness comes at a small cost to performance, so use this function sparingly.
-    /// This function is a convenience for low-level pipes implementers.  You do not need to
-    /// use observe if you stick to the safe API.        
-    /// </summary>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, Void, M, A> Observe() =>
-        Value.Observe();
-
-    [Pure]
-    public void Deconstruct(out Proxy<Void, Unit, Unit, Void, M, A> value) =>
-        value = Value;
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Effect<M, C> SelectMany<B, C>(Func<A, Effect<M, B>> f, Func<A, B, C> project) => 
-        Value.Bind(x => f(x).Map(y => project(x, y))).ToEffect();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Effect<M, C> SelectMany<B, C>(Func<A, IO<B>> f, Func<A, B, C> project) =>
-        SelectMany(a => Effect.liftIO<M, B>(f(a)), project);
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Effect` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Eff` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public K<M, C> SelectMany<B, C>(Func<A, K<M, B>> bind, Func<A, B, C> project) =>
-        M.Bind(this.RunEffect(), a => M.Map(b => project(a, b), bind(a)));
-
-    /// <summary>
-    /// Chain one effect after another
-    /// </summary>
-    [Pure]
-    public static Effect<M, A> operator &(
-        Effect<M, A> lhs,
-        Effect<M, A> rhs) =>
-        lhs.Bind(_ => rhs).ToEffect();
-    
-    [Pure]
-    public override string ToString() => 
-        "effect";
-}
diff --git a/LanguageExt.Pipes/Effect/Effect.cs b/LanguageExt.Pipes/Effect/Effect.cs
deleted file mode 100644
index bd591fb27..000000000
--- a/LanguageExt.Pipes/Effect/Effect.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using System.Linq;
-using static LanguageExt.Pipes.Proxy;
-using System.Runtime.CompilerServices;
-using LanguageExt.Async.Linq;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// Effects represent a 'fused' set of producer, pipes, and consumer into one type.
-/// 
-/// It neither can neither `yield` nor be `awaiting`, it represents an entirely closed effect system.
-/// </summary>
-/// <remarks>
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     Void〈==      〈== Unit
-///           |         |
-///     Unit ==〉      ==〉Void
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public static class Effect
-{
-    [Pure]
-    public static K<M, R> RunEffect<M, R>(this K<Proxy<Void, Unit, Unit, Void, M>, R> ma)
-        where M : Monad<M>
-    {
-        return Go(ma.As());
-
-        K<M, R> Go(Proxy<Void, Unit, Unit, Void, M, R> p) =>
-            p.ToProxy() switch
-            {
-                ProxyM<Void, Unit, Unit, Void, M, R> (var mx)    => M.Bind(mx, Go),
-                Pure<Void, Unit, Unit, Void, M, R> (var r)       => M.Pure(r),
-                Iterator<Void, Unit, Unit, Void, M, R> iter      => runIterator(iter, Go),
-                IteratorAsync<Void, Unit, Unit, Void, M, R> iter => runAsyncIterator(iter, Go),
-                Request<Void, Unit, Unit, Void, M, R> (var v, _) => closed<K<M, R>>(v),
-                Respond<Void, Unit, Unit, Void, M, R> (var v, _) => closed<K<M, R>>(v),
-                _                                                => throw new NotSupportedException()
-            };
-    }
-
-    static K<M, R> runIterator<M, R>(
-        Iterator<Void, Unit, Unit, Void, M, R> iter,
-        Func<Proxy<Void, Unit, Unit, Void, M, R>, K<M, R>> go)
-        where M : Monad<M> =>
-        from _ in iter.Run().Select(e => e.RunEffect()).Actions()
-        from r in go(iter.Next())
-        select r;
-
-    static K<M, R> runAsyncIterator<M, R>(
-        IteratorAsync<Void, Unit, Unit, Void, M, R> iter,
-        Func<Proxy<Void, Unit, Unit, Void, M, R>, K<M, R>> go)
-        where M : Monad<M> =>
-        from _ in iter.Run().Select(e => e.RunEffect()).Actions()
-        from r in go(iter.Next())
-        select r;
-    
-    [Pure]
-    static Proxy<UOut, UIn, DIn, DOut, N, R> HoistX<UOut, UIn, DIn, DOut, M, N, R>(
-        this Proxy<UOut, UIn, DIn, DOut, M, R> ma,
-        Func<K<M, Proxy<UOut, UIn, DIn, DOut, N, R>>, K<N, Proxy<UOut, UIn, DIn, DOut, N, R>>> nat) 
-        where M : Monad<M> 
-        where N : Monad<N> 
-    {
-        return Go(ma);
-
-        Proxy<UOut, UIn, DIn, DOut, N, R> Go(Proxy<UOut, UIn, DIn, DOut, M, R> p) =>
-            p.ToProxy() switch
-            {
-                ProxyM<UOut, UIn, DIn, DOut, M, R> (var mx)          => new ProxyM<UOut, UIn, DIn, DOut, N, R>(nat(mx.Map(Go))),
-                Pure<UOut, UIn, DIn, DOut, M, R> (var r)             => new Pure<UOut, UIn, DIn, DOut, N, R> (r),
-                Request<UOut, UIn, DIn, DOut, M, R> (var a1, var fa) => new Request<UOut, UIn, DIn, DOut, N, R>(a1, a =>Go(fa(a))),
-                Respond<UOut, UIn, DIn, DOut, M, R> (var b, var fb1) => new Respond<UOut, UIn, DIn, DOut, N, R> (b, b1 => Go(fb1(b1))),
-                _                                                    => throw new NotSupportedException()
-            };
-    }
-        
-    [Pure, MethodImpl(mops)]
-    public static Effect<M, R> lift<M, R>(K<M, R> ma) 
-        where M : Monad<M> =>
-        lift<Void, Unit, Unit, Void, M, R>(ma).ToEffect();
-
-    [Pure, MethodImpl(mops)]
-    public static Effect<M, R> liftIO<M, R>(IO<R> ma) 
-        where M : Monad<M> =>
-        liftIO<Void, Unit, Unit, Void, M, R>(ma).ToEffect();
-
-    [Pure, MethodImpl(mops)]
-    public static Effect<M, C> SelectMany<M, A, B, C>(
-        this K<M, A> ma, 
-        Func<A, Effect<M, B>> bind,
-        Func<A, B, C> project)
-        where M : Monad<M> =>
-        lift(ma).SelectMany(bind, project);
-}
diff --git a/Samples/PipesExamples/EffectT/EffectT.Extensions.cs b/LanguageExt.Pipes/EffectT/EffectT.Extensions.cs
similarity index 98%
rename from Samples/PipesExamples/EffectT/EffectT.Extensions.cs
rename to LanguageExt.Pipes/EffectT/EffectT.Extensions.cs
index da8afe615..573e82df2 100644
--- a/Samples/PipesExamples/EffectT/EffectT.Extensions.cs
+++ b/LanguageExt.Pipes/EffectT/EffectT.Extensions.cs
@@ -1,6 +1,7 @@
+using System;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 public static class EffectTExtensions
 {
diff --git a/Samples/PipesExamples/EffectT/EffectT.Module.cs b/LanguageExt.Pipes/EffectT/EffectT.Module.cs
similarity index 98%
rename from Samples/PipesExamples/EffectT/EffectT.Module.cs
rename to LanguageExt.Pipes/EffectT/EffectT.Module.cs
index 679977837..ca28e4b64 100644
--- a/Samples/PipesExamples/EffectT/EffectT.Module.cs
+++ b/LanguageExt.Pipes/EffectT/EffectT.Module.cs
@@ -1,7 +1,9 @@
+using System;
+using System.Threading.Tasks;
 using LanguageExt.Common;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 /// <summary>
 /// `EffectT` streaming effect monad-transformer
diff --git a/Samples/PipesExamples/EffectT/EffectT.Monad.cs b/LanguageExt.Pipes/EffectT/EffectT.Monad.cs
similarity index 94%
rename from Samples/PipesExamples/EffectT/EffectT.Monad.cs
rename to LanguageExt.Pipes/EffectT/EffectT.Monad.cs
index eb04598de..3e07491f0 100644
--- a/Samples/PipesExamples/EffectT/EffectT.Monad.cs
+++ b/LanguageExt.Pipes/EffectT/EffectT.Monad.cs
@@ -1,7 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using LanguageExt.Async.Linq;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 public class EffectT<M> : MonadT<EffectT<M>, M>
     where M : Monad<M>
diff --git a/Samples/PipesExamples/EffectT/EffectT.cs b/LanguageExt.Pipes/EffectT/EffectT.cs
similarity index 96%
rename from Samples/PipesExamples/EffectT/EffectT.cs
rename to LanguageExt.Pipes/EffectT/EffectT.cs
index 38bed4948..4ff378cf1 100644
--- a/Samples/PipesExamples/EffectT/EffectT.cs
+++ b/LanguageExt.Pipes/EffectT/EffectT.cs
@@ -1,7 +1,9 @@
+using System;
 using System.Diagnostics.Contracts;
+using System.Threading.Tasks;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 public readonly record struct EffectT<M, A>(PipeT<Unit, Void, M, A> Proxy) : K<EffectT<M>, A>
     where M : Monad<M>
diff --git a/LanguageExt.Pipes/Extensions/Extensions.MapApply.cs b/LanguageExt.Pipes/Extensions/Extensions.MapApply.cs
deleted file mode 100644
index 61a43a2b1..000000000
--- a/LanguageExt.Pipes/Extensions/Extensions.MapApply.cs
+++ /dev/null
@@ -1,90 +0,0 @@
-using System;
-using LanguageExt.Traits;
-using LanguageExt.Pipes;
-
-namespace LanguageExt;
-
-public static partial class ProxyExtensions
-{
-    /// <summary>
-    /// Functor map operation
-    /// </summary>
-    /// <remarks>
-    /// Unwraps the value within the functor, passes it to the map function `f` provided, and
-    /// then takes the mapped value and wraps it back up into a new functor.
-    /// </remarks>
-    /// <param name="ma">Functor to map</param>
-    /// <param name="f">Mapping function</param>
-    /// <returns>Mapped functor</returns>
-    public static Proxy<UOut, UIn, DIn, DOut, M, B> Map<UOut, UIn, DIn, DOut, M, A, B>(
-        this Func<A, B> f, 
-        K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma) 
-        where M : Monad<M> =>
-        Functor.map(f, ma).As();
-    
-    /// <summary>
-    /// Functor map operation
-    /// </summary>
-    /// <remarks>
-    /// Unwraps the value within the functor, passes it to the map function `f` provided, and
-    /// then takes the mapped value and wraps it back up into a new functor.
-    /// </remarks>
-    /// <param name="ma">Functor to map</param>
-    /// <param name="f">Mapping function</param>
-    /// <returns>Mapped functor</returns>
-    public static Proxy<UOut, UIn, DIn, DOut, M, B> Map<UOut, UIn, DIn, DOut, M, A, B>(
-        this Func<A, B> f, 
-        Proxy<UOut, UIn, DIn, DOut, M, A> ma) 
-        where M : Monad<M> =>
-        Functor.map(f, ma).As();
-    
-    /// <summary>
-    /// Applicative action: runs the first applicative, ignores the result, and returns the second applicative
-    /// </summary>
-    public static Proxy<UOut, UIn, DIn, DOut, M, B> Action<UOut, UIn, DIn, DOut, M, A, B>(
-        this Proxy<UOut, UIn, DIn, DOut, M, A> ma, 
-        K<Proxy<UOut, UIn, DIn, DOut, M>, B> mb) 
-        where M : Monad<M> =>
-        Applicative.action(ma, mb).As();
-    
-    /// <summary>
-    /// Applicative action: runs the first applicative, ignores the result, and returns the second applicative
-    /// </summary>
-    public static Proxy<UOut, UIn, DIn, DOut, M, B> Action<UOut, UIn, DIn, DOut, M, A, B>(
-        this K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma, 
-        K<Proxy<UOut, UIn, DIn, DOut, M>, B> mb) 
-        where M : Monad<M> =>
-        Applicative.action(ma, mb).As();
-
-    /// <summary>
-    /// Applicative functor apply operation
-    /// </summary>
-    /// <remarks>
-    /// Unwraps the value within the `ma` applicative-functor, passes it to the unwrapped function(s) within `mf`, and
-    /// then takes the resulting value and wraps it back up into a new applicative-functor.
-    /// </remarks>
-    /// <param name="ma">Value(s) applicative functor</param>
-    /// <param name="mf">Mapping function(s)</param>
-    /// <returns>Mapped applicative functor</returns>
-    public static Proxy<UOut, UIn, DIn, DOut, M, B> Apply<UOut, UIn, DIn, DOut, M, A, B>(
-        this Proxy<UOut, UIn, DIn, DOut, M, Func<A, B>> mf, 
-        K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma) 
-        where M : Monad<M> =>
-        Applicative.apply(mf, ma).As();
-
-    /// <summary>
-    /// Applicative functor apply operation
-    /// </summary>
-    /// <remarks>
-    /// Unwraps the value within the `ma` applicative-functor, passes it to the unwrapped function(s) within `mf`, and
-    /// then takes the resulting value and wraps it back up into a new applicative-functor.
-    /// </remarks>
-    /// <param name="ma">Value(s) applicative functor</param>
-    /// <param name="mf">Mapping function(s)</param>
-    /// <returns>Mapped applicative functor</returns>
-    public static Proxy<UOut, UIn, DIn, DOut, M, B> Apply<UOut, UIn, DIn, DOut, M, A, B>(
-        this K<Proxy<UOut, UIn, DIn, DOut, M>, Func<A, B>> mf, 
-        K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma) 
-        where M : Monad<M> =>
-        Applicative.apply(mf, ma).As();
-}    
diff --git a/LanguageExt.Pipes/Extensions/Extensions.cs b/LanguageExt.Pipes/Extensions/Extensions.cs
deleted file mode 100644
index 9146a9874..000000000
--- a/LanguageExt.Pipes/Extensions/Extensions.cs
+++ /dev/null
@@ -1,124 +0,0 @@
-using System;
-using LanguageExt.Pipes;
-using System.Diagnostics.Contracts;
-using System.Runtime.CompilerServices;
-using LanguageExt.Traits;
-
-namespace LanguageExt;
-
-public static partial class ProxyExtensions
-{
-    public static Proxy<UOut, UIn, DIn, DOut, M, A> As<UOut, UIn, DIn, DOut, M, A>(
-        this K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma)
-        where M : Monad<M> =>
-        (Proxy<UOut, UIn, DIn, DOut, M, A>)ma;
-
-    [Pure]
-    public static Effect<M, A> As<M, A>(
-        this K<Proxy<Void, Unit, Unit, Void, M>, A> ma)
-        where M : Monad<M> =>
-        ma switch
-        {
-            Effect<M, A> e                        => e,
-            Proxy<Void, Unit, Unit, Void, M, A> p => new Effect<M, A>(p),
-            _                                     => throw new InvalidCastException($"Expected an Effect or Proxy<Void, Unit, Unit, Void, M, A>, but got: {ma.GetType()}")
-        };
-    
-    public static Producer<OUT, M, A> As<OUT, M, A>(
-        this K<Proxy<Void, Unit, Unit, OUT, M>, A> ma)
-        where M : Monad<M> =>
-        ma switch
-        {
-            Producer<OUT, M, A> p                => p,
-            Proxy<Void, Unit, Unit, OUT, M, A> p => new Producer<OUT, M, A>(p),
-            _                                    => throw new InvalidCastException($"Expected a Producer or Proxy<Void, Unit, Unit, OUT, M, A>, but got: {ma.GetType()}")
-        };
-    
-    public static Consumer<IN, M, A> As<IN, M, A>(
-        this K<Proxy<Unit, IN, Unit, Void, M>, A> ma)
-        where M : Monad<M> =>
-        ma switch
-        {
-            Consumer<IN, M, A> c                => c,
-            Proxy<Unit, IN, Unit, Void, M, A> p => new Consumer<IN, M, A>(p),
-            _                                   => throw new InvalidCastException($"Expected a Consumer or Proxy<Unit, IN, Unit, Void, M, A>, but got: {ma.GetType()}")
-        };
-    
-    public static Pipe<IN, OUT, M, A> As<IN, OUT, M, A>(
-        this K<Proxy<Unit, IN, Unit, OUT, M>, A> ma)
-        where M : Monad<M> =>
-        ma switch
-        {
-            Pipe<IN, OUT, M, A> p              => p,
-            Proxy<Unit, IN, Unit, OUT, M, A> p => new Pipe<IN, OUT, M, A>(p),
-            _                                  => throw new InvalidCastException($"Expected a Pipe or Proxy<Unit, IN, Unit, OUT, M, A>, but got: {ma.GetType()}")
-        };
-    
-    public static Client<REQ, RES, M, A> As<REQ, RES, M, A>(
-        this K<Proxy<REQ, RES,  Unit, Void, M>, A> ma)
-        where M : Monad<M> =>
-        ma switch
-        {
-            Client<REQ, RES, M, A> c            => c,
-            Proxy<REQ, RES, Unit, Void, M, A> p => new Client<REQ, RES, M, A>(p),
-            _                                   => throw new InvalidCastException($"Expected a Client or Proxy<REQ, RES, Unit, Void, M, A>, but got: {ma.GetType()}")
-        };
-    
-    public static Server<REQ, RES, M, A> As<REQ, RES, M, A>(
-        this K<Proxy<Void, Unit, REQ, RES, M>, A> ma)
-        where M : Monad<M> =>
-        ma switch
-        {
-            Server<REQ, RES, M, A> s            => s,
-            Proxy<Void, Unit, REQ, RES, M, A> p => new Server<REQ, RES, M, A>(p),
-            _                                   => throw new InvalidCastException($"Expected a Server Proxy<Void, Unit, REQ, RES, M, A>, but got: {ma.GetType()}")
-        };
-    
-    /// <summary>
-    /// Converts a `Proxy` with the correct _shape_ into an `Effect`
-    /// </summary>
-    [Pure]
-    public static Effect<M, R> ToEffect<M, R>(this Proxy<Void, Unit, Unit, Void, M, R> ma) 
-        where M : Monad<M> =>
-        ma as Effect<M, R> ?? new Effect<M, R>(ma);
-        
-    /// <summary>
-    /// Converts a `Proxy` with the correct _shape_ into a `Producer`
-    /// </summary>
-    [Pure]
-    public static Producer<A, M, R> ToProducer<A, M, R>(this Proxy<Void, Unit, Unit, A, M, R> ma) 
-        where M : Monad<M> =>
-        ma as Producer<A, M, R> ?? new Producer<A, M, R>(ma);
-        
-    /// <summary>
-    /// Converts a `Proxy` with the correct _shape_ into a `Consumer`
-    /// </summary>
-    [Pure]
-    public static Consumer<A, M, R> ToConsumer<A, M, R>(this Proxy<Unit, A, Unit, Void, M, R> ma) 
-        where M : Monad<M> =>
-        ma as Consumer<A, M, R> ?? new Consumer<A, M, R>(ma);
-
-    /// <summary>
-    /// Converts a `Proxy` with the correct _shape_ into n `Pipe`
-    /// </summary>
-    [Pure]
-    public static Pipe<A, B, M, R> ToPipe<A, B, M, R>(this Proxy<Unit, A, Unit, B, M, R> ma) 
-        where M : Monad<M> =>
-        ma as Pipe<A, B, M, R> ?? new Pipe<A, B, M, R>(ma);
-        
-    /// <summary>
-    /// Converts a `Proxy` with the correct _shape_ into a `Client`
-    /// </summary>
-    [Pure]
-    public static Client<A, B, M, R> ToClient<A, B, M, R>(this Proxy<A, B, Unit, Void, M, R> ma) 
-        where M : Monad<M> =>
-        ma as Client<A, B, M, R> ?? new Client<A, B, M, R>(ma);
-        
-    /// <summary>
-    /// Converts a `Proxy` with the correct _shape_ into a `Server`
-    /// </summary>
-    [Pure]
-    public static Server<A, B, M, R> ToServer<A, B, M, R>(this Proxy<Void, Unit, A, B, M, R> ma) 
-        where M : Monad<M> =>
-        ma as Server<A, B, M, R> ?? new Server<A, B, M, R>(ma);
-}
diff --git a/LanguageExt.Pipes/Extensions/LINQ.cs b/LanguageExt.Pipes/Extensions/LINQ.cs
deleted file mode 100644
index 9b107aace..000000000
--- a/LanguageExt.Pipes/Extensions/LINQ.cs
+++ /dev/null
@@ -1,162 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Pipes;
-using LanguageExt.Traits;
-
-namespace LanguageExt;
-
-public static partial class ProxyExtensions
-{
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Producer<OUT, M, B> Bind<OUT, A, M, B>(
-        this Proxy<Void, Unit, Unit, OUT, M, A> ma, 
-        Func<A, Producer<OUT, M, B>> f) 
-        where M : Monad<M> =>
-        ma.Bind(f).ToProducer();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Consumer<IN, M, B> Bind<IN, A, M, B>(
-        this Proxy<Unit, IN, Unit, Void, M, A> ma, 
-        Func<A, Consumer<IN, M, B>> f) 
-        where M : Monad<M> =>
-        ma.Bind(f).ToConsumer();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Pipe<IN, OUT, M, B> Bind<IN, OUT, A, M, B>(
-        this Proxy<Unit, IN, Unit, OUT, M, A> ma, 
-        Func<A, Pipe<IN, OUT, M, B>> f) 
-        where M : Monad<M> =>
-        ma.Bind(f).ToPipe();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Client<REQ, RES, M, B> Bind<REQ, RES, A, M, B>(
-        this Proxy<REQ, RES, Unit, Void, M, A> ma, 
-        Func<A, Client<REQ, RES, M, B>> f) 
-        where M : Monad<M> =>
-        ma.Bind(f).ToClient();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Server<REQ, RES, M, B> Bind<REQ, RES, A, M, B>(
-        this Proxy<Void, Unit, REQ, RES, M, A> ma, 
-        Func<A, Server<REQ, RES, M, B>> f) 
-        where M : Monad<M> =>
-        ma.Bind(f).ToServer();
-
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Producer<OUT, M, B> SelectMany<OUT, A, M, B>(
-        this Proxy<Void, Unit, Unit, OUT, M, A> ma, 
-        Func<A, Producer<OUT, M, B>> f) 
-        where M : Monad<M> =>
-        ma.Bind(f).ToProducer();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Consumer<IN, M, B> SelectMany<IN, A, M, B>(
-        this Proxy<Unit, IN, Unit, Void, M, A> ma, 
-        Func<A, Consumer<IN, M, B>> f) 
-        where M : Monad<M> =>
-        ma.Bind(f).ToConsumer();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Pipe<IN, OUT, M, B> SelectMany<IN, OUT, A, M, B>(
-        this Proxy<Unit, IN, Unit, OUT, M, A> ma, 
-        Func<A, Pipe<IN, OUT, M, B>> f) 
-        where M : Monad<M> =>
-        ma.Bind(f).ToPipe();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Client<REQ, RES, M, B> SelectMany<REQ, RES, A, M, B>(
-        this Proxy<REQ, RES, Unit, Void, M, A> ma, 
-        Func<A, Client<REQ, RES, M, B>> f) 
-        where M : Monad<M> =>
-        ma.Bind(f).ToClient();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Server<REQ, RES, M, B> SelectMany<REQ, RES, A, M, B>(
-        this Proxy<Void, Unit, REQ, RES, M, A> ma, Func<A, Server<REQ, RES, M, B>> f) 
-        where M : Monad<M> =>
-        ma.Bind(f).ToServer();
-
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Producer<OUT, M, C> SelectMany<OUT, A, B, M, C>(
-        this Proxy<Void, Unit, Unit, OUT, M, A> ma, Func<A, Producer<OUT, M, B>> f, 
-        Func<A, B, C> project) 
-        where M : Monad<M> =>
-        ma.Bind(a => f(a).Map(b => project(a, b))).ToProducer();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Consumer<IN, M, C> SelectMany<IN, A, B, M, C>(
-        this Proxy<Unit, IN, Unit, Void, M, A> ma, 
-        Func<A, Consumer<IN, M, B>> f, Func<A, B, C> project) 
-        where M : Monad<M> =>
-        ma.Bind(a => f(a).Map(b => project(a, b))).ToConsumer();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Pipe<IN, OUT, M, C> SelectMany<IN, OUT, A, B, M, C>(
-        this Proxy<Unit, IN, Unit, OUT, M, A> ma, 
-        Func<A, Pipe<IN, OUT, M, B>> f, 
-        Func<A, B, C> project) 
-        where M : Monad<M> =>
-        ma.Bind(a => f(a).Map(b => project(a, b))).ToPipe();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Client<REQ, RES, M, C> SelectMany<REQ, RES, A, B, M, C>(
-        this Proxy<REQ, RES, Unit, Void, M, A> ma, 
-        Func<A, Client<REQ, RES, M, B>> f, 
-        Func<A, B, C> project) 
-        where M : Monad<M> =>
-        ma.Bind(a => f(a).Map(b => project(a, b))).ToClient();
-        
-    /// <summary>
-    /// Monad bind (specialised)
-    /// </summary>
-    [Pure]
-    public static Server<REQ, RES, M, C> SelectMany<REQ, RES, A, B, M, C>(
-        this Proxy<Void, Unit, REQ, RES, M, A> ma, 
-        Func<A, Server<REQ, RES, M, B>> f, Func<A, B, C> project) 
-        where M : Monad<M> =>
-        ma.Bind(a => f(a).Map(b => project(a, b))).ToServer();
-}
diff --git a/LanguageExt.Pipes/Iterator/CoreTypes.cs b/LanguageExt.Pipes/Iterator/CoreTypes.cs
deleted file mode 100644
index c3cfd5986..000000000
--- a/LanguageExt.Pipes/Iterator/CoreTypes.cs
+++ /dev/null
@@ -1,229 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using System.Linq;
-using System.Threading.Tasks;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-public abstract record Iterator<UOut, UIn, DIn, DOut, M, A>(
-    Func<Proxy<UOut, UIn, DIn, DOut, M, A>> Next) 
-    : Proxy<UOut, UIn, DIn, DOut, M, A>
-    where M : Monad<M>
-{
-    public abstract IEnumerable<Proxy<UOut, UIn, DIn, DOut, M, Unit>> Run();
-}
-
-public abstract record IteratorAsync<UOut, UIn, DIn, DOut, M, A>(
-    Func<Proxy<UOut, UIn, DIn, DOut, M, A>> Next) 
-    : Proxy<UOut, UIn, DIn, DOut, M, A>
-    where M : Monad<M>
-{
-    public abstract IAsyncEnumerable<Proxy<UOut, UIn, DIn, DOut, M, Unit>> Run();
-}
-
-public record IteratorFoldable<UOut, UIn, DIn, DOut, F, X, M, A>(
-    K<F, X> Items,
-    Func<X, Proxy<UOut, UIn, DIn, DOut, M, Unit>> Yield,
-    Func<Proxy<UOut, UIn, DIn, DOut, M, A>> Next) 
-    : Iterator<UOut, UIn, DIn, DOut, M, A>(Next)
-    where M : Monad<M>
-    where F : Foldable<F>
-{
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> ToProxy() =>
-        this;
-
-    public override IEnumerable<Proxy<UOut, UIn, DIn, DOut, M, Unit>> Run()
-    {
-        foreach (var item in Items.ToIterable())
-        {
-            yield return Yield(item);
-        }
-    }
-    
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Bind<B>(
-        Func<A, Proxy<UOut, UIn, DIn, DOut, M, B>> f) =>
-        new IteratorFoldable<UOut, UIn, DIn, DOut, F, X, M, B>(
-            Items,
-            Yield,
-            () => Next().Bind(f));
-    
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Map<B>(
-        Func<A, B> f) =>
-        new IteratorFoldable<UOut, UIn, DIn, DOut, F, X, M, B>(
-            Items,
-            Yield,
-            () => Next().Map(f));
-    
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> MapM<B>(
-        Func<K<M, A>, K<M, B>> f) =>
-        new IteratorFoldable<UOut, UIn, DIn, DOut, F, X, M, B>(
-            Items,
-            Yield,
-            () => Next().MapM(f));
-            
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, IO<A>> ToIO() =>
-        new IteratorFoldable<UOut, UIn, DIn, DOut, F, X, M, IO<A>>(
-            Items,
-            Yield,
-            () => Next().ToIO());
-
-    public override Proxy<UOut, UIn, C1, C, M, A> For<C1, C>(
-        Func<DOut, Proxy<UOut, UIn, C1, C, M, DIn>> body) =>
-        ReplaceRespond(body);
-    
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Action<B>(
-        Proxy<UOut, UIn, DIn, DOut, M, B> r) =>
-        new IteratorFoldable<UOut, UIn, DIn, DOut, F, X, M, B>(
-            Items,
-            Yield,
-            () => Next().Action(r));    
-    
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, UOut, UIn, M, A>> lhs) =>
-        new IteratorFoldable<UOutA, AUInA, DIn, DOut, F, X, M, A>(
-            Items,
-            c1 => Yield(c1).PairEachRequestWithRespond(x => lhs(x).Map(_ => Prelude.unit)),
-            () => Next().PairEachRequestWithRespond(lhs));
-    
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, DIn, DOut, M, UIn>> lhs) =>
-        new IteratorFoldable<UOutA, AUInA, DIn, DOut, F, X, M, A>(
-            Items,
-            c1 => Yield(c1).ReplaceRequest(lhs),                
-            () => Next().ReplaceRequest(lhs));
-    
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<DOut, Proxy<DIn, DOut, DInC, DOutC, M, A>> rhs) =>
-        new IteratorFoldable<UOut, UIn, DInC, DOutC, F, X, M, A>(
-            Items,
-            c1 => Yield(c1).PairEachRespondWithRequest(x => rhs(x).Map(_ => Prelude.unit)),
-            () => Next().PairEachRespondWithRequest(rhs));
-    
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<DOut, Proxy<UOut, UIn, DInC, DOutC, M, DIn>> rhs) =>
-        new IteratorFoldable<UOut, UIn, DInC, DOutC, F, X, M, A>(
-            Items,
-            c1 => Yield(c1).ReplaceRespond(rhs),
-            () => Next().ReplaceRespond(rhs));
-    
-    public override Proxy<DOut, DIn, UIn, UOut, M, A> Reflect() =>
-        new IteratorFoldable<DOut, DIn, UIn, UOut, F, X, M, A>(
-            Items, 
-            x => Yield(x).Reflect(),
-            () => Next().Reflect());
-    
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> Observe() =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, A>(M.Pure<Proxy<UOut, UIn, DIn, DOut, M, A>>(this));
-}
-
-public record IteratorAsyncEnumerable<UOut, UIn, DIn, DOut, F, X, M, A>(
-    IAsyncEnumerable<X> Items,
-    Func<X, Proxy<UOut, UIn, DIn, DOut, M, Unit>> Yield,
-    Func<Proxy<UOut, UIn, DIn, DOut, M, A>> Next) 
-    : IteratorAsync<UOut, UIn, DIn, DOut, M, A>(Next)
-    where M : Monad<M>
-    where F : Foldable<F>
-{
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> ToProxy() =>
-        this;
-
-    public override async IAsyncEnumerable<Proxy<UOut, UIn, DIn, DOut, M, Unit>> Run()
-    {
-        await foreach (var item in Items)
-        {
-            yield return Yield(item);
-        }
-    }
-    
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Bind<B>(
-        Func<A, Proxy<UOut, UIn, DIn, DOut, M, B>> f) =>
-        new IteratorAsyncEnumerable<UOut, UIn, DIn, DOut, F, X, M, B>(
-            Items,
-            Yield,
-            () => Next().Bind(f));
-    
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Map<B>(
-        Func<A, B> f) =>
-        new IteratorAsyncEnumerable<UOut, UIn, DIn, DOut, F, X, M, B>(
-            Items,
-            Yield,
-            () => Next().Map(f));
-    
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> MapM<B>(
-        Func<K<M, A>, K<M, B>> f) =>
-        new IteratorAsyncEnumerable<UOut, UIn, DIn, DOut, F, X, M, B>(
-            Items,
-            Yield,
-            () => Next().MapM(f));
-            
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, IO<A>> ToIO() =>
-        new IteratorAsyncEnumerable<UOut, UIn, DIn, DOut, F, X, M, IO<A>>(
-            Items,
-            Yield,
-            () => Next().ToIO());
-
-    public override Proxy<UOut, UIn, C1, C, M, A> For<C1, C>(
-        Func<DOut, Proxy<UOut, UIn, C1, C, M, DIn>> body) =>
-        ReplaceRespond(body);
-    
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Action<B>(
-        Proxy<UOut, UIn, DIn, DOut, M, B> r) =>
-        new IteratorAsyncEnumerable<UOut, UIn, DIn, DOut, F, X, M, B>(
-            Items,
-            Yield,
-            () => Next().Action(r));    
-    
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, UOut, UIn, M, A>> lhs) =>
-        new IteratorAsyncEnumerable<UOutA, AUInA, DIn, DOut, F, X, M, A>(
-            Items,
-            c1 => Yield(c1).PairEachRequestWithRespond(x => lhs(x).Map(_ => Prelude.unit)),
-            () => Next().PairEachRequestWithRespond(lhs));
-    
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, DIn, DOut, M, UIn>> lhs) =>
-        new IteratorAsyncEnumerable<UOutA, AUInA, DIn, DOut, F, X, M, A>(
-            Items,
-            c1 => Yield(c1).ReplaceRequest(lhs),                
-            () => Next().ReplaceRequest(lhs));
-    
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<DOut, Proxy<DIn, DOut, DInC, DOutC, M, A>> rhs) =>
-        new IteratorAsyncEnumerable<UOut, UIn, DInC, DOutC, F, X, M, A>(
-            Items,
-            c1 => Yield(c1).PairEachRespondWithRequest(x => rhs(x).Map(_ => Prelude.unit)),
-            () => Next().PairEachRespondWithRequest(rhs));
-    
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<DOut, Proxy<UOut, UIn, DInC, DOutC, M, DIn>> rhs) =>
-        new IteratorAsyncEnumerable<UOut, UIn, DInC, DOutC, F, X, M, A>(
-            Items,
-            c1 => Yield(c1).ReplaceRespond(rhs),
-            () => Next().ReplaceRespond(rhs));
-    
-    public override Proxy<DOut, DIn, UIn, UOut, M, A> Reflect() =>
-        new IteratorAsyncEnumerable<DOut, DIn, UIn, UOut, F, X, M, A>(
-            Items, 
-            x => Yield(x).Reflect(),
-            () => Next().Reflect());
-    
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> Observe() =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, A>(M.Pure<Proxy<UOut, UIn, DIn, DOut, M, A>>(this));
-}
diff --git a/LanguageExt.Pipes/Pipe/CoreTypes.cs b/LanguageExt.Pipes/Pipe/CoreTypes.cs
deleted file mode 100644
index 0ba85b53a..000000000
--- a/LanguageExt.Pipes/Pipe/CoreTypes.cs
+++ /dev/null
@@ -1,368 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// Pipes both can both be `await` and can `yield`
-/// </summary>
-/// <remarks>
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     Unit〈==      〈== Unit
-///           |         |
-///      IN  ==〉      ==〉OUT
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public record Pipe<IN, OUT, M, A> : Proxy<Unit, IN, Unit, OUT, M, A> 
-    where M : Monad<M>
-{
-    public readonly Proxy<Unit, IN, Unit, OUT, M, A> Value;
-        
-    /// <summary>
-    /// Constructor
-    /// </summary>
-    /// <param name="value">Correctly shaped `Proxy` that represents a `Pipe`</param>
-    public Pipe(Proxy<Unit, IN, Unit, OUT, M, A> value) =>
-        Value = value;
-        
-    /// <summary>
-    /// Calling this will effectively cast the sub-type to the base.
-    /// </summary>
-    /// <remarks>This type wraps up a `Proxy` for convenience, and so it's a `Proxy` proxy.  So calling this method
-    /// isn't exactly the same as a cast operation, as it unwraps the `Proxy` from within.  It has the same effect
-    /// however, and removes a level of indirection</remarks>
-    /// <returns>A general `Proxy` type from a more specialised type</returns>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, OUT, M, A> ToProxy() =>
-        Value.ToProxy();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, OUT, M, S> Bind<S>(
-        Func<A, Proxy<Unit, IN, Unit, OUT, M, S>> f) =>
-        Value.Bind(f);
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Pipe<IN, OUT, M, B> Bind<B>(Func<A, K<M, B>> f) =>
-        Value.Bind(x => Pipe.lift<IN, OUT, M, B>(f(x))).ToPipe();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Pipe<IN, OUT, M, B> Bind<B>(Func<A, IO<B>> f) =>
-        Value.Bind(x => Pipe.liftIO<IN, OUT, M, B>(f(x))).ToPipe();
-            
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, OUT, M, B> Map<B>(Func<A, B> f) =>
-        Value.Map(f);
-
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, OUT, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
-        Value.MapM(f);
-        
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, OUT, M, IO<A>> ToIO() =>
-        Value.ToIO();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Pipe<IN, OUT, M, B> Bind<B>(Func<A, Pipe<IN, OUT, M, B>> f) => 
-        Value.Bind(f).ToPipe();
-        
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public new Pipe<IN, OUT, M, B> Select<B>(Func<A, B> f) => 
-        Value.Map(f).ToPipe();        
-
-    /// <summary>
-    /// `For(body)` loops over the `Proxy p` replacing each `yield` with `body`
-    /// </summary>
-    /// <param name="body">Any `yield` found in the `Proxy` will be replaced with this function.  It will be composed so
-    /// that the value yielded will be passed to the argument of the function.  That returns a `Proxy` to continue the
-    /// processing of the computation</param>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the function provided</returns>
-    [Pure]
-    public override Proxy<Unit, IN, C1, C, M, A> For<C1, C>(
-        Func<OUT, Proxy<Unit, IN, C1, C, M, Unit>> body) =>
-        Value.For(body);
-
-    /// <summary>
-    /// Applicative action
-    ///
-    /// Invokes this `Proxy`, then the `Proxy r` 
-    /// </summary>
-    /// <param name="r">`Proxy` to run after this one</param>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, OUT, M, S> Action<S>(Proxy<Unit, IN, Unit, OUT, M, S> r) =>
-        Value.Action(r);
-
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, OUT, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<Unit, Proxy<UOutA, AUInA, Unit, IN, M, A>> lhs) =>
-        Value.PairEachRequestWithRespond(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, OUT, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<Unit, Proxy<UOutA, AUInA, Unit, OUT, M, IN>> lhs) =>
-        Value.ReplaceRequest(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<Unit, IN, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<OUT, Proxy<Unit, OUT, DInC, DOutC, M, A>> rhs) =>
-        Value.PairEachRespondWithRequest(rhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<Unit, IN, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<OUT, Proxy<Unit, IN, DInC, DOutC, M, Unit>> rhs) =>
-        Value.ReplaceRespond(rhs);
-
-    /// <summary>
-    /// Reverse the arrows of the `Proxy` to find its dual.  
-    /// </summary>
-    /// <returns>The dual of `this`</returns>
-    [Pure]
-    public override Proxy<OUT, Unit, IN, Unit, M, A> Reflect() =>
-        Value.Reflect();
-
-    /// <summary>
-    /// 
-    ///     Observe(lift (Pure(r))) = Observe(Pure(r))
-    ///     Observe(lift (m.Bind(f))) = Observe(lift(m.Bind(x => lift(f(x)))))
-    /// 
-    /// This correctness comes at a small cost to performance, so use this function sparingly.
-    /// This function is a convenience for low-level pipes implementers.  You do not need to
-    /// use observe if you stick to the safe API.        
-    /// </summary>
-    [Pure]
-    public override Proxy<Unit, IN, Unit, OUT, M, A> Observe() =>
-        Value.Observe();
-
-    [Pure]
-    public void Deconstruct(out Proxy<Unit, IN, Unit, OUT, M, A> value) =>
-        value = Value;
-        
-    /// <summary>
-    /// Compose a `Producer` and a `Pipe` together into a `Producer`.  
-    /// </summary>
-    /// <param name="p1">`Producer`</param>
-    /// <param name="p2">`Pipe`</param>
-    /// <returns>`Producer`</returns>
-    [Pure]
-    public static Producer<OUT, M, A> operator |(Producer<IN, M, A> p1, Pipe<IN, OUT, M, A> p2) =>
-        Proxy.compose(p1, p2);
-        
-    /// <summary>
-    /// Compose a `Producer` and a `Pipe` together into a `Producer`.  
-    /// </summary>
-    /// <param name="p1">`Producer`</param>
-    /// <param name="p2">`Pipe`</param>
-    /// <returns>`Producer`</returns>
-    [Pure]
-    public static Producer<OUT, M, A> operator |(Producer<IN, A> p1, Pipe<IN, OUT, M, A> p2) =>
-        Proxy.compose(p1, p2);
-        
-    /// <summary>
-    /// Compose a `Producer` and a `Pipe` together into a `Producer`.  
-    /// </summary>
-    /// <param name="p1">`Producer`</param>
-    /// <param name="p2">`Pipe`</param>
-    /// <returns>`Producer`</returns>
-    [Pure]
-    public static Producer<OUT, M, A> operator |(Producer<OUT, IN> p1, Pipe<IN, OUT, M, A> p2) =>
-        Proxy.compose(p1, p2);
-        
-    /// <summary>
-    /// Compose a `Pipe` and a `Consumer` together into a `Consumer`.  
-    /// </summary>
-    /// <param name="p1">`Pipe`</param>
-    /// <param name="p2">`Consumer`</param>
-    /// <returns>`Consumer`</returns>
-    [Pure]
-    public static Consumer<IN, M, A> operator |(Pipe<IN, OUT, M, A> p1, Consumer<OUT, A> p2) =>
-        Proxy.compose(p1, p2);
-        
-    /// <summary>
-    /// Compose a `Pipe` and a `Consumer` together into a `Consumer`.  
-    /// </summary>
-    /// <param name="p1">`Pipe`</param>
-    /// <param name="p2">`Consumer`</param>
-    /// <returns>`Consumer`</returns>
-    [Pure]
-    public static Consumer<IN, M, A> operator |(Pipe<IN, OUT, M, A> p1, Consumer<OUT, M, A> p2) =>
-        Proxy.compose(p1, p2);
-        
-    /// <summary>
-    /// Composition chaining of two pipes.  
-    /// </summary>
-    /// <remarks>
-    /// We can't provide the operator overloading to chain two pipes together, because operators don't have
-    /// generics of their own.  And so we can use this method to chain to pipes together.
-    /// </remarks>
-    /// <param name="pipe">Right hand side `Pipe`</param>
-    /// <typeparam name="C">Type of value that the right hand side pipe yields</typeparam>
-    /// <returns>A composition of this pipe and the `Pipe` provided</returns>
-    [Pure]
-    public Pipe<IN, C, M, A> Then<C>(Pipe<OUT, C, M, A> pipe) =>
-        Proxy.compose(this, pipe);
-
-    /// <summary>
-    /// Conversion operator from the _pure_ `Pipe` type, to the monad transformer version of the `Pipe`
-    /// </summary>
-    /// <param name="p">Pure `Pipe`</param>
-    /// <returns>Monad transformer version of the `Pipe`</returns>
-    [Pure]
-    public static implicit operator Pipe<IN, OUT, M, A>(Pipe<IN, OUT, A> p) =>
-        p.Interpret<M>();
-
-    /// <summary>
-    /// Conversion operator from the `Pure` type, to the monad transformer version of the `Pipe`
-    /// </summary>
-    /// <param name="p">`Pure` value</param>
-    /// <returns>Monad transformer version of the `Pipe`</returns>
-    [Pure]
-    public static implicit operator Pipe<IN, OUT, M, A>(Pure<A> p) =>
-        Pipe.Pure<IN, OUT, M, A>(p.Value);
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Pipe<IN, OUT, M, B> SelectMany<B>(Func<A, Pipe<IN, OUT, B>> bind) =>
-        Value.Bind(a => bind(a).Interpret<M>()).ToPipe();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Pipe<IN, OUT, M, C> SelectMany<B, C>(Func<A, Pipe<IN, OUT, B>> bind, Func<A, B, C> project) =>
-        SelectMany(a => bind(a).Select(b => project(a, b)));
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Pipe<IN, OUT, M, B> SelectMany<B>(Func<A, Pipe<IN, OUT, M, B>> f) => 
-        Value.Bind(f).ToPipe();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Pipe<IN, OUT, M, C> SelectMany<B, C>(Func<A, Pipe<IN, OUT, M, B>> f, Func<A, B, C> project) => 
-        Value.Bind(a => f(a).Map(b => project(a, b))).ToPipe();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Pipe<IN, OUT, M, C> SelectMany<B, C>(Func<A, K<M, B>> bind, Func<A, B, C> project) =>
-        Bind(x => M.Map(y => project(x, y), bind(x)));
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Pipe<IN, OUT, M, C> SelectMany<B, C>(Func<A, IO<B>> bind, Func<A, B, C> project) =>
-        Bind(x => bind(x).Map(y => project(x, y)));
-
-    /// <summary>
-    /// Chain one pipe's set of awaits and yields after another
-    /// </summary>
-    [Pure]
-    public static Pipe<IN, OUT, M, A> operator &(
-        Pipe<IN, OUT, M, A> lhs,
-        Pipe<IN, OUT, M, A> rhs) =>
-        lhs.Bind(_ => rhs);
-    
-    [Pure]
-    public override string ToString() => 
-        "pipe";
-}
diff --git a/LanguageExt.Pipes/Pipe/Pipe.cs b/LanguageExt.Pipes/Pipe/Pipe.cs
deleted file mode 100644
index 5cbe5eb12..000000000
--- a/LanguageExt.Pipes/Pipe/Pipe.cs
+++ /dev/null
@@ -1,219 +0,0 @@
-using System;
-using static LanguageExt.Prelude;
-using System.Diagnostics.Contracts;
-using static LanguageExt.Pipes.Proxy;
-using System.Runtime.CompilerServices;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// Pipes both can both be `await` and can `yield`
-/// </summary>
-/// <remarks>
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     Unit〈==      〈== Unit
-///           |         |
-///      IN  ==〉      ==〉OUT
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public static class Pipe
-{
-    /// <summary>
-    /// Monad return / pure
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<A, B, M, R> Pure<A, B, M, R>(R value) where M : Monad<M> =>
-        new Pure<Unit, A, Unit, B, M, R>(value).ToPipe();
-        
-    /// <summary>
-    /// Wait for a value from upstream (whilst in a pipe)
-    /// </summary>
-    /// <remarks>
-    /// This is the version of `await` that works for pipes.  In consumers, use `Consumer.await`
-    /// </remarks>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<A, Y, M, A> awaiting<M, A, Y>() 
-        where M : Monad<M> =>
-        request<Unit, A, Unit, Y, M>(unit).ToPipe();
-        
-    /// <summary>
-    /// Send a value downstream (whilst in a pipe)
-    /// </summary>
-    /// <remarks>
-    /// This is the version of `yield` that works for pipes.  In producers, use `Producer.yield`
-    /// </remarks>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<IN, OUT, M, Unit> yield<IN, OUT, M>(OUT value) 
-        where M : Monad<M> =>
-        respond<Unit, IN, Unit, OUT, M>(value).ToPipe();
-
-    /// <summary>
-    /// Only forwards values that satisfy the predicate.
-    /// </summary>
-    public static Pipe<A, A, M, Unit> filter<M, A>(Func<A, bool> f) 
-        where M : Monad<M> =>
-        cat<A, M, Unit>().For(a => f(a)
-                                       ? yield<A, A, M>(a)
-                                       : Pure<A, A, M, Unit>(default))
-                         .ToPipe();
-
-    /// <summary>
-    /// Map the output of the pipe (not the bound value as is usual with Map)
-    /// </summary>
-    public static Pipe<A, B, M, R> map<A, B, M, R>(Func<A, B> f) 
-        where M : Monad<M> =>
-        cat<A, M, R>().For(a => yield<A, B, M>(f(a))).ToPipe();
-
-    /// <summary>
-    /// Map the output of the pipe (not the bound value as is usual with Map)
-    /// </summary>
-    public static Pipe<A, B, M, Unit> map<A, M, B>(Func<A, B> f) 
-        where M : Monad<M> =>
-        cat<A, M, Unit>().For(a => yield<A, B, M>(f(a))).ToPipe();
-
-    /// <summary>
-    /// Map the output of the pipe (not the bound value as is usual with Map)
-    /// </summary>
-    public static Pipe<A, B, Unit> map<A, B>(Func<A, B> f) =>
-        new Pipe<A, B, Unit>.Await(x => new Pipe<A, B, Unit>.Yield(f(x), PureProxy.PipePure<A, B, Unit>));
-    
-    /// <summary>
-    /// Apply a monadic function to all values flowing downstream (not the bound value as is usual with Map)
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<A, B, M, R> mapM<A, B, M, R>(Func<A, K<M, B>> f) where M : Monad<M> =>
-        cat<A, M, R>()
-           .ForEach(a => lift<A, B, M, B>(f(a)).Bind(x => yield<A, B, M>(x)).ToPipe());
-    
-    /// <summary>
-    /// Lift the IO monad into the Pipe monad transformer (a specialism of the Proxy monad transformer)
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<A, B, M, R> lift<A, B, M, R>(K<M, R> ma) 
-        where M : Monad<M> =>
-        lift<Unit, A, Unit, B, M, R>(ma).ToPipe(); 
- 
-    /// <summary>
-    /// Lift the IO monad into the Pipe monad transformer (a specialism of the Proxy monad transformer)
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<A, B, M, R> liftIO<A, B, M, R>(IO<R> ma) 
-        where M : Monad<M> =>
-        liftIO<Unit, A, Unit, B, M, R>(ma).ToPipe(); 
-
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns false the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="WhileState">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<IN, OUT, M, Unit> foldWhile<IN, OUT, M>(
-        OUT Initial, 
-        Func<OUT, IN, OUT> Fold, 
-        Func<OUT, bool> WhileState) 
-        where M : Monad<M> =>
-        foldUntil<IN, OUT, M>(Initial, Fold, x => !WhileState(x));
- 
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns true the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="UntilState">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    public static Pipe<IN, OUT, M, Unit> foldUntil<IN, OUT, M>(
-        OUT Initial, 
-        Func<OUT, IN, OUT> Fold, 
-        Func<OUT, bool> UntilState)
-        where M : Monad<M>
-    {
-        var state = Initial;
-        return awaiting<M, IN, OUT>()
-                   .Bind(x =>
-                         {
-                             state = Fold(state, x);
-                             if (UntilState(state))
-                             {
-                                 var nstate = state;
-                                 state = Initial;
-                                 return yield<IN, OUT, M>(nstate);
-                             }
-                             else
-                             {
-                                 return Pure<IN, OUT, M, Unit>(unit);
-                             }
-                         })
-                   .ToPipe();
-    }
-
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns false the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="WhileValue">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<IN, OUT, M, Unit> foldWhile<IN, OUT, M>(
-        OUT Initial
-      , Func<OUT, IN, OUT> Fold, 
-        Func<IN, bool> WhileValue) 
-        where M : Monad<M> =>
-        foldUntil<IN, OUT, M>(Initial, Fold, x => !WhileValue(x));
- 
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns true the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="UntilValue">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    public static Pipe<IN, OUT, M, Unit> foldUntil<IN, OUT, M>(
-        OUT Initial, 
-        Func<OUT, IN, OUT> Fold, 
-        Func<IN, bool> UntilValue)
-        where M : Monad<M>
-    {
-        var state = Initial;
-        return awaiting<M, IN, OUT>()
-                   .Bind(x =>
-                         {
-                             if (UntilValue(x))
-                             {
-                                 var nstate = state;
-                                 state = Initial;
-                                 return yield<IN, OUT, M>(nstate);
-                             }
-                             else
-                             {
-                                 state = Fold(state, x);
-                                 return Pure<IN, OUT, M, Unit>(unit);
-                             }
-                         })
-                   .ToPipe();
-    }
-
-    /// <summary>
-    /// Strict left scan
-    /// </summary>
-    public static Pipe<IN, OUT, M, Unit> scan<IN, OUT, M, S>(Func<S, IN, S> Step, S Begin, Func<S, OUT> Done)
-        where M : Monad<M>
-    {
-        return go(Begin);
-
-        Pipe<IN, OUT, M, Unit> go(S x) =>
-            from _ in yield<IN, OUT, M>(Done(x))
-            from a in awaiting<M, IN, OUT>()
-            let x1 = Step(x, a)
-            from r in go(x1)
-            select r;
-    }
-}
diff --git a/Samples/PipesExamples/PipeT/PipeT.Cached.cs b/LanguageExt.Pipes/PipeT/PipeT.Cached.cs
similarity index 86%
rename from Samples/PipesExamples/PipeT/PipeT.Cached.cs
rename to LanguageExt.Pipes/PipeT/PipeT.Cached.cs
index b87162ef8..0cabfcaf3 100644
--- a/Samples/PipesExamples/PipeT/PipeT.Cached.cs
+++ b/LanguageExt.Pipes/PipeT/PipeT.Cached.cs
@@ -1,6 +1,6 @@
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 class PipeTCached<IN, OUT, M>
     where M : Monad<M>
diff --git a/Samples/PipesExamples/PipeT/PipeT.DSL.cs b/LanguageExt.Pipes/PipeT/PipeT.DSL.cs
similarity index 99%
rename from Samples/PipesExamples/PipeT/PipeT.DSL.cs
rename to LanguageExt.Pipes/PipeT/PipeT.DSL.cs
index d1f390791..4b1201cde 100644
--- a/Samples/PipesExamples/PipeT/PipeT.DSL.cs
+++ b/LanguageExt.Pipes/PipeT/PipeT.DSL.cs
@@ -1,7 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 using LanguageExt.Async.Linq;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 record PipeTEmpty<IN, OUT, M, A> : PipeT<IN, OUT, M, A>
     where M : Monad<M>, MonoidK<M>
diff --git a/Samples/PipesExamples/PipeT/PipeT.Extensions.cs b/LanguageExt.Pipes/PipeT/PipeT.Extensions.cs
similarity index 98%
rename from Samples/PipesExamples/PipeT/PipeT.Extensions.cs
rename to LanguageExt.Pipes/PipeT/PipeT.Extensions.cs
index 83b51186b..a8062e9fe 100644
--- a/Samples/PipesExamples/PipeT/PipeT.Extensions.cs
+++ b/LanguageExt.Pipes/PipeT/PipeT.Extensions.cs
@@ -1,6 +1,7 @@
+using System;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 public static class PipeTExtensions
 {
diff --git a/Samples/PipesExamples/PipeT/PipeT.Module.cs b/LanguageExt.Pipes/PipeT/PipeT.Module.cs
similarity index 99%
rename from Samples/PipesExamples/PipeT/PipeT.Module.cs
rename to LanguageExt.Pipes/PipeT/PipeT.Module.cs
index 39457cb64..0f987b858 100644
--- a/Samples/PipesExamples/PipeT/PipeT.Module.cs
+++ b/LanguageExt.Pipes/PipeT/PipeT.Module.cs
@@ -1,9 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 using LanguageExt.Async.Linq;
 using LanguageExt.Common;
 using LanguageExt.Traits;
 using static LanguageExt.Prelude;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 /// <summary>
 /// `PipeT` streaming producer monad-transformer
diff --git a/Samples/PipesExamples/PipeT/PipeT.Monad.cs b/LanguageExt.Pipes/PipeT/PipeT.Monad.cs
similarity index 95%
rename from Samples/PipesExamples/PipeT/PipeT.Monad.cs
rename to LanguageExt.Pipes/PipeT/PipeT.Monad.cs
index ff6e88487..b4264e878 100644
--- a/Samples/PipesExamples/PipeT/PipeT.Monad.cs
+++ b/LanguageExt.Pipes/PipeT/PipeT.Monad.cs
@@ -1,8 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using LanguageExt.Async.Linq;
 using LanguageExt.Common;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 public class PipeT<IN, OUT, M> : MonadT<PipeT<IN, OUT, M>, M>
     where M : Monad<M>
diff --git a/Samples/PipesExamples/PipeT/PipeT.cs b/LanguageExt.Pipes/PipeT/PipeT.cs
similarity index 99%
rename from Samples/PipesExamples/PipeT/PipeT.cs
rename to LanguageExt.Pipes/PipeT/PipeT.cs
index 59a8ce26b..c6d0e4d10 100644
--- a/Samples/PipesExamples/PipeT/PipeT.cs
+++ b/LanguageExt.Pipes/PipeT/PipeT.cs
@@ -1,7 +1,9 @@
+using System;
 using System.Diagnostics.Contracts;
+using System.Threading.Tasks;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 /// <summary>
 /// `PipeT` monad-transformer base-type for Pipes streaming components:
diff --git a/LanguageExt.Pipes/Producer/CoreTypes.cs b/LanguageExt.Pipes/Producer/CoreTypes.cs
deleted file mode 100644
index a218a6d38..000000000
--- a/LanguageExt.Pipes/Producer/CoreTypes.cs
+++ /dev/null
@@ -1,312 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// Producers can only `yield`
-/// </summary>
-/// <remarks>
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     Void〈==      〈== Unit
-///           |         |
-///     Unit ==〉      ==〉OUT
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public record Producer<OUT, M, A> : Proxy<Void, Unit, Unit, OUT, M, A> 
-    where M : Monad<M>
-{
-    public readonly Proxy<Void, Unit, Unit, OUT, M, A> Value;
-        
-    /// <summary>
-    /// Constructor
-    /// </summary>
-    /// <param name="value">Correctly shaped `Proxy` that represents a `Producer`</param>
-    public Producer(Proxy<Void, Unit, Unit, OUT, M, A> value) =>
-        Value = value;
-
-    /// <summary>
-    /// Calling this will effectively cast the sub-type to the base.
-    /// </summary>
-    /// <remarks>This type wraps up a `Proxy` for convenience, and so it's a `Proxy` proxy.  So calling this method
-    /// isn't exactly the same as a cast operation, as it unwraps the `Proxy` from within.  It has the same effect
-    /// however, and removes a level of indirection</remarks>
-    /// <returns>A general `Proxy` type from a more specialised type</returns>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, A> ToProxy() =>
-        Value.ToProxy();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, S> Bind<S>(
-        Func<A, Proxy<Void, Unit, Unit, OUT, M, S>> f) =>
-        Value.Bind(f);
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Producer<OUT, M, B> Bind<B>(Func<A, K<M, B>> f) =>
-        Value.Bind(x => Producer.lift<OUT, M, B>(f(x))).ToProducer();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Producer<OUT, M, B> Bind<B>(Func<A, IO<B>> f) =>
-        Value.Bind(x => Producer.liftIO<OUT, M, B>(f(x))).ToProducer();
-
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, B> Map<B>(Func<A, B> f) =>
-        Value.Map(f);
-
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
-        Value.MapM(f);
-
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, IO<A>> ToIO() =>
-        Value.ToIO();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Producer<OUT, M, B> Bind<B>(Func<A, Producer<OUT, M, B>> f) => 
-        Value.Bind(f).ToProducer();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Producer<OUT, M, B> SelectMany<B>(Func<A, Producer<OUT, M, B>> f) => 
-        Value.Bind(f).ToProducer();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Producer<OUT, M, C> SelectMany<B, C>(Func<A, Producer<OUT, M, B>> f, Func<A, B, C> project) => 
-        Value.Bind(a => f(a).Map(b => project(a, b))).ToProducer();
-        
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public new Producer<OUT, M, B> Select<B>(Func<A, B> f) => 
-        Value.Map(f).ToProducer();
-
-    /// <summary>
-    /// `For(body)` loops over the `Proxy p` replacing each `yield` with `body`
-    /// </summary>
-    /// <param name="body">Any `yield` found in the `Proxy` will be replaced with this function.  It will be composed so
-    /// that the value yielded will be passed to the argument of the function.  That returns a `Proxy` to continue the
-    /// processing of the computation</param>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the function provided</returns>
-    [Pure]
-    public override Proxy<Void, Unit, C1, C, M, A> For<C1, C>(Func<OUT, Proxy<Void, Unit, C1, C, M, Unit>> body) =>
-        Value.ReplaceRespond(body);
-
-    /// <summary>
-    /// Applicative action
-    ///
-    /// Invokes this `Proxy`, then the `Proxy r` 
-    /// </summary>
-    /// <param name="r">`Proxy` to run after this one</param>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, B> Action<B>(Proxy<Void, Unit, Unit, OUT, M, B> r) =>
-        Value.Action(r);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, OUT, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<Void, Proxy<UOutA, AUInA, Void, Unit, M, A>> lhs) =>
-        Value.PairEachRequestWithRespond(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, OUT, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<Void, Proxy<UOutA, AUInA, Unit, OUT, M, Unit>> lhs) =>
-        Value.ReplaceRequest(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<Void, Unit, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<OUT, Proxy<Unit, OUT, DInC, DOutC, M, A>> rhs) =>
-        Value.PairEachRespondWithRequest(rhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<Void, Unit, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<OUT, Proxy<Void, Unit, DInC, DOutC, M, Unit>> rhs) =>
-        Value.ReplaceRespond(rhs);
-
-    /// <summary>
-    /// Reverse the arrows of the `Proxy` to find its dual.  
-    /// </summary>
-    /// <returns>The dual of `this`</returns>
-    [Pure]
-    public override Proxy<OUT, Unit, Unit, Void, M, A> Reflect() =>
-        Value.Reflect();
-
-    /// <summary>
-    /// 
-    ///     Observe(lift (Pure(r))) = Observe(Pure(r))
-    ///     Observe(lift (m.Bind(f))) = Observe(lift(m.Bind(x => lift(f(x)))))
-    /// 
-    /// This correctness comes at a small cost to performance, so use this function sparingly.
-    /// This function is a convenience for low-level pipes implementers.  You do not need to
-    /// use observe if you stick to the safe API.        
-    /// </summary>
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, A> Observe() =>
-        Value.Observe();
-
-    /// <summary>
-    /// Compose a `Producer` and a `Consumer` together into an `Effect`.  
-    /// </summary>
-    /// <param name="p1">`Producer`</param>
-    /// <param name="p2">`Consumer`</param>
-    /// <returns>`Effect`</returns>
-    [Pure]
-    public static Effect<M, A> operator |(Producer<OUT, M, A> p1, Consumer<OUT, M, A> p2) => 
-        Proxy.compose(p1, p2);
-        
-    /// <summary>
-    /// Compose a `Producer` and a `Consumer` together into an `Effect`.  
-    /// </summary>
-    /// <param name="p1">`Producer`</param>
-    /// <param name="p2">`Consumer`</param>
-    /// <returns>`Effect`</returns>
-    [Pure]
-    public static Effect<M, A> operator |(Producer<OUT, M, A> p1, Consumer<OUT, A> p2) => 
-        Proxy.compose(p1, p2);
-        
-    [Pure]
-    public void Deconstruct(out Proxy<Void, Unit, Unit, OUT, M, A> value) =>
-        value = Value;
-
-    /// <summary>
-    /// Conversion operator from the _pure_ `Producer` type, to the monad transformer version of the `Producer`
-    /// </summary>
-    /// <param name="p">Pure `Producer`</param>
-    /// <returns>Monad transformer version of the `Producer`</returns>
-    [Pure]
-    public static implicit operator Producer<OUT, M, A>(Producer<OUT, A> p) =>
-        p.Interpret<M>();
-
-    /// <summary>
-    /// Conversion operator from the `Pure` type, to the monad transformer version of the `Producer`
-    /// </summary>
-    /// <param name="p">`Pure` value</param>
-    /// <returns>Monad transformer version of the `Producer`</returns>
-    [Pure]
-    public static implicit operator Producer<OUT, M, A>(Pure<A> p) =>
-        Producer.Pure<OUT, M, A>(p.Value);
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Producer<OUT, M, B> SelectMany<B>(Func<A, Producer<OUT, B>> bind) =>
-        Value.Bind(a => bind(a).Interpret<M>()).ToProducer();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Producer<OUT, M, C> SelectMany<B, C>(Func<A, Producer<OUT, B>> bind, Func<A, B, C> project) =>
-        SelectMany(a => bind(a).Select(b => project(a, b)));
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Producer<OUT, M, C> SelectMany<B, C>(Func<A, K<M, B>> bind, Func<A, B, C> project) =>
-        Bind(x => M.Map(y => project(x, y), bind(x)));
-
-    /// <summary>
-    /// Chain one producer's set of yields after another
-    /// </summary>
-    [Pure]
-    public static Producer<OUT, M, A> operator &(
-        Producer<OUT, M, A> lhs,
-        Producer<OUT, M, A> rhs) =>
-        lhs.Bind(_ => rhs);
-    
-    [Pure]
-    public override string ToString() => 
-        "producer";
-}
diff --git a/LanguageExt.Pipes/Producer/Producer.cs b/LanguageExt.Pipes/Producer/Producer.cs
deleted file mode 100644
index 2fa6b49ab..000000000
--- a/LanguageExt.Pipes/Producer/Producer.cs
+++ /dev/null
@@ -1,355 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using LanguageExt.Traits;
-using LanguageExt.UnsafeValueAccess;
-using static LanguageExt.Pipes.Proxy;
-using static LanguageExt.Prelude;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// Producers can only `yield`
-/// </summary>
-/// <remarks>
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     Void ==       == Unit
-///           |         |
-///     Unit ==〉      ==〉OUT
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public static class Producer
-{
-    /// <summary>
-    /// Monad return / pure
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<OUT, M, R> Pure<OUT, M, R>(R value) 
-        where M : Monad<M> =>
-        new Pure<Void, Unit, Unit, OUT, M, R>(value).ToProducer();
-        
-    /// <summary>
-    /// Send a value downstream (whilst in a producer)
-    /// </summary>
-    /// <remarks>
-    /// This is the simpler version (fewer generic arguments required) of `yield` that works
-    /// for producers. 
-    /// </remarks>
-    [Pure, MethodImpl(mops)]
-    public static Producer<OUT, M, Unit> yield<OUT, M>(OUT value) 
-        where M : Monad<M> =>
-        respond<Void, Unit, Unit, OUT, M>(value).ToProducer();
-
-    [Pure, MethodImpl(mops)]
-    public static Producer<X, M, Unit> yieldAll<M, X>(IEnumerable<X> xs)
-        where M : Monad<M> =>
-        new IteratorFoldable<Void, Unit, Unit, X, Iterable, X, M, Unit>(
-                xs.AsIterable(),
-                yield<X, M>,
-                () => Pure<X, M, Unit>(unit))
-           .ToProducer();
-
-    [Pure, MethodImpl(mops)]
-    public static Producer<X, M, Unit> yieldAll<M, X>(IAsyncEnumerable<X> xs)
-        where M : Monad<M> =>
-        new IteratorAsyncEnumerable<Void, Unit, Unit, X, Iterable, X, M, Unit>(
-                xs,
-                yield<X, M>,
-                () => Pure<X, M, Unit>(unit))
-           .ToProducer();
-
-    [Pure, MethodImpl(mops)]
-    public static Producer<X, M, Unit> yieldAll<M, X>(IObservable<X> xs)
-        where M : Monad<M> =>
-        yieldAll<M, X>(xs.ToAsyncEnumerable(new CancellationToken()));
-
-    /// <summary>
-    /// Repeat a monadic action indefinitely, yielding each result
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<A, M, Unit> repeatM<M, A>(K<M, A> ma) 
-        where M : Monad<M> =>
-        repeat(lift<A, M, A>(ma).Bind(x => yield<A, M>(x)));
-        
-    /// <summary>
-    /// Lift the IO monad into the Producer monad transformer (a specialism of the Proxy monad transformer)
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<OUT, M, R> lift<OUT, M, R>(K<M, R> ma) 
-        where M : Monad<M> =>
-        lift<Void, Unit, Unit, OUT, M, R>(ma).ToProducer();
-    
-    /// <summary>
-    /// Lift the IO monad into the Producer monad transformer (a specialism of the Proxy monad transformer)
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<OUT, M, R> liftIO<OUT, M, R>(IO<R> ma) 
-        where M : Monad<M> =>
-        liftIO<Void, Unit, Unit, OUT, M, R>(ma).ToProducer();
- 
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns true the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="UntilValue">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    public static Producer<S, M, Unit> FoldUntil<S, M, A>(
-        this Producer<S, M, A> ma, 
-        S Initial, 
-        Func<S, A, S> Fold, 
-        Func<A, bool> UntilValue)
-        where M : Monad<M>
-    {
-        var state = Initial;
-        return ma.Bind(
-            x =>
-            {
-                if (UntilValue(x))
-                {
-                    var nstate = state;
-                    state = Initial;
-                    return yield<S, M>(nstate);
-                }
-                else
-                {
-                    state = Fold(state, x);
-                    return Pure<S, M, Unit>(unit);
-                }
-            });
-    }
- 
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns true the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="UntilValue">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    public static Producer<S, M, Unit> FoldWhile<S, M, A>(
-        this Producer<S, M, A> ma, 
-        S Initial, 
-        Func<S, A, S> Fold, 
-        Func<A, bool> WhileValue)
-        where M : Monad<M>
-    {
-        var state = Initial;
-        return ma.Bind(
-            x =>
-            {
-                if (WhileValue(x))
-                {
-                    state = Fold(state, x);
-                    return Pure<S, M, Unit>(unit);
-                }
-                else
-                {
-                    var nstate = state;
-                    state = Initial;
-                    return yield<S, M>(nstate);
-                }
-            });
-    }
-         
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns true the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="UntilValue">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    public static Producer<S, M, Unit> FoldUntil<S, M, A>(
-        this Producer<S, M, A> ma, 
-        S Initial, Func<S, A, S> Fold, 
-        Func<S, bool> UntilState)
-        where M : Monad<M>
-    {
-        var state = Initial;
-        return ma.Bind(
-            x =>
-            {
-                state = Fold(state, x);
-                if (UntilState(state))
-                {
-                    var nstate = state;
-                    state = Initial;
-                    return yield<S, M>(nstate);
-                }
-                else
-                {
-                    return Pure<S, M, Unit>(unit);
-                }
-            });
-    }
- 
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns true the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="UntilValue">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    public static Producer<S, M, Unit> FoldWhile<S, M, A>(
-        this Producer<S, M, A> ma, 
-        S Initial, 
-        Func<S, A, S> Fold, 
-        Func<S, bool> WhileState)
-        where M : Monad<M>
-    {
-        var state = Initial;
-        return ma.Bind(
-            x =>
-            {
-                state = Fold(state, x);
-                if (WhileState(state))
-                {
-                    return Pure<S, M, Unit>(unit);
-                }
-                else
-                {
-                    var nstate = state;
-                    state = Initial;
-                    return yield<S, M>(nstate);
-                }
-            });
-    }
-
-    /// <summary>
-    /// Merge a sequence of producers into a single producer
-    /// </summary>
-    /// <remarks>The merged producer completes when all component producers have completed</remarks>
-    /// <param name="ms">Sequence of producers to merge</param>
-    /// <returns>Merged producers</returns>
-    public static Producer<OUT, M, Unit> merge_OLD<OUT, M>(Seq<Producer<OUT, M, Unit>> ms)
-        where M : Monad<M> =>
-        ms switch
-        {
-            { IsEmpty     : true }               => lift<OUT, M, Unit>(M.Pure(unit)),
-            { Tail.IsEmpty: true }               => ms[0],
-            { Head        : var h, Tail: var t } => 
-                from x in h.ValueUnsafe()!
-                from xs in merge<OUT, M>(t)
-                select x
-        };
-
-    public static Producer<OUT, M, Unit> merge<OUT, M>(Seq<Producer<OUT, M, Unit>> ms)
-        where M : Monad<M>
-    {
-        if (ms.Count == 0) return Pure<OUT, M, Unit>(unit);
-        var complete = new CountdownEvent(ms.Count);
-        var wait     = new AutoResetEvent(false);
-        var queue    = new ConcurrentQueue<OUT>();
-        var effects  = ms.Traverse(runEffect);
-
-        return from t in liftIO<OUT, M, CancellationToken>(cancelToken)
-               from _ in effects
-               from r in yieldAll<M, OUT>(dequeue(t))
-               select unit;
-
-        async IAsyncEnumerable<OUT> dequeue([EnumeratorCancellation] CancellationToken token)
-        {
-            try
-            {
-                while (true)
-                {
-                    await wait.WaitOneAsync(50, token).ConfigureAwait(false);
-                    if (complete.IsSet) yield break;
-                    if (token.IsCancellationRequested) yield break;
-                    while (queue.TryDequeue(out var item))
-                    {
-                        yield return item;
-                    }
-                }
-            }
-            finally
-            {
-                wait.Dispose();
-                complete.Dispose();
-            }
-        }
-        
-        Unit enqueue(OUT value)
-        {
-            queue?.Enqueue(value);
-            wait?.Set();
-            return unit;
-        }
-        
-        Consumer<OUT, M, Unit> receive() =>
-            from x in Consumer.awaiting<M, OUT>()
-            let _ = enqueue(x)
-            select unit;
-
-        Unit countDown()
-        {
-            complete.Signal();
-            return unit;
-        }
-
-        K<M, ForkIO<Unit>> runEffect(Producer<OUT, M, Unit> p) =>
-            (from _1 in p | receive()
-             let _2 = countDown()
-             select unit)
-            .ToEffect()
-            .RunEffect()
-            .ForkIO();    
-    }
-    
-    /// <summary>
-    /// Merge an array of queues into a single producer
-    /// </summary>
-    /// <remarks>The merged producer completes when all component queues have completed</remarks>
-    /// <param name="ms">Sequence of queues to merge</param>
-    /// <returns>Queues merged into a single producer</returns>
-    public static Producer<OUT, M, Unit> merge<OUT, M>(params Queue<OUT, M, Unit>[] ms) 
-        where M : Monad<M> =>
-        merge(ms.AsIterable().ToSeq().Map(m => (Producer<OUT, M, Unit>)m));
- 
-    /// <summary>
-    /// Merge an array of producers into a single producer
-    /// </summary>
-    /// <remarks>The merged producer completes when all component producers have completed</remarks>
-    /// <param name="ms">Sequence of producers to merge</param>
-    /// <returns>Merged producers</returns>
-    public static Producer<OUT, M, Unit> merge<OUT, M>(params Producer<OUT, M, Unit>[] ms) 
-        where M : Monad<M> =>
-        merge(toSeq(ms));
- 
-    /// <summary>
-    /// Merge an array of producers into a single producer
-    /// </summary>
-    /// <remarks>The merged producer completes when all component producers have completed</remarks>
-    /// <param name="ms">Sequence of producers to merge</param>
-    /// <returns>Merged producers</returns>
-    public static Producer<OUT, M, Unit> merge<OUT, M>(params Proxy<Void, Unit, Unit, OUT, M, Unit>[] ms) 
-        where M : Monad<M> =>
-        merge(toSeq(ms).Map(m => m.ToProducer()));
- 
-    /// <summary>
-    /// Merge a sequence of queues into a single producer
-    /// </summary>
-    /// <remarks>The merged producer completes when all component queues have completed</remarks>
-    /// <param name="ms">Sequence of queues to merge</param>
-    /// <returns>Queues merged into a single producer</returns>
-    public static Producer<OUT, M, Unit> merge<OUT, M>(Seq<Queue<OUT, M, Unit>> ms) 
-        where M : Monad<M> =>
-        merge(ms.Map(m => (Producer<OUT, M, Unit>)m));
- 
-    /// <summary>
-    /// Merge a sequence of producers into a single producer
-    /// </summary>
-    /// <remarks>The merged producer completes when all component producers have completed</remarks>
-    /// <param name="ms">Sequence of producers to merge</param>
-    /// <returns>Merged producers</returns>
-    public static Producer<OUT, M, Unit> merge<OUT, M>(Seq<Proxy<Void, Unit, Unit, OUT, M, Unit>> ms) 
-        where M : Monad<M> =>
-        merge(ms.Map(m => m.ToProducer()));
-}
diff --git a/Samples/PipesExamples/ProducerT/ProducerT.Extensions.cs b/LanguageExt.Pipes/ProducerT/ProducerT.Extensions.cs
similarity index 98%
rename from Samples/PipesExamples/ProducerT/ProducerT.Extensions.cs
rename to LanguageExt.Pipes/ProducerT/ProducerT.Extensions.cs
index bc84b4326..806d901f0 100644
--- a/Samples/PipesExamples/ProducerT/ProducerT.Extensions.cs
+++ b/LanguageExt.Pipes/ProducerT/ProducerT.Extensions.cs
@@ -1,6 +1,7 @@
+using System;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 public static class ProducerTExtensions
 {
diff --git a/Samples/PipesExamples/ProducerT/ProducerT.Module.cs b/LanguageExt.Pipes/ProducerT/ProducerT.Module.cs
similarity index 86%
rename from Samples/PipesExamples/ProducerT/ProducerT.Module.cs
rename to LanguageExt.Pipes/ProducerT/ProducerT.Module.cs
index a3047d91e..972cc9a69 100644
--- a/Samples/PipesExamples/ProducerT/ProducerT.Module.cs
+++ b/LanguageExt.Pipes/ProducerT/ProducerT.Module.cs
@@ -1,11 +1,15 @@
+using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
 using LanguageExt.Common;
 using LanguageExt.Pipes;
+using LanguageExt.Pipes.Concurrent;
 using LanguageExt.Traits;
 using static LanguageExt.Prelude;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 /// <summary>
 /// `ProducerT` streaming producer monad-transformer
@@ -301,72 +305,25 @@ public static ProducerT<OUT, M, Unit> foldWhile<OUT, M, A>(
         where M : Monad<M> =>
         PipeT.foldWhile(Time, Fold, Pred, Init, Item.Proxy);
     
-    /*
     /// <summary>
     /// Merge multiple producers
     /// </summary>
-    /// <param name="producers"></param>
-    /// <typeparam name="OUT"></typeparam>
-    /// <typeparam name="M"></typeparam>
-    /// <returns></returns>
-    public static ProducerT<OUT, M, Unit> merge<OUT, M>(Seq<ProducerT<OUT, M, Unit>> producers)
+    /// <param name="producers">Producers to merge</param>
+    /// <param name="settings">Buffer settings</param>
+    /// <typeparam name="OUT">Stream value to produce</typeparam>
+    /// <typeparam name="M">Lifted monad type</typeparam>
+    /// <returns>Merged producer</returns>
+    public static ProducerT<OUT, M, Unit> merge<OUT, M>(
+        Seq<ProducerT<OUT, M, Unit>> producers, 
+        Buffer<OUT>? settings = null)
         where M : Monad<M>
     {
         if (producers.Count == 0) return pure<OUT, M, Unit>(default);
-        var complete = new CountdownEvent(producers.Count);
-        var wait     = new AutoResetEvent(false);
-        var queue    = new ConcurrentQueue<OUT>();
-        var effects  = producers.Traverse(runEffect);
 
-        return from t in liftIO<OUT, M, CancellationToken>(cancelToken)
-               from _ in effects
-               from r in yieldAll<M, OUT>(dequeue(t))
+        return from mailbox in Pure(Mailbox.spawn(settings ?? Buffer<OUT>.Unbounded))
+               from forks   in producers.Traverse(p => (p | mailbox.ToConsumer<M>()).ForkIO()).As().Run()
+               from _       in mailbox.ToProducer<M>()
+               from x       in forks.Traverse(f => f.Cancel).As()
                select unit;
-        
-        async IAsyncEnumerable<OUT> dequeue([EnumeratorCancellation] CancellationToken token)
-        {
-            try
-            {
-                while (true)
-                {
-                    await wait.WaitOneAsync(50, token).ConfigureAwait(false);
-                    if (complete.IsSet) yield break;
-                    if (token.IsCancellationRequested) yield break;
-                    while (queue.TryDequeue(out var item))
-                    {
-                        yield return item;
-                    }
-                }
-            }
-            finally
-            {
-                wait.Dispose();
-                complete.Dispose();
-            }
-        }
-        
-        Unit enqueue(OUT value)
-        {
-            queue?.Enqueue(value);
-            wait?.Set();
-            return default;
-        }
-        
-        ConsumerT<OUT, M, Unit> receive() =>
-            ConsumerT.awaiting<M, OUT>()
-                     .Map(enqueue);
-
-        Unit countDown()
-        {
-            complete.Signal();
-            return default;
-        }
-
-        K<M, ForkIO<Unit>> runEffect(ProducerT<OUT, M, Unit> p) =>
-            (from _1 in p | receive()
-             let _2 = countDown()
-             select Unit.Default)
-           .Run()
-           .ForkIO();    
-    }    */
+    }
 }
diff --git a/Samples/PipesExamples/ProducerT/ProducerT.Monad.cs b/LanguageExt.Pipes/ProducerT/ProducerT.Monad.cs
similarity index 95%
rename from Samples/PipesExamples/ProducerT/ProducerT.Monad.cs
rename to LanguageExt.Pipes/ProducerT/ProducerT.Monad.cs
index af84df26e..90eb7f0c2 100644
--- a/Samples/PipesExamples/ProducerT/ProducerT.Monad.cs
+++ b/LanguageExt.Pipes/ProducerT/ProducerT.Monad.cs
@@ -1,7 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using LanguageExt.Async.Linq;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 public class ProducerT<OUT, M> : MonadT<ProducerT<OUT, M>, M>
     where M : Monad<M>
diff --git a/Samples/PipesExamples/ProducerT/ProducerT.cs b/LanguageExt.Pipes/ProducerT/ProducerT.cs
similarity index 99%
rename from Samples/PipesExamples/ProducerT/ProducerT.cs
rename to LanguageExt.Pipes/ProducerT/ProducerT.cs
index 935d87976..5dfd5e77c 100644
--- a/Samples/PipesExamples/ProducerT/ProducerT.cs
+++ b/LanguageExt.Pipes/ProducerT/ProducerT.cs
@@ -1,7 +1,8 @@
+using System;
 using System.Diagnostics.Contracts;
 using LanguageExt.Traits;
 
-namespace LanguageExt.Pipes2;
+namespace LanguageExt.Pipes;
 
 /// <summary>
 /// `ProducerT` streaming producer monad-transformer instance
diff --git a/LanguageExt.Pipes/Proxy.Monad.cs b/LanguageExt.Pipes/Proxy.Monad.cs
deleted file mode 100644
index 42f8a2111..000000000
--- a/LanguageExt.Pipes/Proxy.Monad.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-using System;
-using System.Collections.Generic;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// Monad transformer trait implementation for `Proxy`
-/// </summary>
-public class Proxy<UOut, UIn, DIn, DOut, M> : 
-    MonadT<Proxy<UOut, UIn, DIn, DOut, M>, M>
-    where M : Monad<M>
-{
-    static K<Proxy<UOut, UIn, DIn, DOut, M>, B> Monad<Proxy<UOut, UIn, DIn, DOut, M>>.Bind<A, B>(
-        K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma, 
-        Func<A, K<Proxy<UOut, UIn, DIn, DOut, M>, B>> f) => 
-        ma.As().Bind(x => f(x).As());
-
-    static K<Proxy<UOut, UIn, DIn, DOut, M>, B> Functor<Proxy<UOut, UIn, DIn, DOut, M>>.Map<A, B>(
-        Func<A, B> f, K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma) => 
-        ma.As().Map(f);
-
-    static K<Proxy<UOut, UIn, DIn, DOut, M>, A> Applicative<Proxy<UOut, UIn, DIn, DOut, M>>.Pure<A>(A value) => 
-        Proxy.Pure<UOut, UIn, DIn, DOut, M, A>(value);
-
-    static K<Proxy<UOut, UIn, DIn, DOut, M>, B> Applicative<Proxy<UOut, UIn, DIn, DOut, M>>.Apply<A, B>(
-        K<Proxy<UOut, UIn, DIn, DOut, M>, Func<A, B>> mf, 
-        K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma) => 
-        mf.As().Apply(ma.As());
-
-    static K<Proxy<UOut, UIn, DIn, DOut, M>, A> MonadT<Proxy<UOut, UIn, DIn, DOut, M>, M>.Lift<A>(K<M, A> ma) =>
-        Proxy.lift<UOut, UIn, DIn, DOut, M, A>(ma);
-
-    static K<Proxy<UOut, UIn, DIn, DOut, M>, A> MonadIO<Proxy<UOut, UIn, DIn, DOut, M>>.LiftIO<A>(IO<A> ma) => 
-        Proxy.lift<UOut, UIn, DIn, DOut, M, A>(M.LiftIO(ma));
-
-    static K<Proxy<UOut, UIn, DIn, DOut, M>, IO<A>> MonadIO<Proxy<UOut, UIn, DIn, DOut, M>>.ToIO<A>(K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma) =>
-        ma.As().ToIO();
-
-    static K<Proxy<UOut, UIn, DIn, DOut, M>, A> Applicative<Proxy<UOut, UIn, DIn, DOut, M>>.Actions<A>(
-        IEnumerable<K<Proxy<UOut, UIn, DIn, DOut, M>, A>> fas) =>
-        fas.AsIterable().Map(fa => fa.ToIO()).Actions().Bind(io => io);
-}
diff --git a/LanguageExt.Pipes/Proxy.Prelude.cs b/LanguageExt.Pipes/Proxy.Prelude.cs
deleted file mode 100644
index 06908854e..000000000
--- a/LanguageExt.Pipes/Proxy.Prelude.cs
+++ /dev/null
@@ -1,722 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Threading.Tasks;
-using LanguageExt.Traits;
-using static LanguageExt.Prelude;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// The `static Proxy` class is the `Prelude` of the Pipes system.
-/// </summary>
-public static partial class Proxy
-{
-    internal const MethodImplOptions mops = MethodImplOptions.AggressiveInlining;
-    
-    /// <summary>
-    /// Wait for a value to flow from upstream (whilst in a `Pipe` or a `Consumer`)
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<A, A> awaiting<A>() =>
-        PureProxy.ConsumerAwait<A>();
-
-    /// <summary>
-    /// Send a value flowing downstream (whilst in a `Producer` or a `Pipe`)
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<A, Unit> yield<A>(A value) =>
-        PureProxy.ProducerYield(value);
-
-    /// <summary>
-    /// Create a queue
-    /// </summary>
-    /// <remarks>A `Queue` is a `Producer` with an `Enqueue`, and a `Done` to cancel the operation</remarks>
-    [Pure, MethodImpl(mops)]
-    public static Queue<A, M, Unit> Queue<M, A>() 
-        where M : Monad<M>
-    {
-        var c = new Channel<A>();
-        var p = Producer.yieldAll<M, A>(c);
-        return new Queue<A, M, Unit>(p, c);
-    }
-
-    /// <summary>
-    /// Create a `Producer` from an `IEnumerable`.  This will automatically `yield` each value of the
-    /// `IEnumerable` down stream
-    /// </summary>
-    /// <param name="xs">Items to `yield`</param>
-    /// <typeparam name="X">Type of the value to `yield`</typeparam>
-    /// <returns>`Producer`</returns>
-    [Pure, MethodImpl(mops)]
-    public static Producer<X, Unit> yieldAll<F, X>(K<F, X> xs) where F : Foldable<F> =>
-        PureProxy.ProducerFold(xs);
- 
-    /// <summary>
-    /// Create a `Producer` from an `IAsyncEnumerable`.  This will automatically `yield` each value of the
-    /// `IEnumerable` down stream
-    /// </summary>
-    /// <param name="xs">Items to `yield`</param>
-    /// <typeparam name="X">Type of the value to `yield`</typeparam>
-    /// <returns>`Producer`</returns>
-    [Pure, MethodImpl(mops)]
-    public static Producer<X, Unit> yieldAll<X>(IAsyncEnumerable<X> xs) =>
-        yieldAll(xs.ToBlockingEnumerable().AsIterable());
-
-    /// <summary>
-    /// Create a `Producer` from an `IObservable`.  This will automatically `yield` each value of the
-    /// `IObservable` down stream
-    /// </summary>
-    /// <param name="xs">Items to `yield`</param>
-    /// <typeparam name="X">Type of the value to `yield`</typeparam>
-    /// <returns>`Producer`</returns>
-    [Pure, MethodImpl(mops)]
-    public static Producer<X, Unit> yieldAll<X>(IObservable<X> xs) =>
-        from t in PureProxy.ProducerLiftIO<X, CancellationToken>(IO.token)
-        from r in yieldAll(xs.ToAsyncEnumerable(t))
-        select r;
-
-    // TODO: IMPLEMENT TAIL CALLS
-    [Pure, MethodImpl(mops)]
-    public static Producer<OUT, M, R> tail<OUT, M, R>(Producer<OUT, M, R> ma) 
-        where M : Monad<M> =>
-        ma;
-
-    // TODO: IMPLEMENT TAIL CALLS
-    [Pure, MethodImpl(mops)]
-    public static Consumer<IN, M, R> tail<IN, M, R>(Consumer<IN, M, R> ma) 
-        where M : Monad<M> =>
-        ma;
-
-    // TODO: IMPLEMENT TAIL CALLS
-    [Pure, MethodImpl(mops)]
-    public static Pipe<IN, OUT, M, R> tail<IN, OUT, M, R>(Pipe<IN, OUT, M, R> ma) 
-        where M : Monad<M> =>
-        ma;
-
-    /// <summary>
-    /// Repeat the `Producer` indefinitely
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<OUT, M, Unit> repeat<OUT, M, R>(Producer<OUT, M, R> ma)
-        where M : Monad<M> =>
-        new IteratorFoldable<Void, Unit, Unit, OUT, Iterable, Unit, M, Unit>(
-            Naturals.AsIterable().Map(_ => unit),
-            _ => ma.ToProxy().Map(_ => unit),
-            () => Producer.Pure<OUT, M, Unit>(unit))
-           .ToProducer();
-
-    /// <summary>
-    /// Repeat the `Consumer` indefinitely
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<IN, M, Unit> repeat<IN, M, R>(Consumer<IN, M, R> ma) 
-        where M : Monad<M> =>
-        new IteratorFoldable<Unit, IN, Unit, Void, Iterable, Unit, M, Unit>(
-                Naturals.AsIterable().Map(_ => unit),
-                _ => ma.ToProxy().Map(_ => unit),
-                () => Consumer.Pure<IN, M, Unit>(unit))
-           .ToConsumer();
-
-    /// <summary>
-    /// Repeat the `Pipe` indefinitely
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<IN, OUT, M, Unit> repeat<IN, OUT, M, R>(Pipe<IN, OUT, M, R> ma) 
-        where M : Monad<M> =>
-        new IteratorFoldable<Unit, IN, Unit, OUT, Iterable, Unit, M, Unit>(
-                Naturals.AsIterable().Map(_ => unit),
-                _ => ma.ToProxy().Map(_ => unit),
-                () => Pipe.Pure<IN, OUT, M, Unit>(unit))
-           .ToPipe();
-
-    /// <summary>
-    /// Lift a monad into the `Proxy` monad transformer
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, B1, B, M, R> lift<A1, A, B1, B, M, R>(K<M, R> ma) 
-        where M : Monad<M> =>
-        new ProxyM<A1, A, B1, B, M, R>(M.Map(Pure<A1, A, B1, B, M, R>, ma));
-
-    /// <summary>
-    /// Lift an IO monad into the `Proxy` monad transformer
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, B1, B, M, R> liftIO<A1, A, B1, B, M, R>(K<IO, R> ma) 
-        where M : Monad<M> =>
-        lift<A1, A, B1, B, M, R>(M.LiftIO(ma));
-
-    internal static Unit dispose<A>(A d) where A : IDisposable
-    {
-        d.Dispose();
-        return default;
-    }
-
-    internal static Unit anyDispose<A>(A x)
-    {
-        if (x is IDisposable d)
-        {
-            d.Dispose();
-        }
-
-        return default;
-    }
-
-    /// <summary>
-    /// The identity `Pipe`, simply replicates its upstream value and propagates it downstream 
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<A, A, M, R> cat<A, M, R>()
-        where M : Monad<M> =>
-        pull<Unit, A, M, R>(default).ToPipe();
-
-    /// <summary>
-    /// Forward requests followed by responses
-    ///
-    ///    pull = request | respond | pull
-    /// 
-    /// </summary>
-    /// <remarks>
-    /// `pull` is the identity of the pull category.
-    /// </remarks>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<UOut, UIn, UOut, UIn, M, A> pull<UOut, UIn, M, A>(UOut a1)
-        where M : Monad<M> =>
-        new Request<UOut, UIn, UOut, UIn, M, A>(
-            a1,
-            a => new Respond<UOut, UIn, UOut, UIn, M, A>(
-                a,
-                pull<UOut, UIn, M, A>));
-
-    /// <summary>
-    /// `push = respond | request | push`
-    /// </summary>
-    /// <remarks>
-    /// `push` is the identity of the push category.
-    /// </remarks>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<UOut, UIn, UOut, UIn, M, A> push<UOut, UIn, M, A>(UIn a)
-        where M : Monad<M> =>
-        new Respond<UOut, UIn, UOut, UIn, M, A>(
-            a,
-            a1 => new Request<UOut, UIn, UOut, UIn, M, A>(
-                a1,
-                push<UOut, UIn, M, A>));
-
-    /// <summary>
-    /// Send a value of type `DOut` downstream and block waiting for a reply of type `DIn`
-    /// </summary>
-    /// <remarks>
-    /// `respond` is the identity of the respond category.
-    /// </remarks>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<X1, X, DIn, DOut, M, DIn> respond<X1, X, DIn, DOut, M>(DOut value) 
-        where M : Monad<M> =>
-        new Respond<X1, X, DIn, DOut, M, DIn>(value, r => new Pure<X1, X, DIn, DOut, M, DIn>(r));
-
-    /// <summary>
-    /// Send a value of type `UOut` upstream and block waiting for a reply of type `UIn`
-    /// </summary>
-    /// <remarks>
-    /// `request` is the identity of the request category.
-    /// </remarks>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<UOut, UIn, Y1, Y, M, UIn> request<UOut, UIn, Y1, Y, M>(UOut value) 
-        where M : Monad<M> =>
-        new Request<UOut, UIn, Y1, Y, M, UIn>(value, r => new Pure<UOut, UIn, Y1, Y, M, UIn>(r));
-
-
-    /// <summary>
-    /// `reflect` transforms each streaming category into its dual:
-    ///
-    /// The request category is the dual of the respond category
-    ///
-    ///      reflect . respond = request
-    ///      reflect . (f | g) = reflect . f | reflect . g
-    ///      reflect . request = respond
-    ///      reflect . (f | g) = reflect . f | reflect . g
-    ///
-    /// The pull category is the dual of the push category
-    ///
-    ///      reflect . push = pull
-    ///      reflect . (f | g) = reflect . f | reflect . g
-    ///      reflect . pull = push
-    ///      reflect . (f | g) = reflect . f | reflect . g
-    ///
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<DOut, DIn, UIn, UOut, M, R> reflect<UOut, UIn, DIn, DOut, M, R>(
-        Proxy<UOut, UIn, DIn, DOut, M, R> p)
-        where M : Monad<M> =>
-        p.Reflect();
-
-    /// <summary>
-    /// `p.ForEach(body)` loops over the `Producer p` replacing each `yield` with `body`
-    /// 
-    ///     Producer b r -> (b -> Producer c ()) -> Producer c r
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<OUT_B, M, A> ForEach<OUT_A, OUT_B, M, A>(
-        this Producer<OUT_A, M, A> p, 
-        Func<OUT_A, Producer<OUT_B, M, Unit>> body)
-        where M : Monad<M> =>
-        p.For(body).ToProducer();
-
-    /// <summary>
-    /// `p.ForEach(body)` loops over `Producer p` replacing each `yield` with `body`
-    /// 
-    ///     Producer b r -> (b -> Effect ()) -> Effect r
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Effect<M, A> ForEach<OUT, M, A>(
-        this Producer<OUT, M, A> p, 
-        Func<OUT, Effect<M, Unit>> fb)
-        where M : Monad<M> =>
-        p.For(fb).ToEffect();
-
-    /// <summary>
-    /// `p.ForEach(body)` loops over `Pipe p` replacing each `yield` with `body`
-    /// 
-    ///     Pipe x b r -> (b -> Consumer x ()) -> Consumer x r
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<IN, M, A> ForEach<IN, OUT, M, A>(
-        this Pipe<IN, OUT, M, A> p0, 
-        Func<OUT, Consumer<IN, M, Unit>> fb)
-        where M : Monad<M> =>
-        p0.For(fb).ToConsumer();
-
-    /// <summary>
-    /// `p.ForEach(body)` loops over `Pipe p` replacing each `yield` with `body`
-    /// 
-    ///     Pipe x b r -> (b -> Pipe x c ()) -> Pipe x c r
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<IN, OUT, M, R> ForEach<IN, B, OUT, M, R>(
-        this Pipe<IN, B, M, R> p0, 
-        Func<B, Pipe<IN, OUT, M, Unit>> fb)
-        where M : Monad<M> =>
-        p0.For(fb).ToPipe();
-
-    /// <summary>
-    /// `compose(draw, p)` loops over `p` replacing each `await` with `draw`
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<UOut, UIn, DIn, DOut, M, B> compose<UOut, UIn, DIn, DOut, A, M, B>(
-        Proxy<UOut, UIn, DIn, DOut, M, A> p1, 
-        Proxy<Unit, A, DIn, DOut, M, B> p2)
-        where M : Monad<M> =>
-        compose(_ => p1, p2);
-
-    /// <summary>
-    /// `compose(draw, p)` loops over `p` replacing each `await` with `draw`
-    /// 
-    ///     Effect b -> Consumer b c -> Effect c
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Effect<M, A> compose<OUT, M, A>(
-        Effect<M, OUT> p1, 
-        Consumer<OUT, M, A> p2)
-        where M : Monad<M> =>
-        compose(_ => p1, p2).ToEffect();
-
-    /// <summary>
-    /// `compose(draw, p)` loops over `p` replacing each `await` with `draw`
-    /// 
-    ///     Consumer a b -> Consumer b c -> Consumer a c
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<A, M, C> compose<A, B, M, C>(
-        Consumer<A, M, B> p1, 
-        Consumer<B, M, C> p2) 
-        where M : Monad<M> =>
-        compose(_ => p1, p2).ToConsumer();
-
-    /// <summary>
-    /// `compose(draw, p)` loops over `p` replacing each `await` with `draw`
-    /// 
-    ///     Producer y b -> Pipe b y m c -> Producer y c
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<OUT, M, C> compose<OUT, IN, M, C>(
-        Producer<OUT, M, IN> p1, 
-        Pipe<IN, OUT, M, C> p2) 
-        where M : Monad<M> =>
-        compose(_ => p1, p2).ToProducer();
-
-    /// <summary>
-    /// `compose(draw, p)` loops over `p` replacing each `await` with `draw`
-    /// 
-    ///     Pipe a y b -> Pipe b y c -> Pipe a y c
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<A, Y, M, C> compose<Y, A, B, M, C>(
-        Pipe<A, Y, M, B> p1,
-        Pipe<B, Y, M, C> p2) 
-        where M : Monad<M> =>
-        compose(_ => p1, p2).ToPipe();
-
-    // fixAwaitDual
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, Y1, Y, M, C> compose<A1, A, Y1, Y, B, M, C>(
-        Proxy<Unit, B, Y1, Y, M, C> p2,
-        Proxy<A1, A, Y1, Y, M, B> p1) 
-        where M : Monad<M> =>
-        compose(p1, p2);
-
-    /// <summary>
-    /// Replaces each `request` or `respond` in `p0` with `fb1`.
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, Y1, Y, M, C> compose<A1, A, B1, B, Y1, Y, M, C>(
-        Func<B1, Proxy<A1, A, Y1, Y, M, B>> fb1,
-        Proxy<B1, B, Y1, Y, M, C> p0) 
-        where M : Monad<M> =>
-        p0.ReplaceRequest(fb1);
-
-    /// <summary>
-    /// `compose(p, f)` pairs each `respond` in `p` with a `request` in `f`.
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, C1, C, M, R> compose<A1, A, B1, B, C1, C, M, R>(
-        Proxy<A1, A, B1, B, M, R> p,
-        Func<B, Proxy<B1, B, C1, C, M, R>> fb)
-        where M : Monad<M> =>
-        p.PairEachRespondWithRequest(fb);
-
-    /// <summary>
-    /// `compose(f, p)` pairs each `request` in `p` with a `respond` in `f`
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, C1, C, M, R> compose<A1, A, B1, B, C1, C, M, R>(
-        Func<B1, Proxy<A1, A, B1, B, M, R>> fb1,
-        Proxy<B1, B, C1, C, M, R> p)
-        where M : Monad<M> =>
-        p.PairEachRequestWithRespond(fb1);
-
-    /// <summary>
-    /// Pipe composition
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, C1, C, M, R> compose<A1, A, B, C1, C, M, R>(
-        Proxy<A1, A, Unit, B, M, R> p1,
-        Proxy<Unit, B, C1, C, M, R> p2)
-        where M : Monad<M> =>
-        compose(_ => p1, p2);
-
-    /// <summary>
-    /// Pipe composition
-    ///
-    ///     Producer b r -> Consumer b r -> Effect m r
-    /// 
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Effect<M, R> compose<B, M, R>(
-        Producer<B, M, R> p1,
-        Consumer<B, M, R> p2)
-        where M : Monad<M> =>
-        compose(p1.ToProxy(), p2).ToEffect();
-
-    /// <summary>
-    /// Pipe composition
-    ///
-    ///     Producer b r -> Pipe b c r -> Producer c r
-    /// 
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<C, M, R> compose<B, C, M, R>(
-        Producer<B, M, R> p1,
-        Pipe<B, C, M, R> p2)
-        where M : Monad<M> =>
-        compose(p1.ToProxy(), p2).ToProducer();
-
-    /// <summary>
-    /// Pipe composition
-    ///
-    ///     Pipe a b r -> Consumer b r -> Consumer a r
-    /// 
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Consumer<A, M, R> compose<A, B, M, R>(
-        Pipe<A, B, M, R> p1,
-        Consumer<B, M, R> p2)
-        where M : Monad<M> =>
-        compose(p1.ToProxy(), p2).ToConsumer();
-
-    /// <summary>
-    /// Pipe composition
-    ///
-    ///     Pipe a b r -> Pipe b c r -> Pipe a c r
-    /// 
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<A, C, M, R> compose<A, B, C, M, R>(
-        Pipe<A, B, M, R> p1,
-        Pipe<B, C, M, R> p2)
-        where M : Monad<M> =>
-        compose(p1.ToProxy(), p2).ToPipe();
-
-    /// <summary>
-    /// Compose two unfolds, creating a new unfold
-    /// </summary>
-    /// <remarks>
-    /// This is the composition operator of the respond category.
-    /// </remarks>
-    [Pure, MethodImpl(mops)]
-    public static Func<A, Proxy<X1, X, C1, C, M, A1>> compose<X1, X, A1, A, B1, B, C1, M, C>(
-        Func<A, Proxy<X1, X, B1, B, M, A1>> fa,
-        Func<B, Proxy<X1, X, C1, C, M, B1>> fb) 
-        where M : Monad<M> =>
-        a => compose(fa(a), fb);
-
-    /// <summary>
-    /// Compose two unfolds, creating a new unfold
-    /// </summary>
-    /// <remarks>
-    /// This is the composition operator of the respond category.
-    /// </remarks>
-    [Pure, MethodImpl(mops)]
-    public static Func<A, Proxy<X1, X, C1, C, M, A1>> Then<X1, X, A1, A, B1, B, C1, M, C>(
-        this Func<A, Proxy<X1, X, B1, B, M, A1>> fa,
-        Func<B, Proxy<X1, X, C1, C, M, B1>> fb) 
-        where M : Monad<M> =>
-        a => compose(fa(a), fb);
-
-    /// <summary>
-    /// `compose(p, f)` replaces each `respond` in `p` with `f`.
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<X1, X, C1, C, M, A1> compose<X1, X, A1, B1, C1, C, M, B>(
-        Proxy<X1, X, B1, B, M, A1> p0,
-        Func<B, Proxy<X1, X, C1, C, M, B1>> fb) 
-        where M : Monad<M> =>
-        p0.ReplaceRespond(fb);
-
-    /// <summary>
-    /// `compose(p, f)` replaces each `respond` in `p` with `f`.
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<X1, X, C1, C, M, A1> Then<X1, X, A1, B1, C1, C, M, B>(
-        this Proxy<X1, X, B1, B, M, A1> p0,
-        Func<B, Proxy<X1, X, C1, C, M, B1>> fb) 
-        where M : Monad<M> =>
-        compose(p0, fb);
-
-
-    /// <summary>
-    ///  Compose two folds, creating a new fold
-    /// 
-    ///     (f | g) x = f | g x
-    /// 
-    ///     | is the composition operator of the request category.
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Func<C1, Proxy<A1, A, Y1, Y, M, C>> compose<A1, A, B1, B, Y1, Y, C1, M, C>(
-        Func<B1, Proxy<A1, A, Y1, Y, M, B>> fb1,
-        Func<C1, Proxy<B1, B, Y1, Y, M, C>> fc1) 
-        where M : Monad<M> =>
-        c1 => compose(fb1, fc1(c1));
-
-    /// <summary>
-    /// 
-    ///     observe(lift (Pure(r))) = observe(Pure(r))
-    ///     observe(lift (m.Bind(f))) = observe(lift(m.Bind(x => lift(f(x)))))
-    /// 
-    /// This correctness comes at a small cost to performance, so use this function sparingly.
-    /// This function is a convenience for low-level pipes implementers.  You do not need to
-    /// use observe if you stick to the safe API.        
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, B1, B, M, R> observe<A1, A, B1, B, M, R>(
-        Proxy<A1, A, B1, B, M, R> p0)
-        where M : Monad<M> =>
-        p0.Observe();
-
-    /// <summary>
-    /// `Absurd` function
-    /// </summary>
-    /// <param name="value">`Void` is supposed to represent `void`, nothing can be constructed from `void` and
-    /// so this method just throws `ApplicationException("closed")`</param>
-    [Pure, MethodImpl(mops)]
-    public static A closed<A>(Void value) =>
-        throw new ApplicationException("closed");
-
-    /// <summary>
-    /// Applicative apply
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, B1, B, M, S> apply<A1, A, B1, B, R, M, S>(
-        Proxy<A1, A, B1, B, M, Func<R, S>> pf,
-        Proxy<A1, A, B1, B, M, R> px) where M : Monad<M>
-    {
-        return Go(pf);
-
-        Proxy<A1, A, B1, B, M, S> Go(Proxy<A1, A, B1, B, M, Func<R, S>> p) =>
-            p.ToProxy() switch
-            {
-                Request<A1, A, B1, B, M, Func<R, S>> (var a1, var fa) => new Request<A1, A, B1, B, M, S>(a1, a => Go(fa(a))),
-                Respond<A1, A, B1, B, M, Func<R, S>> (var b, var fb1) => new Respond<A1, A, B1, B, M, S>(b, b1 => Go(fb1(b1))),
-                ProxyM<A1, A, B1, B, M, Func<R, S>> (var m)           => new ProxyM<A1, A, B1, B, M, S>(M.Map(Go, m)),
-                Pure<A1, A, B1, B, M, Func<R, S>> (var f)             => px.Map(f),
-                _                                                     => throw new NotSupportedException()
-            };
-    }
-
-    /// <summary>
-    /// Applicative apply
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, B1, B, M, S> Apply<A1, A, B1, B, R, M, S>(
-        this Proxy<A1, A, B1, B, M, Func<R, S>> pf, 
-        Proxy<A1, A, B1, B, M, R> px) 
-        where M : Monad<M> =>
-        apply(pf, px);
-
-    /// <summary>
-    /// Applicative action
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, B1, B, M, S> Action<A1, A, B1, B, R, M, S>(
-        this Proxy<A1, A, B1, B, M, R> l, 
-        Proxy<A1, A, B1, B, M, S> r) 
-        where M : Monad<M> =>
-        l.Action(r);
-
-    /// <summary>
-    /// Monad return / pure
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Proxy<A1, A, B1, B, M, R> Pure<A1, A, B1, B, M, R>(R value) 
-        where M : Monad<M> =>
-        new Pure<A1, A, B1, B, M, R>(value);
-
-    /// <summary>
-    /// Creates a non-yielding producer that returns the result of the effects
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static K<M, (A, B)> collect<M, A, B>(Effect<M, A> ma, Effect<M, B> mb)
-        where M : Monad<M> =>
-        fun((A x, B y) => (x, y)).Map(ma.RunEffect()).Apply(mb.RunEffect());
- 
-    /// <summary>
-    /// Creates a non-yielding producer that returns the result of the effects
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static K<M, (A, B, C)> collect<M, A, B, C>(Effect<M, A> ma, Effect<M, B> mb, Effect<M, C> mc) 
-        where M : Monad<M> =>
-        fun((A x, B y, C z) => (x, y, z)).Map(ma.RunEffect()).Apply(mb.RunEffect()).Apply(mc.RunEffect());
-
-    /// <summary>
-    /// Creates a non-yielding producer that returns the result of the effects
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<(A, B), M, Unit> yield<M, A, B>(Effect<M, A> ma, Effect<M, B> mb) 
-        where M : Monad<M> =>
-        from r in collect(ma, mb)
-        from _ in yield(r)
-        select unit;
-
-    /// <summary>
-    /// Creates a non-yielding producer that returns the result of the effects
-    /// </summary>
-    [Pure, MethodImpl(mops)]
-    public static Producer<(A, B, C), M, Unit> yield<M, A, B, C>(Effect<M, A> ma, Effect<M, B> mb, Effect<M, C> mc) 
-        where M : Monad<M> =>
-        from r in collect(ma, mb, mc)
-        from _ in yield(r)
-        select unit;
-
-    /// <summary>
-    /// Only forwards values that satisfy the predicate.
-    /// </summary>
-    public static Pipe<A, A, Unit> filter<A>(Func<A, bool> f) =>
-        from x in awaiting<A>()
-        from r in f(x) ? yield(x) : Prelude.Pure(unit)
-        select r;
-
-    /// <summary>
-    /// Map the output of the pipe (not the bound value as is usual with Map)
-    /// </summary>
-    public static Pipe<A, B, Unit> map<A, B>(Func<A, B> f) =>
-        from x in awaiting<A>()
-        from r in yield(f(x))
-        select r;
-
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns false the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="WhileState">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<IN, OUT, Unit> foldWhile<IN, OUT>(OUT Initial, Func<OUT, IN, OUT> Fold, Func<OUT, bool> State) => 
-        foldUntil(Initial, Fold, x => !State(x));
- 
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns true the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="UntilState">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    public static Pipe<IN, OUT, Unit> foldUntil<IN, OUT>(OUT Initial, Func<OUT, IN, OUT> Fold, Func<OUT, bool> State)
-    {
-        var state = Initial;
-        return awaiting<IN>()
-           .Bind(x =>
-                 {
-                     state = Fold(state, x);
-                     if (State(state))
-                     {
-                         var nstate = state;
-                         state = Initial;
-                         return yield(nstate);
-                     }
-                     else
-                     {
-                         return Prelude.Pure(unit);
-                     }
-                 });
-    }        
-        
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns false the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="WhileValue">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    [Pure, MethodImpl(mops)]
-    public static Pipe<IN, OUT, Unit> foldWhile<IN, OUT>(OUT Initial, Func<OUT, IN, OUT> Fold, Func<IN, bool> Value) => 
-        foldUntil(Initial, Fold, x => !Value(x));
- 
-    /// <summary>
-    /// Folds values coming down-stream, when the predicate returns true the folded value is yielded 
-    /// </summary>
-    /// <param name="Initial">Initial state</param>
-    /// <param name="Fold">Fold operation</param>
-    /// <param name="UntilValue">Predicate</param>
-    /// <returns>A pipe that folds</returns>
-    public static Pipe<IN, OUT, Unit> foldUntil<IN, OUT>(OUT Initial, Func<OUT, IN, OUT> Fold, Func<IN, bool> Value)
-    {
-        var state = Initial;
-        return awaiting<IN>()
-           .Bind(x =>
-                 {
-                     if (Value(x))
-                     {
-                         var nstate = state;
-                         state = Initial;
-                         return yield(nstate);
-                     }
-                     else
-                     {
-                         state = Fold(state, x);
-                         return Prelude.Pure(unit);
-                     }
-                 });
-    }
-}
diff --git a/LanguageExt.Pipes/Proxy.Prelude.mapapply.cs b/LanguageExt.Pipes/Proxy.Prelude.mapapply.cs
deleted file mode 100644
index 814bd43f3..000000000
--- a/LanguageExt.Pipes/Proxy.Prelude.mapapply.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-using System;
-using LanguageExt.Traits;
-using LanguageExt.Pipes;
-
-namespace LanguageExt.Pipes;
-
-public static partial class Proxy
-{
-    /// <summary>
-    /// Functor map operation
-    /// </summary>
-    /// <remarks>
-    /// Unwraps the value within the functor, passes it to the map function `f` provided, and
-    /// then takes the mapped value and wraps it back up into a new functor.
-    /// </remarks>
-    /// <param name="ma">Functor to map</param>
-    /// <param name="f">Mapping function</param>
-    /// <returns>Mapped functor</returns>
-    public static Proxy<UOut, UIn, DIn, DOut, M, B> map<UOut, UIn, DIn, DOut, M, A, B>(
-        Func<A, B> f, 
-        K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma) 
-        where M : Monad<M> =>
-        Functor.map(f, ma).As();
-    
-    /// <summary>
-    /// Applicative action: runs the first applicative, ignores the result, and returns the second applicative
-    /// </summary>
-    public static Proxy<UOut, UIn, DIn, DOut, M, B> action<UOut, UIn, DIn, DOut, M, A, B>(
-        K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma, 
-        K<Proxy<UOut, UIn, DIn, DOut, M>, B> mb) 
-        where M : Monad<M> =>
-        Applicative.action(ma, mb).As();
-
-    /// <summary>
-    /// Applicative functor apply operation
-    /// </summary>
-    /// <remarks>
-    /// Unwraps the value within the `ma` applicative-functor, passes it to the unwrapped function(s) within `mf`, and
-    /// then takes the resulting value and wraps it back up into a new applicative-functor.
-    /// </remarks>
-    /// <param name="ma">Value(s) applicative functor</param>
-    /// <param name="mf">Mapping function(s)</param>
-    /// <returns>Mapped applicative functor</returns>
-    public static Proxy<UOut, UIn, DIn, DOut, M, B> apply<UOut, UIn, DIn, DOut, M, A, B>(
-        K<Proxy<UOut, UIn, DIn, DOut, M>, Func<A, B>> mf, 
-        K<Proxy<UOut, UIn, DIn, DOut, M>, A> ma) 
-        where M : Monad<M> =>
-        Applicative.apply(mf, ma).As();
-}    
diff --git a/LanguageExt.Pipes/Proxy.ProxyM.cs b/LanguageExt.Pipes/Proxy.ProxyM.cs
deleted file mode 100644
index 516626586..000000000
--- a/LanguageExt.Pipes/Proxy.ProxyM.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// One of the algebraic cases of the `Proxy` type.  This type lifts a `Transducer` computation into the
-/// `Proxy` monad-transformer.  This is how the `Proxy` system can cause real-world effects.
-/// </summary>
-/// <typeparam name="UOut">Upstream out type</typeparam>
-/// <typeparam name="UIn">Upstream in type</typeparam>
-/// <typeparam name="DIn">Downstream in type</typeparam>
-/// <typeparam name="DOut">Downstream uut type</typeparam>
-/// <typeparam name="A">The monadic bound variable - it doesn't flow up or down stream, it works just like any bound
-/// monadic variable.  If the effect represented by the `Proxy` ends, then this will be the result value.
-///
-/// When composing `Proxy` sub-types (like `Producer`, `Pipe`, `Consumer`, etc.)  </typeparam>
-internal record ProxyM<UOut, UIn, DIn, DOut, M, A>(K<M, Proxy<UOut, UIn, DIn, DOut, M, A>> Value) : 
-    Proxy<UOut, UIn, DIn, DOut, M, A>
-    where M : Monad<M>
-{
-    /// <summary>
-    /// When working with sub-types, like `Producer`, calling this will effectively cast the sub-type to the base.
-    /// </summary>
-    /// <returns>A general `Proxy` type from a more specialised type</returns>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> ToProxy() => 
-        this;
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Bind<B>(Func<A, Proxy<UOut, UIn, DIn, DOut, M, B>> f) =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, B>(M.Map(p => p.Bind(f), Value));
-
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Map<B>(Func<A, B> f) =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, B>(M.Map(p => p.Map(f), Value));
-
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, B>(M.Map(p => p.MapM(f), Value));
-    
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, IO<A>> ToIO() =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, IO<A>>(M.Map(p => p.ToIO(), Value));
-
-    /// <summary>
-    /// `For(body)` loops over the `Proxy p` replacing each `yield` with `body`
-    /// </summary>
-    /// <param name="body">Any `yield` found in the `Proxy` will be replaced with this function.  It will be composed so
-    /// that the value yielded will be passed to the argument of the function.  That returns a `Proxy` to continue the
-    /// processing of the computation</param>
-    /// <returns></returns>
-    [Pure]
-    public override Proxy<UOut, UIn, C1, C, M, A> For<C1, C>(Func<DOut, Proxy<UOut, UIn, C1, C, M, DIn>> body) =>
-        ReplaceRespond(body);
-
-    /// <summary>
-    /// Applicative action
-    ///
-    /// Invokes this `Proxy`, then the `Proxy r` 
-    /// </summary>
-    /// <param name="r">`Proxy` to run after this one</param>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, S> Action<S>(Proxy<UOut, UIn, DIn, DOut, M, S> r) =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, S>(M.Map(p => p.Action(r), Value));
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `fb1`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, UOut, UIn, M, A>> fb1) =>
-        new ProxyM<UOutA, AUInA, DIn, DOut, M, A>(M.Map(p1 => p1.PairEachRequestWithRespond(fb1), Value));
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, DIn, DOut, M, UIn>> lhs) =>
-        new ProxyM<UOutA, AUInA, DIn, DOut, M, A>(M.Map(p => p.ReplaceRequest(lhs), Value));
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<DOut, Proxy<DIn, DOut, DInC, DOutC, M, A>> rhs) =>
-        new ProxyM<UOut, UIn, DInC, DOutC, M, A>(M.Map(p1 => p1.PairEachRespondWithRequest(rhs), Value));
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<DOut, Proxy<UOut, UIn, DInC, DOutC, M, DIn>> rhs) =>
-        new ProxyM<UOut, UIn, DInC, DOutC, M, A>(M.Map(p => p.ReplaceRespond(rhs), Value));
-
-    /// <summary>
-    /// Reverse the arrows of the `Proxy` to find its dual.  
-    /// </summary>
-    /// <returns>The dual of `this1</returns>
-    [Pure]
-    public override Proxy<DOut, DIn, UIn, UOut, M, A> Reflect() =>
-        new ProxyM<DOut, DIn, UIn, UOut, M, A>(M.Map(p => p.Reflect(), Value));
-
-    /// <summary>
-    /// 
-    ///     Observe(lift (Pure(r))) = Observe(Pure(r))
-    ///     Observe(lift (m.Bind(f))) = Observe(lift(m.Bind(x => lift(f(x)))))
-    /// 
-    /// This correctness comes at a small cost to performance, so use this function sparingly.
-    /// This function is a convenience for low-level pipes implementers.  You do not need to
-    /// use observe if you stick to the safe API.        
-    /// </summary>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> Observe() =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, A>(M.Map(p => p.Observe(), Value));
-        
-    [Pure]
-    public void Deconstruct(out K<M, Proxy<UOut, UIn, DIn, DOut, M, A>> value) =>
-        value = Value;
-    
-    [Pure]
-    public override string ToString() => 
-        "proxyM";
-}
diff --git a/LanguageExt.Pipes/Proxy.Pure.cs b/LanguageExt.Pipes/Proxy.Pure.cs
deleted file mode 100644
index 2571a320f..000000000
--- a/LanguageExt.Pipes/Proxy.Pure.cs
+++ /dev/null
@@ -1,159 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// One of the algebraic cases of the `Proxy` type.  This type represents a pure value.  It can be thought of as the
-/// terminating value of the computation, as there's not continuation attached to this case. 
-/// </summary>
-/// <typeparam name="UOut">Upstream out type</typeparam>
-/// <typeparam name="UIn">Upstream in type</typeparam>
-/// <typeparam name="DIn">Downstream in type</typeparam>
-/// <typeparam name="DOut">Downstream uut type</typeparam>
-/// <typeparam name="A">The monadic bound variable - it doesn't flow up or down stream, it works just like any bound
-/// monadic variable.  If the effect represented by the `Proxy` ends, then this will be the result value.
-///
-/// When composing `Proxy` subtypes (like `Producer`, `Pipe`, `Consumer`, etc.)  </typeparam>
-public record Pure<UOut, UIn, DIn, DOut, M, A>(A Value) : Proxy<UOut, UIn, DIn, DOut, M, A>
-    where M : Monad<M>
-{
-    /// <summary>
-    /// When working with subtypes, like `Producer`, calling this will effectively cast the subtype to the base.
-    /// </summary>
-    /// <returns>A general `Proxy` type from a more specialised type</returns>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> ToProxy() => this;
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Bind<B>(Func<A, Proxy<UOut, UIn, DIn, DOut, M, B>> f) =>
-        f(Value);
-
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Map<B>(Func<A, B> f) =>
-        new Pure<UOut, UIn, DIn, DOut, M, B>(f(Value));
-            
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
-        Proxy.lift<UOut, UIn, DIn, DOut, M, B>(f(M.Pure(Value)));
-                    
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, IO<A>> ToIO() =>
-        new Pure<UOut, UIn, DIn, DOut, M, IO<A>>(IO.pure(Value));
-
-    /// <summary>
-    /// `For(body)` loops over the `Proxy p` replacing each `yield` with `body`
-    /// </summary>
-    /// <param name="body">Any `yield` found in the `Proxy` will be replaced with this function.  It will be composed so
-    /// that the value yielded will be passed to the argument of the function.  That returns a `Proxy` to continue the
-    /// processing of the computation</param>
-    /// <returns></returns>
-    [Pure]
-    public override Proxy<UOut, UIn, C1, C, M, A> For<C1, C>(Func<DOut, Proxy<UOut, UIn, C1, C, M, DIn>> body) =>
-        ReplaceRespond(body);
-
-    /// <summary>
-    /// Applicative action
-    ///
-    /// Invokes this `Proxy`, then the `Proxy r` 
-    /// </summary>
-    /// <param name="r">`Proxy` to run after this one</param>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Action<B>(Proxy<UOut, UIn, DIn, DOut, M, B> r) =>
-        r;
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, UOut, UIn, M, A>> _) =>
-        new Pure<UOutA, AUInA, DIn, DOut, M, A>(Value);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, DIn, DOut, M, UIn>> _) =>
-        new Pure<UOutA, AUInA, DIn, DOut, M, A>(Value).ToProxy();
-                
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<DOut, Proxy<DIn, DOut, DInC, DOutC, M, A>> _) =>
-        new Pure<UOut, UIn, DInC, DOutC, M, A>(Value);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<DOut, Proxy<UOut, UIn, DInC, DOutC, M, DIn>> _) =>
-        new Pure<UOut, UIn, DInC, DOutC, M, A>(Value);
-
-    /// <summary>
-    /// Reverse the arrows of the `Proxy` to find its dual.  
-    /// </summary>
-    /// <returns>The dual of `this1</returns>
-    [Pure]
-    public override Proxy<DOut, DIn, UIn, UOut, M, A> Reflect() =>
-        new Pure<DOut, DIn, UIn, UOut, M, A>(Value);
-
-    /// <summary>
-    /// 
-    ///     Observe(lift (Pure(r))) = Observe(Pure(r))
-    ///     Observe(lift (m.Bind(f))) = Observe(lift(m.Bind(x => lift(f(x)))))
-    /// 
-    /// This correctness comes at a small cost to performance, so use this function sparingly.
-    /// This function is a convenience for low-level pipes implementers.  You do not need to
-    /// use observe if you stick to the safe API.        
-    /// </summary>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> Observe() =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, A>(M.Pure(Proxy.Pure<UOut, UIn, DIn, DOut, M, A>(Value)));
-        
-
-    [Pure]
-    public void Deconstruct(out A value) =>
-        value = Value;
-    
-    [Pure]
-    public override string ToString() => 
-        "pure";
-}
diff --git a/LanguageExt.Pipes/Proxy.cs b/LanguageExt.Pipes/Proxy.cs
deleted file mode 100644
index 12c4bd016..000000000
--- a/LanguageExt.Pipes/Proxy.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// A `Proxy` is a monad transformer that receives and sends information on both
-/// an upstream and downstream interface.  It is the base type for all of the key
-/// other important types in the Pipes ecosystem, like `Producer`, `Consumer`,
-/// `Pipe`, etc.
-/// 
-/// Diagrammatically, you can think of a `Proxy` as having the following shape:
-/// 
-///         Upstream | Downstream
-///             +---------+
-///             |         |
-///       UOut ◄--       ◄-- DIn
-///             |         |
-///       UIn  --►       --► DOut
-///             |    |    |
-///             +----|----+
-///                  A
-///
-/// You can connect proxies together in five different ways:
-/// 
-///   1. Connect pull-based streams
-///   2. Connect push-based streams
-///   3. Chain folds
-///   4. Chain unfolds
-///   5. Sequence proxies
-/// 
-/// The type variables signify:
-///
-/// * `UOut` and `Uin` - The upstream interface, where `UOut` go out and `UIn` come in
-/// * `DOut` and `DIn` - The downstream interface, where `DOut` go out and `DIn` come in
-/// * `RT` - The runtime of the transformed effect monad
-/// * `A` - The return value    
-/// </summary>
-/// <typeparam name="UOut">Upstream out type</typeparam>
-/// <typeparam name="UIn">Upstream in type</typeparam>
-/// <typeparam name="DIn">Downstream in type</typeparam>
-/// <typeparam name="DOut">Downstream uut type</typeparam>
-/// <typeparam name="A">The monadic bound variable - it doesn't flow up or down stream, it works just like any bound
-/// monadic variable.  If the effect represented by the `Proxy` ends, then this will be the result value.
-///
-/// When composing `Proxy` subtypes (like `Producer`, `Pipe`, `Consumer`, etc.)  </typeparam>
-public abstract record Proxy<UOut, UIn, DIn, DOut, M, A> : K<Proxy<UOut, UIn, DIn, DOut, M>, A>
-    where M : Monad<M>
-{
-    /// <summary>
-    /// When working with subtypes, like `Producer`, calling this will effectively cast the sub-type to the base.
-    /// </summary>
-    /// <returns>A general `Proxy` type from a more specialised type</returns>
-    public abstract Proxy<UOut, UIn, DIn, DOut, M, A> ToProxy();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    public abstract Proxy<UOut, UIn, DIn, DOut, M, B> Bind<B>(Func<A, Proxy<UOut, UIn, DIn, DOut, M, B>> f);
-        
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    public abstract Proxy<UOut, UIn, DIn, DOut, M, B> Map<B>(Func<A, B> f);
-
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    public abstract Proxy<UOut, UIn, DIn, DOut, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f);
-
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    public abstract Proxy<UOut, UIn, DIn, DOut, M, IO<A>> ToIO();
-        
-    /// <summary>
-    /// `For(body)` loops over the `Proxy p` replacing each `yield` with `body`
-    /// </summary>
-    /// <param name="body">Any `yield` found in the `Proxy` will be replaced with this function.  It will be composed so
-    /// that the value yielded will be passed to the argument of the function.  That returns a `Proxy` to continue the
-    /// processing of the computation</param>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the function provided</returns>
-    public abstract Proxy<UOut, UIn, C1, C, M, A> For<C1, C>(Func<DOut, Proxy<UOut, UIn, C1, C, M, DIn>> body);
-        
-    /// <summary>
-    /// Applicative action
-    ///
-    /// Invokes this `Proxy`, then the `Proxy r` 
-    /// </summary>
-    /// <param name="r">`Proxy` to run after this one</param>
-    public abstract Proxy<UOut, UIn, DIn, DOut, M, B> Action<B>(Proxy<UOut, UIn, DIn, DOut, M, B> r);
-        
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    public abstract Proxy<UOutA, AUInA, DIn, DOut, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, UOut, UIn, M, A>> lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    public abstract Proxy<UOutA, AUInA, DIn, DOut, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, DIn, DOut, M, UIn>> lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    public abstract Proxy<UOut, UIn, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<DOut, Proxy<DIn, DOut, DInC, DOutC, M, A>> rhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    public abstract Proxy<UOut, UIn, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<DOut, Proxy< UOut, UIn, DInC, DOutC, M, DIn>> rhs);
-
-    /// <summary>
-    /// Reverse the arrows of the `Proxy` to find its dual.  
-    /// </summary>
-    /// <returns>The dual of `this`</returns>
-    public abstract Proxy<DOut, DIn, UIn, UOut, M, A> Reflect();
-        
-    /// <summary>
-    /// 
-    ///     Observe(lift (Pure(r))) = Observe(Pure(r))
-    ///     Observe(lift (m.Bind(f))) = Observe(lift(m.Bind(x => lift(f(x)))))
-    /// 
-    /// This correctness comes at a small cost to performance, so use this function sparingly.
-    /// This function is a convenience for low-level pipes implementers.  You do not need to
-    /// use observe if you stick to the safe API.        
-    /// </summary>
-    public abstract Proxy<UOut, UIn, DIn, DOut, M, A> Observe();
-
-    /// <summary>
-    /// Monadic bind operation, followed by a mapping projection, enables usage in LINQ expressions
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <param name="prject">The mapping projection function</param>
-    /// <typeparam name="C">The new bound value type</typeparam>
-    /// <returns>The result of the bind and mapping composition</returns>
-    [Pure]
-    public Proxy<UOut, UIn, DIn, DOut, M, C> SelectMany<B, C>(
-        Func<A, Proxy<UOut, UIn, DIn, DOut, M, B>> f, 
-        Func<A, B, C> project) =>
-        Bind(a => f(a).Map(b => project(a, b)));
-
-    /// <summary>
-    /// Functor map operation, enables usage in LINQ expressions
-    /// </summary>
-    /// <param name="f">Map function</param>
-    /// <typeparam name="B">The new bound value type</typeparam>
-    /// <returns>The result of the lifted function applied to the bound value</returns>
-    [Pure]
-    public Proxy<UOut, UIn, DIn, DOut, M, B> Select<B>(Func<A, B> f) =>
-        Map(f);
-    
-    [Pure]
-    public override string ToString() => 
-        "proxy";
-}
diff --git a/LanguageExt.Pipes/PureProxy/Consumer.cs b/LanguageExt.Pipes/PureProxy/Consumer.cs
deleted file mode 100644
index a2b719fe2..000000000
--- a/LanguageExt.Pipes/PureProxy/Consumer.cs
+++ /dev/null
@@ -1,219 +0,0 @@
-//
-// This file contains a number of micro-free-monads that allow for creation of pure producers, consumers, and pipes.  
-// They're used to facilitate the building of Proxy derived types without the need for typing the generic arguments endlessly
-// The Haskell original could auto-infer the generic parameter types, the system here tries to replicate manually what
-// Haskell can do automatically.  Hence why there are so many implementations of SelectMany!
-//
-
-using System;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-public abstract class Consumer<IN, A>
-{
-    public abstract Consumer<IN, B> Select<B>(Func<A, B> f);
-    
-    public abstract Consumer<IN, B> Bind<B>(Func<A, Consumer<IN, B>> f);
-    public abstract Consumer<IN, M, B> Bind<M, B>(Func<A, Consumer<IN, M, B>> f) where M : Monad<M>;
-    public abstract Pipe<IN, OUT, B> Bind<OUT, B>(Func<A, Producer<OUT, B>> f);
-    
-    public Consumer<IN, B> Bind<B>(Func<A, Pure<B>> f) =>
-        Map(x => f(x).Value);
- 
-    public Consumer<IN, B> Bind<B>(Func<A, Fail<Error>> f) =>
-        Bind(x => new Consumer<IN, B>.Fail(f(x).Value));
- 
-    public Consumer<IN, M, B> Bind<M, B>(Func<A, K<M, B>> f) 
-        where M : Monad<M> =>
-        Interpret<M>().Bind(f);
-
-    public Consumer<IN, B> Bind<B>(Func<A, IO<B>> f) =>
-        Bind(x => PureProxy.ConsumerLiftIO<IN, B>(f(x)));
- 
-    public abstract Consumer<IN, M, A> Interpret<M>() 
-        where M : Monad<M>;
-    
-    public abstract Pipe<IN, OUT, A> ToPipe<OUT>();
-        
-    public Consumer<IN, B> Map<B>(Func<A, B> f) => Select(f);
-        
-    public Consumer<IN, C> SelectMany<B, C>(Func<A, Pure<B>> f, Func<A, B, C> project) =>
-        Map(x => project(x, f(x).Value));
- 
-    public Consumer<IN, C> SelectMany<B, C>(Func<A, Fail<Error>> f, Func<A, B, C> project) =>
-        Bind<C>(f);
-
-    public Consumer<IN, C> SelectMany<B, C>(Func<A, IO<B>> f, Func<A, B, C> project) =>
-        Bind(x => f(x).Map(y => project(x, y)));
- 
-    public Consumer<IN, M, C> SelectMany<M, B, C>(Func<A, K<M, B>> f, Func<A, B, C> project)
-        where M : Monad<M> =>
-        Bind(a =>  M.Map(b => project(a, b), f(a)));
- 
-    public Consumer<IN, C> SelectMany<B, C>(Func<A, Consumer<IN, B>> f, Func<A, B, C> project) =>
-        Bind(a => f(a).Select(b => project(a, b)));
-        
-    public Consumer<IN, M, C> SelectMany<M, B, C>(Func<A, Consumer<IN, M, B>> f, Func<A, B, C> project) 
-        where M : Monad<M> =>
-        Bind(a => f(a).Select(b => project(a, b)));
-        
-    public Pipe<IN, OUT, C> SelectMany<OUT, B, C>(Func<A, Producer<OUT, B>> f, Func<A, B, C> project) =>
-        Bind(a => f(a).Select(b => project(a, b)));
-       
-    public Consumer<IN, C> SelectMany<C>(Func<A, Guard<Error, Unit>> bind, Func<A, Unit, C> project ) =>
-        Map(a => bind(a) switch
-                 {
-                     { Flag: true } => project(a, default),
-                     var g => g.OnFalse().Throw<C>()
-                 });
-    
-    public static implicit operator Consumer<IN, A>(Pure<A> ma) =>
-        new Pure(ma.Value);
-       
-    public static Consumer<IN, A> operator &(
-        Consumer<IN, A> lhs,
-        Consumer<IN, A> rhs) =>
-        lhs.Bind(_ => rhs);
-
-    public class Pure(A Value) : Consumer<IN, A>
-    {
-        public override Consumer<IN, B> Select<B>(Func<A, B> f) =>
-            new Consumer<IN, B>.Pure(f(Value));
-
-        public override Consumer<IN, B> Bind<B>(Func<A, Consumer<IN, B>> f) =>
-            f(Value);
-
-        public override Consumer<IN, M, B> Bind<M, B>(Func<A, Consumer<IN, M, B>> f) =>
-            f(Value);
-
-        public override Pipe<IN, OUT, B> Bind<OUT, B>(Func<A, Producer<OUT, B>> f) =>
-            f(Value).ToPipe<IN>();
-
-        public override Consumer<IN, M, A> Interpret<M>() =>
-            Consumer.Pure<IN, M, A>(Value);
-
-        public override Pipe<IN, OUT, A> ToPipe<OUT>() =>
-            new Pipe<IN, OUT, A>.Pure(Value);
-    }
-
-    public class Fail(Error Error) : Consumer<IN, A>
-    {
-        public override Consumer<IN, B> Select<B>(Func<A, B> _) =>
-            new Consumer<IN, B>.Fail(Error);
-
-        public override Consumer<IN, B> Bind<B>(Func<A, Consumer<IN, B>> _) =>
-            new Consumer<IN, B>.Fail(Error);
-
-        public override Consumer<IN, M, B> Bind<M, B>(Func<A, Consumer<IN, M, B>> f) =>
-            PureProxy.ConsumerLift<IN, A>(Error.Throw<A>).Bind(f);
-            
-        public override Pipe<IN, OUT, B> Bind<OUT, B>(Func<A, Producer<OUT, B>> _) =>
-            new Pipe<IN, OUT, B>.Fail(Error);
-
-        public override Consumer<IN, M, A> Interpret<M>() =>
-            PureProxy.ConsumerLift<IN, A>(Error.Throw<A>);
-
-        public override Pipe<IN, OUT, A> ToPipe<OUT>() =>
-            new Pipe<IN, OUT, A>.Fail(Error);
-    }
-
-    public class Lift<X>(Func<X> Function, Func<X, Consumer<IN, A>> Next) : Consumer<IN, A>
-    {
-        public override Consumer<IN, B> Select<B>(Func<A, B> f) => 
-            new Consumer<IN, B>.Lift<X>(Function, x => Next(x).Select(f));
-
-        public override Consumer<IN, B> Bind<B>(Func<A, Consumer<IN, B>> f) => 
-            new Consumer<IN, B>.Lift<X>(Function, x => Next(x).Bind(f));
-
-        public override Consumer<IN, M, B> Bind<M, B>(Func<A, Consumer<IN, M, B>> f) =>
-            Consumer.lift<IN, M, X>(M.Pure(Function())).Bind(x => Next(x).Bind(f)).ToConsumer();
-
-        public override Pipe<IN, OUT, B> Bind<OUT, B>(Func<A, Producer<OUT, B>> f) => 
-            new Pipe<IN, OUT, B>.Lift<X>(Function, x => Next(x).Bind(f));
-
-        public override Consumer<IN, M, A> Interpret<M>() =>
-            Consumer.lift<IN, M, X>(M.Pure(Function())).Bind(x => Next(x).Interpret<M>());
-
-        public override Pipe<IN, OUT, A> ToPipe<OUT>() => 
-            new Pipe<IN, OUT, A>.Lift<X>(Function, x => Next(x).ToPipe<OUT>());
-    }
-
-    public class LiftIO<X>(IO<X> Effect, Func<X, Consumer<IN, A>> Next) : Consumer<IN, A>
-    {
-        public override Consumer<IN, B> Select<B>(Func<A, B> f) => 
-            new Consumer<IN, B>.LiftIO<X>(Effect, x => Next(x).Select(f));
-
-        public override Consumer<IN, B> Bind<B>(Func<A, Consumer<IN, B>> f) => 
-            new Consumer<IN, B>.LiftIO<X>(Effect, x => Next(x).Bind(f));
-
-        public override Consumer<IN, M, B> Bind<M, B>(Func<A, Consumer<IN, M, B>> f) =>
-            Consumer.lift<IN, M, X>(M.LiftIO(Effect)).Bind(x => Next(x).Bind(f)).ToConsumer();
-
-        public override Pipe<IN, OUT, B> Bind<OUT, B>(Func<A, Producer<OUT, B>> f) => 
-            new Pipe<IN, OUT, B>.LiftIO<X>(Effect, x => Next(x).Bind(f));
-
-        public override Consumer<IN, M, A> Interpret<M>() =>
-            Consumer.lift<IN, M, X>(M.LiftIO(Effect)).Bind(x => Next(x).Interpret<M>());
-
-        public override Pipe<IN, OUT, A> ToPipe<OUT>() => 
-            new Pipe<IN, OUT, A>.LiftIO<X>(Effect, x => Next(x).ToPipe<OUT>());
-    }
-
-    public class Await : Consumer<IN, A>
-    {
-        public readonly Func<IN, Consumer<IN, A>> Next;
-        public Await(Func<IN, Consumer<IN, A>> next) =>
-            Next = next;
-
-        public override Consumer<IN, B> Select<B>(Func<A, B> f) =>
-            new Consumer<IN, B>.Await(x => Next(x).Select(f));
-
-        public override Consumer<IN, B> Bind<B>(Func<A, Consumer<IN, B>> f) =>
-            new Consumer<IN, B>.Await(x => Next(x).Bind(f));
-
-        public override Consumer<IN, M, B> Bind<M, B>(Func<A, Consumer<IN, M, B>> f) =>
-            Interpret<M>().Bind(f).ToConsumer();
-
-        public override Pipe<IN, OUT, B> Bind<OUT, B>(Func<A, Producer<OUT, B>> f) =>
-            new Pipe<IN, OUT, B>.Await(x => Next(x).Bind(f));
-
-        public override Consumer<IN, M, A> Interpret<M>() =>
-            Consumer.awaiting<M, IN>().Bind(x => Next(x).Interpret<M>()).ToConsumer();
-
-        public override Pipe<IN, OUT, A> ToPipe<OUT>() =>
-            new Pipe<IN, OUT, A>.Await(x => Next(x).ToPipe<OUT>());
-    }
-    
-    public class Fold<F, X>(K<F, X> Items, Func<X, Consumer<IN, Unit>> Yield, Func<Consumer<IN, A>> Next) : Consumer<IN, A>
-        where F : Foldable<F>
-    {
-        public override Consumer<IN, B> Select<B>(Func<A, B> f) => 
-            new Consumer<IN, B>.Fold<F, X>(Items, Yield, () => Next().Select(f));
-
-        public override Consumer<IN, B> Bind<B>(Func<A, Consumer<IN, B>> f) => 
-            new Consumer<IN, B>.Fold<F, X>(Items, Yield, () => Next().Bind(f));
-
-        public override Consumer<IN, M, B> Bind<M, B>(Func<A, Consumer<IN, M, B>> f) =>
-            new(new IteratorFoldable<Unit, IN, Unit, Void, F, X, M, B>(
-                    Items,
-                    x => Yield(x).Interpret<M>(),
-                    () => Next().Bind(f)));
-
-        public override Pipe<IN, OUT, B> Bind<OUT, B>(Func<A, Producer<OUT, B>> f) => 
-            new Pipe<IN, OUT, B>.Fold<F, X>(
-                Items, 
-                x => Yield(x).ToPipe<OUT>(), 
-                () => Next().Bind(f));
-
-        public override Consumer<IN, M, A> Interpret<M>() =>
-            new(new IteratorFoldable<Unit, IN, Unit, Void, F, X, M, A>(
-                    Items,
-                    x => Yield(x).Interpret<M>(),
-                    () => Next().Interpret<M>()));
-
-        public override Pipe<IN, OUT, A> ToPipe<OUT>() => 
-            new Pipe<IN, OUT, A>.Fold<F, X>(Items, x => Yield(x).ToPipe<OUT>(), () => Next().ToPipe<OUT>());
-    }
-}
diff --git a/LanguageExt.Pipes/PureProxy/Pipe.cs b/LanguageExt.Pipes/PureProxy/Pipe.cs
deleted file mode 100644
index 36db15db3..000000000
--- a/LanguageExt.Pipes/PureProxy/Pipe.cs
+++ /dev/null
@@ -1,247 +0,0 @@
-//
-// This file contains a number of micro-free-monads that allow for creation of pure producers, consumers, and pipes.  
-// They're used to facilitate the building of Proxy derived types without the need for typing the generic arguments endlessly
-// The Haskell original could auto-infer the generic parameter types, the system here tries to replicate manually what
-// Haskell can do automatically.  Hence why there are so many implementations of SelectMany!
-//
-
-using System;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-public abstract class Pipe<IN, OUT, A>
-{
-    public abstract Pipe<IN, OUT, B> Select<B>(Func<A, B> f);
-    public abstract Pipe<IN, OUT, M, A> Interpret<M>() where M : Monad<M>;
-    
-    public abstract Pipe<IN, OUT, B> Bind<B>(Func<A, Pipe<IN, OUT, B>> f);
-    public abstract Pipe<IN, OUT, M, B> Bind<M, B>(Func<A, Pipe<IN, OUT, M, B>> f) where M : Monad<M>;
-    public abstract Pipe<IN, OUT, B> Bind<B>(Func<A, Consumer<IN, B>> f);
-    public abstract Pipe<IN, OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f);
-    
-    public Pipe<IN, OUT, B> Bind<B>(Func<A, Pure<B>> f) =>
-        Map(x => f(x).Value);
-  
-    public Pipe<IN, OUT, B> Bind<B>(Func<A, Fail<Error>> f) =>
-        Bind(x => new Pipe<IN, OUT, B>.Fail(f(x).Value));
-
-    public Pipe<IN, OUT, M, B> Bind<M, B>(Func<A, K<M, B>> f) 
-        where M : Monad<M> =>
-        Interpret<M>().Bind(f);
-
-    public Pipe<IN, OUT, B> Bind<B>(Func<A, IO<B>> f) =>
-        Bind(x => PureProxy.PipeLiftIO<IN, OUT, B>(f(x)));
-    
-    public Pipe<IN, OUT, B> Map<B>(Func<A, B> f) => 
-        Select(f);
-
-    public Pipe<IN, OUT, C> SelectMany<B, C>(Func<A, Pipe<IN, OUT, B>> f, Func<A, B, C> project) =>
-        Bind(a => f(a).Select(b => project(a, b)));
-        
-    public Pipe<IN, OUT, C> SelectMany<B, C>(Func<A, Pure<B>> f, Func<A, B, C> project) =>
-        Map(a => project(a, f(a).Value));
-                
-    public Pipe<IN, OUT, C> SelectMany<B, C>(Func<A, Fail<Error>> f, Func<A, B, C> project) =>
-        Bind<C>(f);
-
-    public Pipe<IN, OUT, M, C> SelectMany<M, B, C>(Func<A, K<M, B>> f, Func<A, B, C> project) 
-        where M : Monad<M> =>
-        Bind(a => M.Map(b => project(a, b), f(a)));
-
-    public Pipe<IN, OUT, C> SelectMany<B, C>(Func<A, IO<B>> f, Func<A, B, C> project) =>
-        Bind(x => f(x).Map(y => project(x, y)));
-        
-    public Pipe<IN, OUT, M, C> SelectMany<M, B, C>(Func<A, Pipe<IN, OUT, M, B>> f, Func<A, B, C> project) where M : Monad<M> =>
-        Bind(a => f(a).Select(b => project(a, b)));
-        
-    public Pipe<IN, OUT, C> SelectMany<B, C>(Func<A, Consumer<IN, B>> f, Func<A, B, C> project) =>
-        Bind(a => f(a).Select(b => project(a, b)));
-        
-    public Pipe<IN, OUT, C> SelectMany<B, C>(Func<A, Producer<OUT, B>> f, Func<A, B, C> project) =>
-        Bind(a => f(a).Select(b => project(a, b)));
-    
-    public Pipe<IN, OUT, C> SelectMany<C>(Func<A, Guard<Error, Unit>> bind, Func<A, Unit, C> project ) =>
-        Map(a => bind(a) switch
-                 {
-                     { Flag: true } => project(a, default),
-                     var g          => g.OnFalse().Throw<C>()
-                 });
-
-    public static implicit operator Pipe<IN, OUT, A>(Pure<A> ma) =>
-        new Pure(ma.Value);
-        
-    public static Pipe<IN, OUT, A> operator &(
-        Pipe<IN, OUT, A> lhs,
-        Pipe<IN, OUT, A> rhs) =>
-        lhs.Bind(_ => rhs);
-
-    public class Pure(A Value) : Pipe<IN, OUT, A>
-    {
-        public override Pipe<IN, OUT, B> Select<B>(Func<A, B> f) =>
-            new Pipe<IN, OUT, B>.Pure(f(Value));
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Pipe<IN, OUT, B>> f) =>
-            f(Value);
-
-        public override Pipe<IN, OUT, M, B> Bind<M, B>(Func<A, Pipe<IN, OUT, M, B>> f) =>
-            f(Value);
-
-        public override Pipe<IN, OUT, M, A> Interpret<M>() =>
-            Pipe.Pure<IN, OUT, M, A>(Value);
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Consumer<IN, B>> f) =>
-            f(Value).ToPipe<OUT>();
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) =>
-            f(Value).ToPipe<IN>();
-    }
-
-    public class Fail(Error Error) : Pipe<IN, OUT, A>
-    {
-        public override Pipe<IN, OUT, B> Select<B>(Func<A, B> _) =>
-            new Pipe<IN, OUT, B>.Fail(Error);
-
-        public override Pipe<IN, OUT, M, A> Interpret<M>() => 
-            PureProxy.PipeLift<IN, OUT, A>(Error.Throw<A>);
-        
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Pipe<IN, OUT, B>> f) => 
-            new Pipe<IN, OUT, B>.Fail(Error);
-
-        public override Pipe<IN, OUT, M, B> Bind<M, B>(Func<A, Pipe<IN, OUT, M, B>> f) => 
-            PureProxy.PipeLift<IN, OUT, A>(Error.Throw<A>).Bind(f);
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Consumer<IN, B>> _) =>
-            new Pipe<IN, OUT, B>.Fail(Error);
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) => 
-            new Pipe<IN, OUT, B>.Fail(Error);
-    }
-
-    public class Lift<X>(Func<X> Function, Func<X, Pipe<IN, OUT, A>> Next) : Pipe<IN, OUT, A>
-    {
-        public override Pipe<IN, OUT, B> Select<B>(Func<A, B> f) => 
-            new Pipe<IN, OUT, B>.Lift<X>(Function, x => Next(x).Select(f));
-
-        public override Pipe<IN, OUT, M, A> Interpret<M>() => 
-            Pipe.lift<IN, OUT, M, X>(M.Pure(Function())).Bind(x => Next(x).Interpret<M>());
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Pipe<IN, OUT, B>> f) => 
-            new Pipe<IN, OUT, B>.Lift<X>(Function, x => Next(x).Bind(f));
-
-        public override Pipe<IN, OUT, M, B> Bind<M, B>(Func<A, Pipe<IN, OUT, M, B>> f) => 
-            Pipe.lift<IN, OUT, M, X>(M.Pure(Function())).SelectMany(x => Next(x).Bind(f)).ToPipe();
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Consumer<IN, B>> f) =>
-            new Pipe<IN, OUT, B>.Lift<X>(Function, x => Next(x).Bind(y => f(y).ToPipe<OUT>()));
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) =>
-            new Pipe<IN, OUT, B>.Lift<X>(Function, x => Next(x).Bind(y => f(y).ToPipe<IN>()));
-    }
-
-    public class LiftIO<X>(IO<X> Effect, Func<X, Pipe<IN, OUT, A>> Next) : Pipe<IN, OUT, A>
-    {
-        public override Pipe<IN, OUT, B> Select<B>(Func<A, B> f) => 
-            new Pipe<IN, OUT, B>.LiftIO<X>(Effect, x => Next(x).Select(f));
-
-        public override Pipe<IN, OUT, M, A> Interpret<M>() => 
-            Pipe.lift<IN, OUT, M, X>(M.LiftIO(Effect)).Bind(x => Next(x).Interpret<M>());
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Pipe<IN, OUT, B>> f) => 
-            new Pipe<IN, OUT, B>.LiftIO<X>(Effect, x => Next(x).Bind(f));
-
-        public override Pipe<IN, OUT, M, B> Bind<M, B>(Func<A, Pipe<IN, OUT, M, B>> f) => 
-            Pipe.lift<IN, OUT, M, X>(M.LiftIO(Effect)).SelectMany(x => Next(x).Bind(f)).ToPipe();
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Consumer<IN, B>> f) =>
-            new Pipe<IN, OUT, B>.LiftIO<X>(Effect, x => Next(x).Bind(y => f(y).ToPipe<OUT>()));
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) =>
-            new Pipe<IN, OUT, B>.LiftIO<X>(Effect, x => Next(x).Bind(y => f(y).ToPipe<IN>()));
-    }
-
-    public class Await(Func<IN, Pipe<IN, OUT, A>> Next) : Pipe<IN, OUT, A>
-    {
-        public override Pipe<IN, OUT, B> Select<B>(Func<A, B> f) =>
-            new Pipe<IN, OUT, B>.Await(x => Next(x).Select(f));
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Pipe<IN, OUT, B>> f) =>
-            new Pipe<IN, OUT, B>.Await(x => Next(x).Bind(f));
-
-        public override Pipe<IN, OUT, M, B> Bind<M, B>(Func<A, Pipe<IN, OUT, M, B>> f) =>
-            from x in Interpret<M>()
-            from r in f(x)
-            select r;
-
-        public override Pipe<IN, OUT, M, A> Interpret<M>() =>
-            from x in Pipe.awaiting<M, IN, OUT>()
-            from r in Next(x) 
-            select r;
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Consumer<IN, B>> f) =>
-            new Pipe<IN, OUT, B>.Await(x => Next(x).Bind(f));
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) =>
-            new Pipe<IN, OUT, B>.Await(x => Next(x).Bind(f));
-    }
-
-    public class Yield(OUT Value, Func<Unit, Pipe<IN, OUT, A>> Next) : Pipe<IN, OUT, A>
-    {
-        public override Pipe<IN, OUT, B> Select<B>(Func<A, B> f) =>
-            new Pipe<IN, OUT, B>.Yield(Value, x => Next(x).Select(f));
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Pipe<IN, OUT, B>> f) =>
-            new Pipe<IN, OUT, B>.Yield(Value, x => Next(x).Bind(f));
-
-        public override Pipe<IN, OUT, M, B> Bind<M, B>(Func<A, Pipe<IN, OUT, M, B>> f) =>
-            from x in Interpret<M>()
-            from r in f(x)
-            select r;
-
-        public override Pipe<IN, OUT, M, A> Interpret<M>() =>
-            from x in Pipe.yield<IN, OUT, M>(Value)
-            from r in Next(x) 
-            select r;
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Consumer<IN, B>> f) =>
-            new Pipe<IN, OUT, B>.Yield(Value, x => Next(x).Bind(f));
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) =>
-            new Pipe<IN, OUT, B>.Yield(Value, x => Next(x).Bind(f));
-    }
-    
-    public class Fold<F, X>(K<F, X> Items, Func<X, Pipe<IN, OUT, Unit>> YieldValue, Func<Pipe<IN, OUT, A>> Next) : Pipe<IN, OUT, A>
-        where F : Foldable<F>
-    {
-        public override Pipe<IN, OUT, B> Select<B>(Func<A, B> f) => 
-            new Pipe<IN, OUT, B>.Fold<F, X>(Items, YieldValue, () => Next().Select(f));
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Pipe<IN, OUT, B>> f) => 
-            new Pipe<IN, OUT, B>.Fold<F, X>(Items, YieldValue, () => Next().Bind(f));
-
-        public override Pipe<IN, OUT, M, B> Bind<M, B>(Func<A, Pipe<IN, OUT, M, B>> f) =>
-            new(new IteratorFoldable<Unit, IN, Unit, OUT, F, X, M, B>(
-                    Items,
-                    x => YieldValue(x).Interpret<M>(),
-                    () => Next().Bind(f)));
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Consumer<IN, B>> f) => 
-            new Pipe<IN, OUT, B>.Fold<F, X>(
-                Items, 
-                YieldValue, 
-                () => Next().Bind(f));
-
-        public override Pipe<IN, OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) => 
-            new Pipe<IN, OUT, B>.Fold<F, X>(
-                Items, 
-                YieldValue, 
-                () => Next().Bind(f));
-
-        public override Pipe<IN, OUT, M, A> Interpret<M>() =>
-            new(new IteratorFoldable<Unit, IN, Unit, OUT, F, X, M, A>(
-                    Items,
-                    x => YieldValue(x).Interpret<M>(),
-                    () => Next().Interpret<M>()));
-    }
-}
diff --git a/LanguageExt.Pipes/PureProxy/Producer.cs b/LanguageExt.Pipes/PureProxy/Producer.cs
deleted file mode 100644
index ec6b85725..000000000
--- a/LanguageExt.Pipes/PureProxy/Producer.cs
+++ /dev/null
@@ -1,188 +0,0 @@
-//
-// This file contains a number of micro-free-monads that allow for creation of pure producers, consumers, and pipes.  
-// They're used to facilitate the building of Proxy derived types without the need for typing the generic arguments endlessly
-// The Haskell original could auto-infer the generic parameter types, the system here tries to replicate manually what
-// Haskell can do automatically.  Hence why there are so many implementations of SelectMany!
-//
-
-using System;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-public abstract class Producer<OUT, A>
-{
-    public abstract Producer<OUT, B> Select<B>(Func<A, B> f);
-    
-    public abstract Producer<OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f);
-    public abstract Producer<OUT, M, B> Bind<M, B>(Func<A, Producer<OUT, M, B>> f) where M : Monad<M>;
-    
-    public abstract Producer<OUT, M, A> Interpret<M>() where M : Monad<M>;
-    public abstract Pipe<IN, OUT, A> ToPipe<IN>();
-
-    public Producer<OUT, B> Bind<B>(Func<A, Pure<B>> f) =>
-        Map(x => f(x).Value);
-  
-    public Producer<OUT, B> Bind<B>(Func<A, Fail<Error>> f) =>
-        Bind(x => new Producer<OUT, B>.Fail(f(x).Value));
-
-    public Producer<OUT, M, B> Bind<M, B>(Func<A, K<M, B>> f) 
-        where M : Monad<M> =>
-        Interpret<M>().Bind(f);
-
-    public Producer<OUT, B> Bind<B>(Func<A, IO<B>> f) =>
-        Bind(x => PureProxy.ProducerLiftIO<OUT, B>(f(x)));
-    
-    public Producer<OUT, B> Map<B>(Func<A, B> f) => 
-        Select(f);
-    
-    public Producer<OUT, C> SelectMany<B, C>(Func<A, Producer<OUT, B>> f, Func<A, B, C> project) =>
-        Bind(a => f(a).Select(b => project(a, b)));
-        
-    public Producer<OUT, M, C> SelectMany<M, B, C>(Func<A, Producer<OUT, M, B>> f, Func<A, B, C> project) where M : Monad<M> =>
-        Bind(a => f(a).Select(b => project(a, b)));
-        
-    public Producer<OUT, C> SelectMany<B, C>(Func<A, Pure<B>> f, Func<A, B, C> project) =>
-        Map(a => project(a, f(a).Value));
-        
-    public Producer<OUT, C> SelectMany<B, C>(Func<A, Fail<Error>> f, Func<A, B, C> project) =>
-        Bind<C>(f);
-    
-    public Producer<OUT, C> SelectMany<B, C>(Func<A, IO<B>> f, Func<A, B, C> project) =>
-        Bind(x => f(x).Map(y => project(x, y)));
-        
-    public Producer<OUT, M, C> SelectMany<B, M, C>(Func<A, K<M, B>> f, Func<A, B, C> project)
-        where M : Monad<M> =>
-        Bind(a => M.Map(b => project(a, b), f(a)));
-            
-    public Producer<OUT, C> SelectMany<C>(Func<A, Guard<Error, Unit>> bind, Func<A, Unit, C> project ) =>
-        Map(a => bind(a) switch
-                 {
-                     { Flag: true } => project(a, default),
-                     var g          => g.OnFalse().Throw<C>()
-                 });
-                
-    public static implicit operator Producer<OUT, A>(Pure<A> ma) =>
-        new Pure(ma.Value);
-
-    public static Producer<OUT, A> operator &(
-        Producer<OUT, A> lhs,
-        Producer<OUT, A> rhs) =>
-        lhs.Bind(_ => rhs);
-
-    public class Pure(A Value) : Producer<OUT, A>
-    {
-        public override Producer<OUT, B> Select<B>(Func<A, B> f) =>
-            new Producer<OUT, B>.Pure(f(Value));
-
-        public override Producer<OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) =>
-            f(Value);
-
-        public override Producer<OUT, M, B> Bind<M, B>(Func<A, Producer<OUT, M, B>> f) =>
-            f(Value);
-
-        public override Producer<OUT, M, A> Interpret<M>() =>
-            Producer.Pure<OUT, M, A>(Value);
-
-        public override Pipe<IN, OUT, A> ToPipe<IN>() =>
-            new Pipe<IN, OUT, A>.Pure(Value);
-    }
-
-    public class Fail(Error Error) : Producer<OUT, A>
-    {
-        public override Producer<OUT, B> Select<B>(Func<A, B> _) =>
-            new Producer<OUT, B>.Fail(Error);
-
-        public override Producer<OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) => 
-            new Producer<OUT, B>.Fail(Error);
-
-        public override Producer<OUT, M, B> Bind<M, B>(Func<A, Producer<OUT, M, B>> f) =>
-            PureProxy.ProducerLift<OUT, A>(Error.Throw<A>).Bind(f);
-
-        public override Producer<OUT, M, A> Interpret<M>() => 
-            PureProxy.ProducerLift<OUT, A>(Error.Throw<A>);
-
-        public override Pipe<IN, OUT, A> ToPipe<IN>() => 
-            new Pipe<IN, OUT, A>.Fail(Error);
-    }
-
-    public class Lift<X>(Func<X> Function, Func<X, Producer<OUT, A>> Next) : Producer<OUT, A>
-    {
-        public override Producer<OUT, B> Select<B>(Func<A, B> f) => 
-            new Producer<OUT, B>.Lift<X>(Function, x => Next(x).Select(f));
-
-        public override Producer<OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) => 
-            new Producer<OUT, B>.Lift<X>(Function, x => Next(x).Bind(f));
-
-        public override Producer<OUT, M, B> Bind<M, B>(Func<A, Producer<OUT, M, B>> f) => 
-            Producer.lift<OUT, M, X>(M.Pure(Function())).SelectMany(x => Next(x).Bind(f)).ToProducer();
-
-        public override Producer<OUT, M, A> Interpret<M>() => 
-            Producer.lift<OUT, M, X>(M.Pure(Function())).Bind(x => Next(x).Interpret<M>());
-
-        public override Pipe<IN, OUT, A> ToPipe<IN>() =>
-            new Pipe<IN, OUT, A>.Lift<X>(Function, x => Next(x).ToPipe<IN>());
-    }
-
-    public class LiftIO<X>(IO<X> Effect, Func<X, Producer<OUT, A>> Next) : Producer<OUT, A>
-    {
-        public override Producer<OUT, B> Select<B>(Func<A, B> f) => 
-            new Producer<OUT, B>.LiftIO<X>(Effect, x => Next(x).Select(f));
-
-        public override Producer<OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) => 
-            new Producer<OUT, B>.LiftIO<X>(Effect, x => Next(x).Bind(f));
-
-        public override Producer<OUT, M, B> Bind<M, B>(Func<A, Producer<OUT, M, B>> f) => 
-            Producer.lift<OUT, M, X>(M.LiftIO(Effect)).SelectMany(x => Next(x).Bind(f)).ToProducer();
-
-        public override Producer<OUT, M, A> Interpret<M>() => 
-            Producer.lift<OUT, M, X>(M.LiftIO(Effect)).Bind(x => Next(x).Interpret<M>());
-
-        public override Pipe<IN, OUT, A> ToPipe<IN>() =>
-            new Pipe<IN, OUT, A>.LiftIO<X>(Effect, x => Next(x).ToPipe<IN>());
-    }
-
-    public class Yield(OUT Value, Func<Unit, Producer<OUT, A>> Next) : Producer<OUT, A>
-    {
-        public override Producer<OUT, B> Select<B>(Func<A, B> f) =>
-            new Producer<OUT, B>.Yield(Value, n => Next(n).Select(f));
-
-        public override Producer<OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) =>
-            new Producer<OUT, B>.Yield(Value, n => Next(n).Bind(f));
-
-        public override Producer<OUT, M, B> Bind<M, B>(Func<A, Producer<OUT, M, B>> f) =>
-            Interpret<M>().Bind(f).ToProducer();
-
-        public override Producer<OUT, M, A> Interpret<M>() =>
-            Producer.yield<OUT, M>(Value).Bind(x => Next(x).Interpret<M>()).ToProducer();
-
-        public override Pipe<IN, OUT, A> ToPipe<IN>() =>
-            new Pipe<IN, OUT, A>.Yield(Value, x => Next(x).ToPipe<IN>());
-    }
-    
-    public class Fold<F, X>(K<F, X> Items, Func<X, Producer<OUT, Unit>> YieldValue, Func<Producer<OUT, A>> Next) : Producer<OUT, A>
-        where F : Foldable<F>
-    {
-        public override Producer<OUT, B> Select<B>(Func<A, B> f) => 
-            new Producer<OUT, B>.Fold<F, X>(Items, YieldValue, () => Next().Select(f));
-
-        public override Producer<OUT, B> Bind<B>(Func<A, Producer<OUT, B>> f) => 
-            new Producer<OUT, B>.Fold<F, X>(Items, YieldValue, () => Next().Bind(f));
-
-        public override Producer<OUT, M, B> Bind<M, B>(Func<A, Producer<OUT, M, B>> f) =>
-            new(new IteratorFoldable<Void, Unit, Unit, OUT, F, X, M, B>(
-                    Items,
-                    x => YieldValue(x).Interpret<M>(),
-                    () => Next().Bind(f)));
-
-        public override Producer<OUT, M, A> Interpret<M>() =>
-            new(new IteratorFoldable<Void, Unit, Unit, OUT, F, X, M, A>(
-                    Items,
-                    x => YieldValue(x).Interpret<M>(),
-                    () => Next().Interpret<M>()));
-
-        public override Pipe<IN, OUT, A> ToPipe<IN>() => 
-            new Pipe<IN, OUT, A>.Fold<F, X>(Items, x => YieldValue(x).ToPipe<IN>(), () => Next().ToPipe<IN>());
-    }
-}
diff --git a/LanguageExt.Pipes/PureProxy/PureProxy.cs b/LanguageExt.Pipes/PureProxy/PureProxy.cs
deleted file mode 100644
index 7d1e50af9..000000000
--- a/LanguageExt.Pipes/PureProxy/PureProxy.cs
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// This file contains a number of micro-free-monads that allow for creation of pure producers, consumers, and pipes.  
-// They're used to facilitate the building of Proxy derived types without the need for typing the generic arguments endlessly
-// The Haskell original could auto-infer the generic parameter types, the system here tries to replicate manually what
-// Haskell can do automatically.  Hence why there are so many implementations of SelectMany!
-//
-
-using System;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-public static class PureProxy
-{
-    public static Pipe<IN, OUT, A> PipePure<IN, OUT, A>(A value) =>
-        new Pipe<IN, OUT, A>.Pure(value);
-
-    public static Producer<OUT, A> ProducerPure<OUT, A>(A value) =>
-        new Producer<OUT, A>.Pure(value);
-
-    public static Consumer<IN, A> ConsumerPure<IN, A>(A value) =>
-        new Consumer<IN, A>.Pure(value);
-
-
-    public static Pipe<IN, OUT, A> PipeFail<IN, OUT, A>(Error value) =>
-        new Pipe<IN, OUT, A>.Fail(value);
-
-    public static Producer<OUT, A> ProducerFail<OUT, A>(Error value) =>
-        new Producer<OUT, A>.Fail(value);
-
-    public static Consumer<IN, A> ConsumerFail<IN, A>(Error value) =>
-        new Consumer<IN, A>.Fail(value);
-
-
-    public static Pipe<IN, OUT, A> PipeLift<IN, OUT, A>(Func<A> t) =>
-        new Pipe<IN, OUT, A>.Lift<A>(t, PipePure<IN, OUT, A>);
-
-    public static Producer<OUT, A> ProducerLift<OUT, A>(Func<A> t) =>
-        new Producer<OUT, A>.Lift<A>(t, ProducerPure<OUT, A>);
-
-    public static Consumer<IN, A> ConsumerLift<IN, A>(Func<A> t) =>
-        new Consumer<IN, A>.Lift<A>(t, ConsumerPure<IN, A>);
-
-
-    public static Pipe<IN, OUT, A> PipeLiftIO<IN, OUT, A>(IO<A> ma) =>
-        new Pipe<IN, OUT, A>.LiftIO<A>(ma, PipePure<IN, OUT, A>);
-
-    public static Producer<OUT, A> ProducerLiftIO<OUT, A>(IO<A> ma) =>
-        new Producer<OUT, A>.LiftIO<A>(ma, ProducerPure<OUT, A>);
-
-    public static Consumer<IN, A> ConsumerLiftIO<IN, A>(IO<A> ma) =>
-        new Consumer<IN, A>.LiftIO<A>(ma, ConsumerPure<IN, A>);
-
-
-    public static Pipe<IN, OUT, Unit> PipeFold<IN, F, OUT>(K<F, OUT> items)
-        where F : Foldable<F> =>
-        new Pipe<IN, OUT, Unit>.Fold<F, OUT>(
-            items, 
-            PipeYield<IN, OUT>, 
-            () => PipePure<IN, OUT, Unit>(Prelude.unit));
-
-    public static Producer<OUT, Unit> ProducerFold<F, OUT>(K<F, OUT> items)
-        where F : Foldable<F> =>
-        new Producer<OUT, Unit>.Fold<F, OUT>(
-            items, 
-            ProducerYield, 
-            () => ProducerPure<OUT, Unit>(Prelude.unit));
-
-    public static Consumer<IN, Unit> ConsumerFold<IN, F, A>(K<F, A> items)
-        where F : Foldable<F> =>
-        new Consumer<IN, Unit>.Fold<F, A>(
-            items, 
-            _ => ConsumerPure<IN, Unit>(Prelude.unit), 
-            () => ConsumerPure<IN, Unit>(Prelude.unit));
-
-    
-    public static Consumer<IN, IN> ConsumerAwait<IN>() =>
-        new Consumer<IN, IN>.Await(ConsumerPure<IN, IN>);
-
-    public static Pipe<IN, OUT, IN> PipeAwait<IN, OUT>() =>
-        new Pipe<IN, OUT, IN>.Await(PipePure<IN, OUT, IN>);
-
-    
-    public static Producer<OUT, Unit> ProducerYield<OUT>(OUT value) =>
-        new Producer<OUT, Unit>.Yield(value, ProducerPure<OUT, Unit>);
-
-    public static Pipe<IN, OUT, Unit> PipeYield<IN, OUT>(OUT value) =>
-        new Pipe<IN, OUT, Unit>.Yield(value, PipePure<IN, OUT, Unit>);
-
-    // HERE
-    public static Consumer<IN, M, C> SelectMany<IN, M, A, B, C>(this K<M, A> ma, Func<A, Consumer<IN, B>> f, Func<A, B, C> project) where M : Monad<M> =>
-        from a in Consumer.lift<IN, M, A>(ma)
-        from b in f(a).Interpret<M>()
-        select project(a, b);
-
-    public static Producer<OUT, M, C> SelectMany<OUT, M, A, B, C>(this K<M, A> ma, Func<A, Producer<OUT, B>> f, Func<A, B, C> project) where M : Monad<M> =>
-        from a in Producer.lift<OUT, M, A>(ma)
-        from b in f(a).Interpret<M>()
-        select project(a, b);
-
-    public static Pipe<IN, OUT, M, C> SelectMany<IN, OUT, M, A, B, C>(this K<M, A> ma, Func<A, Pipe<IN, OUT, B>> f, Func<A, B, C> project) where M : Monad<M> =>
-        from a in Pipe.lift<IN, OUT, M, A>(ma)
-        from b in f(a).Interpret<M>()
-        select project(a, b);
-
-    public static Consumer<IN, M, C> SelectMany<IN, M, A, B, C>(this K<M, A> ma, Func<A, Consumer<IN, M, B>> f, Func<A, B, C> project) where M : Monad<M> =>
-        from a in Consumer.lift<IN, M, A>(ma)
-        from b in f(a)
-        select project(a, b);
-
-    public static Producer<OUT, M, C> SelectMany<OUT, M, A, B, C>(this K<M, A> ma, Func<A, Producer<OUT, M, B>> f, Func<A, B, C> project) where M : Monad<M> =>
-        from a in Producer.lift<OUT, M, A>(ma)
-        from b in f(a)
-        select project(a, b);
-
-    public static Pipe<IN, OUT, M, C> SelectMany<IN, OUT, M, A, B, C>(this K<M, A> ma, Func<A, Pipe<IN, OUT, M, B>> f, Func<A, B, C> project) where M : Monad<M> =>
-        from a in Pipe.lift<IN, OUT, M, A>(ma)
-        from b in f(a)
-        select project(a, b);
-}
diff --git a/LanguageExt.Pipes/PureProxy/README.md b/LanguageExt.Pipes/PureProxy/README.md
deleted file mode 100644
index 208af12c0..000000000
--- a/LanguageExt.Pipes/PureProxy/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-This folder contains a number of micro-free-monads that allow for creation of _pure_ producers, consumers, and pipes.   They're used to facilitate the building of `Proxy` derived types without the need for typing the generic arguments endlessly.
-
-The original Haskell Pipes library could auto-infer the generic parameter types, the system here tries to replicate manually what
-Haskell can do automatically.  Hence why there are so many implementations of `SelectMany`!
-
-Mostly you shouldn't need to care too much about the types in this folder as they're effectively 'intermediate' types.
-
diff --git a/LanguageExt.Pipes/Queue/CoreTypes.cs b/LanguageExt.Pipes/Queue/CoreTypes.cs
deleted file mode 100644
index 16a813507..000000000
--- a/LanguageExt.Pipes/Queue/CoreTypes.cs
+++ /dev/null
@@ -1,108 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-public record Queue<OUT, M, A> : Producer<OUT, M, A> 
-    where M : Monad<M>
-{
-    /// <summary>
-    /// Single queue channel
-    /// </summary>
-    readonly Channel<OUT> channel;
-
-    internal Queue(Proxy<Void, Unit, Unit, OUT, M, A> value, Channel<OUT> channel) : base(value) =>
-        this.channel = channel;
-
-    /// <summary>
-    /// Enqueue an item 
-    /// </summary>
-    public Unit Enqueue(OUT value) =>
-        channel.Post(value);
-
-    /// <summary>
-    /// Enqueue an item 
-    /// </summary>
-    public K<M, Unit> EnqueueM(OUT value) =>
-        M.Pure(Enqueue(value));
-
-    /// <summary>
-    /// Mark the Queue as done and cancel any Effect that it is in
-    /// </summary>
-    public Unit Done() =>
-        channel.Stop();
-
-    /// <summary>
-    /// Mark the Queue as done and cancel any Effect that it is in
-    /// </summary>
-    public K<M, Unit> DoneM =>
-        M.Pure(Done());
-       
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, A> ToProxy() =>
-        Value.ToProxy();
-
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, S> Bind<S>(Func<A, Proxy<Void, Unit, Unit, OUT, M, S>> f) =>
-        Value.Bind(f);
-
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, B> Map<B>(Func<A, B> f) =>
-        Value.Map(f);
-        
-    [Pure]
-    public new Producer<OUT, M, B> Select<B>(Func<A, B> f) => 
-        Value.Map(f).ToProducer();
-
-    [Pure]
-    public override Proxy<Void, Unit, C1, C, M, A> For<C1, C>(Func<OUT, Proxy<Void, Unit, C1, C, M, Unit>> body) =>
-        Value.For(body);
-
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, B> Action<B>(Proxy<Void, Unit, Unit, OUT, M, B> r) =>
-        Value.Action(r);
-
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, OUT, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<Void, Proxy<UOutA, AUInA, Void, Unit, M, A>> lhs) =>
-        Value.PairEachRequestWithRespond(lhs);
-
-    [Pure]
-    public override Proxy<UOutA, AUInA, Unit, OUT, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<Void, Proxy<UOutA, AUInA, Unit, OUT, M, Unit>> lhs) =>
-        Value.ReplaceRequest(lhs);
-
-    [Pure]
-    public override Proxy<Void, Unit, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<OUT, Proxy<Unit, OUT, DInC, DOutC, M, A>> rhs) =>
-        Value.PairEachRespondWithRequest(rhs);
-
-    [Pure]
-    public override Proxy<Void, Unit, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<OUT, Proxy<Void, Unit, DInC, DOutC, M, Unit>> rhs) =>
-        Value.ReplaceRespond(rhs);
-
-    [Pure]
-    public override Proxy<OUT, Unit, Unit, Void, M, A> Reflect() =>
-        Value.Reflect();
-
-    [Pure]
-    public override Proxy<Void, Unit, Unit, OUT, M, A> Observe() =>
-        Value.Observe();
-
-    [Pure]
-    public static Effect<M, A> operator |(Queue<OUT, M, A> p1, Consumer<OUT, M, A> p2) => 
-        Proxy.compose(p1, p2);
-        
-    [Pure]
-    public static Effect<M, A> operator |(Queue<OUT, M, A> p1, Consumer<OUT, A> p2) => 
-        Proxy.compose(p1, p2);
-    
-    [Pure]
-    public override string ToString() => 
-        "queue";
-}
diff --git a/LanguageExt.Pipes/RequestRespond/CoreTypes.cs b/LanguageExt.Pipes/RequestRespond/CoreTypes.cs
deleted file mode 100644
index fc3004f9d..000000000
--- a/LanguageExt.Pipes/RequestRespond/CoreTypes.cs
+++ /dev/null
@@ -1,240 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// One of the algebraic cases of the `Proxy` type.  This type represents a request.
-/// </summary>
-/// <typeparam name="RT">Aff system runtime</typeparam>
-/// <typeparam name="UOut">Upstream out type</typeparam>
-/// <typeparam name="UIn">Upstream in type</typeparam>
-/// <typeparam name="DIn">Downstream in type</typeparam>
-/// <typeparam name="DOut">Downstream uut type</typeparam>
-/// <typeparam name="A">The monadic bound variable - it doesn't flow up or down stream, it works just like any bound
-/// monadic variable.  If the effect represented by the `Proxy` ends, then this will be the result value.
-///
-/// When composing `Proxy` sub-types (like `Producer`, `Pipe`, `Consumer`, etc.)  </typeparam>
-public record Request<UOut, UIn, DIn, DOut, M, A>(UOut Value, Func<UIn, Proxy<UOut, UIn, DIn, DOut, M, A>> Next)
-    : Proxy<UOut, UIn, DIn, DOut, M, A>
-    where M : Monad<M> 
-{
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> ToProxy() => this;
-
-    [Pure]
-    public void Deconstruct(out UOut value, out Func<UIn, Proxy<UOut, UIn, DIn, DOut, M, A>> fun) =>
-        (value, fun) = (Value, Next);
-
-    [Pure]
-    public override Proxy<UOut, UIn, C1, C, M, A> For<C1, C>(
-        Func<DOut, Proxy<UOut, UIn, C1, C, M, DIn>> body) =>
-        ReplaceRespond(body);
-
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, S> Action<S>(
-        Proxy<UOut, UIn, DIn, DOut, M, S> r) =>
-        new Request<UOut, UIn, DIn, DOut, M, S>(Value, a => Next(a).Action(r));
-        
-    /*
-        (f >\\ p) replaces each 'request' in `this` with `lhs`.
-
-        Point-ful version of (\>\)
-    */
-    [Pure]
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, DIn, DOut, M, UIn>> lhs) =>
-        lhs(Value).Bind(b => Next(b).ReplaceRequest(lhs));
-
-    /*
-        (p //> f) replaces each 'respond' in `this` with `rhs`
-
-        Point-ful version of />/
-    */
-    [Pure]
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<DOut, Proxy<UOut, UIn, DInC, DOutC, M, DIn>> rhs) =>
-        new Request<UOut, UIn, DInC, DOutC, M, A>(Value, x => Next(x).ReplaceRespond(rhs));
-
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, UOut, UIn, M, A>> lhs) =>
-        lhs(Value).PairEachRespondWithRequest(Next);
-
-    /*
-        (p >>~ f) pairs each 'respond' in `this` with a 'request' in `rhs`.
-
-        Point-ful version of ('>~>')
-    */
-    [Pure]
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<DOut, Proxy<DIn, DOut, DInC, DOutC, M, A>> rhs) =>
-        new Request<UOut, UIn, DInC, DOutC, M, A>(Value, a => Next(a).PairEachRespondWithRequest(rhs));
-
-    [Pure]
-    public override Proxy<DOut, DIn, UIn, UOut, M, A> Reflect() =>
-        new Respond<DOut, DIn, UIn, UOut, M, A>(Value, x => Next(x).Reflect());
-
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> Observe() =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, A>(
-            M.Pure<Proxy<UOut, UIn, DIn, DOut, M, A>>(
-                new Request<UOut, UIn, DIn, DOut, M, A>(
-                    Value,
-                    x => Next(x).Observe())));
- 
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Bind<B>(Func<A, Proxy<UOut, UIn, DIn, DOut, M, B>> f) =>
-        new Request<UOut, UIn, DIn, DOut, M, B>(Value, a => Next(a).Bind(f));
-
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Map<B>(Func<A, B> f) =>
-        new Request<UOut, UIn, DIn, DOut, M, B>(Value, a => Next(a).Map(f));
-
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
-        new Request<UOut, UIn, DIn, DOut, M, B>(Value, a => Next(a).MapM(f));
-
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, IO<A>> ToIO() =>
-        new Request<UOut, UIn, DIn, DOut, M, IO<A>>(Value, a => Next(a).ToIO());
-    
-    [Pure]
-    public override string ToString() => 
-        "request";
-}
-
-/// <summary>
-/// One of the algebraic cases of the `Proxy` type.  This type represents a response.
-/// </summary>
-/// <typeparam name="RT">Aff system runtime</typeparam>
-/// <typeparam name="UOut">Upstream out type</typeparam>
-/// <typeparam name="UIn">Upstream in type</typeparam>
-/// <typeparam name="DIn">Downstream in type</typeparam>
-/// <typeparam name="DOut">Downstream uut type</typeparam>
-/// <typeparam name="A">The monadic bound variable - it doesn't flow up or down stream, it works just like any bound
-/// monadic variable.  If the effect represented by the `Proxy` ends, then this will be the result value.
-///
-/// When composing `Proxy` sub-types (like `Producer`, `Pipe`, `Consumer`, etc.)  </typeparam>
-public record Respond<UOut, UIn, DIn, DOut, M, A>(DOut Value, Func<DIn, Proxy<UOut, UIn, DIn, DOut, M, A>> Next)
-    : Proxy<UOut, UIn, DIn, DOut, M, A>
-    where M : Monad<M> 
-{
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> ToProxy() => this;
-
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Bind<B>(Func<A, Proxy<UOut, UIn, DIn, DOut, M, B>> f) =>
-        new Respond<UOut, UIn, DIn, DOut, M, B>(Value, b1 => Next(b1).Bind(f));
-
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> Map<B>(Func<A, B> f) =>
-        new Respond<UOut, UIn, DIn, DOut, M, B>(Value, a => Next(a).Map(f));
-
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
-        new Respond<UOut, UIn, DIn, DOut, M, B>(Value, a => Next(a).MapM(f));
-
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, IO<A>> ToIO() =>
-        new Respond<UOut, UIn, DIn, DOut, M, IO<A>>(Value, a => Next(a).ToIO());
-
-    [Pure]
-    public override Proxy<UOut, UIn, C1, C, M, A> For<C1, C>(Func<DOut, Proxy<UOut, UIn, C1, C, M, DIn>> body) =>
-        ReplaceRespond(body);
-            
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, S> Action<S>(Proxy<UOut, UIn, DIn, DOut, M, S> r) =>
-        new Respond<UOut, UIn, DIn, DOut, M, S>(Value, b1 => Next(b1).Action(r));
-
-    /*
-        (f >\\ p) replaces each 'request' in `this` with `lhs`.
-
-        Point-ful version of (\>\)
-    */
-    [Pure]
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> ReplaceRequest<UOutA, AUInA>(Func<UOut, Proxy<UOutA, AUInA, DIn, DOut, M, UIn>> lhs) =>
-        new Respond<UOutA, AUInA, DIn, DOut, M, A>(Value, x1 => Next(x1).ReplaceRequest(lhs));
-
-    /*
-        (p //> f) replaces each 'respond' in `this` with `rhs`
-
-        Point-ful version of />/
-    */
-    [Pure]
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<DOut, Proxy<UOut, UIn, DInC, DOutC, M, DIn>> rhs) =>
-        rhs(Value).Bind(b1 => Next(b1).ReplaceRespond(rhs));
-
-    /*
-       (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-
-       Point-ful version of ('>+>')
-    */
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, DIn, DOut, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<UOut, Proxy<UOutA, AUInA, UOut, UIn, M, A>> fb1) =>
-        new Respond<UOutA, AUInA, DIn, DOut, M, A>(Value, c1 => Next(c1).PairEachRequestWithRespond(fb1));
-
-    /*
-        (p >>~ f) pairs each 'respond' in `this` with a 'request' in `rhs`.
-
-        Point-ful version of ('>~>')
-    */
-    [Pure]
-    public override Proxy<UOut, UIn, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<DOut, Proxy<DIn, DOut, DInC, DOutC, M, A>> rhs) =>
-        rhs(Value).PairEachRequestWithRespond(Next);
-
-    [Pure]
-    public override Proxy<DOut, DIn, UIn, UOut, M, A> Reflect() =>
-        new Request<DOut, DIn, UIn, UOut, M, A>(Value, x => Next(x).Reflect());
-
-    [Pure]
-    public override Proxy<UOut, UIn, DIn, DOut, M, A> Observe() =>
-        new ProxyM<UOut, UIn, DIn, DOut, M, A>(
-            M.Pure<Proxy<UOut, UIn, DIn, DOut, M, A>>(
-                new Respond<UOut, UIn, DIn, DOut, M, A>(
-                    Value,
-                    x => Next(x).Observe())));
-
-    [Pure]
-    public void Deconstruct(out DOut value, out Func<DIn, Proxy<UOut, UIn, DIn, DOut, M, A>> fun) =>
-        (value, fun) = (Value, Next);
-    
-    [Pure]
-    public override string ToString() => 
-        "respond";
-}
diff --git a/LanguageExt.Pipes/Server/CoreTypes.cs b/LanguageExt.Pipes/Server/CoreTypes.cs
deleted file mode 100644
index 116d48715..000000000
--- a/LanguageExt.Pipes/Server/CoreTypes.cs
+++ /dev/null
@@ -1,221 +0,0 @@
-using System;
-using System.Diagnostics.Contracts;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// `Server` receives requests of type `REQ` and sends responses of type `RES`.
-///
-/// `Servers` only `respond` and never `request`.
-/// </summary>
-/// <remarks> 
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     Void〈==      〈== RES
-///           |         |
-///     Unit ==〉      ==〉 REQ
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public record Server<REQ, RES, M, A> : Proxy<Void, Unit, REQ, RES, M, A> 
-    where M : Monad<M>
-{
-    public readonly Proxy<Void, Unit, REQ, RES, M, A> Value;
-    
-    /// <summary>
-    /// Constructor
-    /// </summary>
-    /// <param name="value">Correctly shaped `Proxy` that represents a `Server`</param>
-    public Server(Proxy<Void, Unit, REQ, RES, M, A> value) =>
-        Value = value;
-        
-    /// <summary>
-    /// Calling this will effectively cast the subtype to the base.
-    /// </summary>
-    /// <remarks>This type wraps up a `Proxy` for convenience, and so it's a `Proxy` proxy.  So calling this method
-    /// isn't exactly the same as a cast operation, as it unwraps the `Proxy` from within.  It has the same effect
-    /// however, and removes a level of indirection</remarks>
-    /// <returns>A general `Proxy` type from a more specialised type</returns>
-    [Pure]
-    public override Proxy<Void, Unit, REQ, RES, M, A> ToProxy() =>
-        Value.ToProxy();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Proxy` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public override Proxy<Void, Unit, REQ, RES, M, B> Bind<B>(Func<A, Proxy<Void, Unit, REQ, RES, M, B>> f) =>
-        Value.Bind(f);
-            
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<Void, Unit, REQ, RES, M, B> Map<B>(Func<A, B> f) =>
-        Value.Map(f);
-
-    /// <summary>
-    /// Map the lifted monad
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public override Proxy<Void, Unit, REQ, RES, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
-        Value.MapM(f);
-
-    /// <summary>
-    /// Extract the lifted IO monad (if there is one)
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <returns>A new `Proxy` that represents the innermost IO monad, if it exists.</returns>
-    /// <exception cref="ExceptionalException">`Errors.UnliftIONotSupported` if there's no IO monad in the stack</exception>
-    [Pure]
-    public override Proxy<Void, Unit, REQ, RES, M, IO<A>> ToIO() =>
-        Value.ToIO();
-
-    /// <summary>
-    /// Monadic bind operation, for chaining `Server` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Server<REQ, RES, M, B> Bind<B>(Func<A, Server<REQ, RES, M, B>> f) => 
-        Value.Bind(f).ToServer();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Server` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Server<REQ, RES, M, B> SelectMany<B>(Func<A, Server<REQ, RES, M, B>> f) => 
-        Value.Bind(f).ToServer();
-        
-    /// <summary>
-    /// Monadic bind operation, for chaining `Server` computations together.
-    /// </summary>
-    /// <param name="f">The bind function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the bind operation</returns>
-    [Pure]
-    public Server<REQ, RES, M, C> SelectMany<B, C>(Func<A, Server<REQ, RES, M, B>> f, Func<A, B, C> project) => 
-        Value.Bind(a => f(a).Map(b => project(a, b))).ToServer();
-        
-    /// <summary>
-    /// Lifts a pure function into the `Proxy` domain, causing it to map the bound value within
-    /// </summary>
-    /// <param name="f">The map function</param>
-    /// <typeparam name="B">The mapped bound value type</typeparam>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the result of the map operation</returns>
-    [Pure]
-    public new Server<REQ, RES, M, B> Select<B>(Func<A, B> f) => 
-        Value.Map(f).ToServer();
-        
-    /// <summary>
-    /// `For(body)` loops over the `Proxy p` replacing each `yield` with `body`
-    /// </summary>
-    /// <param name="body">Any `yield` found in the `Proxy` will be replaced with this function.  It will be composed so
-    /// that the value yielded will be passed to the argument of the function.  That returns a `Proxy` to continue the
-    /// processing of the computation</param>
-    /// <returns>A new `Proxy` that represents the composition of this `Proxy` and the function provided</returns>
-    [Pure]
-    public override Proxy<Void, Unit, C1, C, M, A> For<C1, C>(Func<RES, Proxy<Void, Unit, C1, C, M, REQ>> body) =>
-        Value.For(body);
-
-    /// <summary>
-    /// Applicative action
-    ///
-    /// Invokes this `Proxy`, then the `Proxy r` 
-    /// </summary>
-    /// <param name="r">`Proxy` to run after this one</param>
-    [Pure]
-    public override Proxy<Void, Unit, REQ, RES, M, S> Action<S>(Proxy<Void, Unit, REQ, RES, M, S> r) =>
-        Value.Action(r);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    /// <remarks>
-    /// (f +>> p) pairs each 'request' in `this` with a 'respond' in `lhs`.
-    /// </remarks>
-    [Pure]
-    public override Proxy<UOutA, AUInA, REQ, RES, M, A> PairEachRequestWithRespond<UOutA, AUInA>(
-        Func<Void, Proxy<UOutA, AUInA, Void, Unit, M, A>> lhs) =>
-        Value.PairEachRequestWithRespond(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<UOutA, AUInA, REQ, RES, M, A> ReplaceRequest<UOutA, AUInA>(
-        Func<Void, Proxy<UOutA, AUInA, REQ, RES, M, Unit>> lhs) =>
-        Value.ReplaceRequest(lhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<Void, Unit, DInC, DOutC, M, A> PairEachRespondWithRequest<DInC, DOutC>(
-        Func<RES, Proxy<REQ, RES, DInC, DOutC, M, A>> rhs) =>
-        Value.PairEachRespondWithRequest(rhs);
-
-    /// <summary>
-    /// Used by the various composition functions and when composing proxies with the `|` operator.  You usually
-    /// wouldn't need to call this directly, instead either pipe them using `|` or call `Proxy.compose(lhs, rhs)` 
-    /// </summary>
-    [Pure]
-    public override Proxy<Void, Unit, DInC, DOutC, M, A> ReplaceRespond<DInC, DOutC>(
-        Func<RES, Proxy<Void, Unit, DInC, DOutC, M, REQ>> rhs) =>
-        Value.ReplaceRespond(rhs);
-
-    /// <summary>
-    /// Reverse the arrows of the `Proxy` to find its dual.  
-    /// </summary>
-    /// <returns>The dual of `this`</returns>
-    [Pure]
-    public override Proxy<RES, REQ, Unit, Void, M, A> Reflect() =>
-        Value.Reflect();
-
-    /// <summary>
-    /// 
-    ///     Observe(lift (Pure(r))) = Observe(Pure(r))
-    ///     Observe(lift (m.Bind(f))) = Observe(lift(m.Bind(x => lift(f(x)))))
-    /// 
-    /// This correctness comes at a small cost to performance, so use this function sparingly.
-    /// This function is a convenience for low-level pipes implementers.  You do not need to
-    /// use observe if you stick to the safe API.        
-    /// </summary>
-    [Pure]
-    public override Proxy<Void, Unit, REQ, RES, M, A> Observe() =>
-        Value.Observe();
-
-    [Pure]
-    public void Deconstruct(out Proxy<Void, Unit, REQ, RES, M, A> value) =>
-        value = Value;
-
-    /// <summary>
-    /// Chain one server after another
-    /// </summary>
-    [Pure]
-    public static Server<REQ, RES, M, A> operator &(
-        Server<REQ, RES, M, A> lhs,
-        Server<REQ, RES, M, A> rhs) =>
-        lhs.Bind(_ => rhs);
-}
diff --git a/LanguageExt.Pipes/Server/Server.cs b/LanguageExt.Pipes/Server/Server.cs
deleted file mode 100644
index bda379330..000000000
--- a/LanguageExt.Pipes/Server/Server.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-using System.Diagnostics.Contracts;
-using System.Runtime.CompilerServices;
-using LanguageExt.Common;
-using LanguageExt.Traits;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// `Server` receives requests of type `REQ` and sends responses of type `RES`.
-///
-/// `Servers` only `respond` and never `request`.
-/// </summary>
-/// <remarks> 
-///       Upstream | Downstream
-///           +---------+
-///           |         |
-///     Void〈==      〈== RES
-///           |         |
-///     Unit ==〉      ==〉REQ
-///           |    |    |
-///           +----|----+
-///                |
-///                A
-/// </remarks>
-public class Server
-{
-    /// <summary>
-    /// Monad return / pure
-    /// </summary>
-    [Pure, MethodImpl(Proxy.mops)]
-    public static Server<REQ, RES, M, R> Pure<REQ, RES, M, R>(R value) 
-        where M : Monad<M> =>
-        new Pure<Void, Unit, REQ, RES, M, R>(value).ToServer();
- 
-    /// <summary>
-    /// Send a value of type `RES` downstream and block waiting for a reply of type `REQ`
-    /// </summary>
-    /// <remarks>
-    /// `respond` is the identity of the respond category.
-    /// </remarks>
-    [Pure, MethodImpl(Proxy.mops)]
-    public static Server<REQ, RES, M, REQ> respond<REQ, RES, M>(RES value) 
-        where M : Monad<M> =>
-        new Respond<Void, Unit, REQ, RES, M, REQ>(value, r => new Pure<Void, Unit, REQ, RES, M, REQ>(r)).ToServer();
-
-    /// <summary>
-    /// Lift am IO monad into the `Proxy` monad transformer
-    /// </summary>
-    [Pure, MethodImpl(Proxy.mops)]
-    public static Server<REQ, RES, M, R> lift<REQ, RES, M, R>(K<M, R> ma) 
-        where M : Monad<M> =>
-        new ProxyM<Void, Unit, REQ, RES, M, R>(M.Map(Proxy.Pure<Void, Unit, REQ, RES, M, R>, ma)).ToServer();
-
-    /// <summary>
-    /// Lift am IO monad into the `Proxy` monad transformer
-    /// </summary>
-    [Pure, MethodImpl(Proxy.mops)]
-    public static Server<REQ, RES, M, R> liftIO<REQ, RES, M, R>(IO<R> ma) 
-        where M : Monad<M> =>
-        lift<REQ, RES, M, R>(M.LiftIO(ma));
-}
diff --git a/LanguageExt.Pipes/Utility/Channel.cs b/LanguageExt.Pipes/Utility/Channel.cs
deleted file mode 100644
index 5e16b5de1..000000000
--- a/LanguageExt.Pipes/Utility/Channel.cs
+++ /dev/null
@@ -1,114 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Threading;
-
-namespace LanguageExt.Pipes;
-
-/// <summary>
-/// An asynchronous queue that guarantees that only one item in the queue is being processed at any one time.
-/// It also guarantees that every item in the queue is processed before a `Stop` action.
-/// </summary>
-class Channel<A> : IAsyncEnumerable<A>
-{
-    readonly ConcurrentQueue<Ev<A>> queue;
-    readonly AutoResetEvent wait;
-    
-    /// <summary>
-    /// Construct
-    /// </summary>
-    public Channel()
-    {
-        queue = new ConcurrentQueue<Ev<A>>();
-        wait = new AutoResetEvent(false);
-    }
-
-    /// <summary>
-    /// Clean up
-    /// </summary>
-    ~Channel() =>
-        wait.Dispose();
-
-    /// <summary>
-    /// Number of items in the channel
-    /// </summary>
-    public int Count =>
-        queue.Count;
-
-    /// <summary>
-    /// Post an event
-    /// </summary>
-    /// <param name="event">Event</param>
-    internal Unit Post(Ev<A> @event)
-    {
-        queue.Enqueue(@event);
-        wait.Set();
-        return default;
-    }
-
-    /// <summary>
-    /// Post an item
-    /// </summary>
-    /// <param name="value">Value</param>
-    public Unit Post(A value) =>
-        Post(Ev.Item(value));
-
-    /// <summary>
-    /// Stop event
-    /// </summary>
-    public Unit Stop() =>
-        Post(Ev<A>.Stop);
-
-    public async IAsyncEnumerator<A> GetAsyncEnumerator(CancellationToken cancellationToken = default)
-    {
-        while (true)
-        {
-            await wait.WaitOneAsync(cancellationToken).ConfigureAwait(false);
-            if (cancellationToken.IsCancellationRequested) yield break;
-
-            while (queue.TryDequeue(out var item))
-            {
-                if (cancellationToken.IsCancellationRequested) yield break;
-
-                switch (item)
-                {
-                    case ItemEv<A> e:
-                        yield return e.Value;
-                        break;
-
-                    case StopEv<A>:
-                        yield break;
-                }
-            }
-        }
-    }
-}
-
-/// <summary>
-/// Event 
-/// </summary>
-static class Ev
-{
-    public static Ev<A> Item<A>(A value) => new ItemEv<A>(value);
-}
-
-/// <summary>
-/// Event 
-/// </summary>
-abstract record Ev<A>
-{
-    public static readonly Ev<A> Stop = StopEv<A>.Default;
-}
-
-/// <summary>
-/// New value event
-/// </summary>
-sealed record ItemEv<A>(A Value) : Ev<A>;
-
-/// <summary>
-/// Stop event
-/// </summary>
-sealed record StopEv<A> : Ev<A>
-{
-    public static readonly Ev<A> Default = new StopEv<A>();
-}
diff --git a/Samples/PipesExamples/Concurrent/Outbox/Outbox.Module.cs b/Samples/PipesExamples/Concurrent/Outbox/Outbox.Module.cs
deleted file mode 100644
index 7692b8ea5..000000000
--- a/Samples/PipesExamples/Concurrent/Outbox/Outbox.Module.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace LanguageExt.Pipes2.Concurrent;
-
-public partial class Outbox
-{
-    
-}
diff --git a/Samples/PipesExamples/Program.cs b/Samples/PipesExamples/Program.cs
index 271cf55a4..5add49694 100644
--- a/Samples/PipesExamples/Program.cs
+++ b/Samples/PipesExamples/Program.cs
@@ -2,11 +2,10 @@
 using LanguageExt;
 using LanguageExt.Common;
 using LanguageExt.Pipes;
-using LanguageExt.Pipes2;
 using LanguageExt.Traits;
-using static LanguageExt.Pipes2.ProducerT;
-using static LanguageExt.Pipes2.PipeT;
-using static LanguageExt.Pipes2.ConsumerT;
+using static LanguageExt.Pipes.ProducerT;
+using static LanguageExt.Pipes.PipeT;
+using static LanguageExt.Pipes.ConsumerT;
 using static LanguageExt.Prelude;
 
 /*var op = from _1 in Producer.lift<int, IO, Unit>(writeLine("pre-yield"))
diff --git a/Samples/PipesExamples/Utility/Channel.cs b/Samples/PipesExamples/Utility/Channel.cs
deleted file mode 100644
index c02cf1d1e..000000000
--- a/Samples/PipesExamples/Utility/Channel.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-using System.Collections.Concurrent;
-
-namespace LanguageExt.Pipes2;
-
-/// <summary>
-/// An asynchronous queue that guarantees that only one item in the queue is being processed at any one time.
-/// It also guarantees that every item in the queue is processed before a `Stop` action.
-/// </summary>
-class Channel<A> : IAsyncEnumerable<A>
-{
-    readonly ConcurrentQueue<Ev<A>> queue;
-    readonly AutoResetEvent wait;
-    
-    /// <summary>
-    /// Construct
-    /// </summary>
-    public Channel()
-    {
-        queue = new ConcurrentQueue<Ev<A>>();
-        wait = new AutoResetEvent(false);
-    }
-
-    /// <summary>
-    /// Clean up
-    /// </summary>
-    ~Channel() =>
-        wait.Dispose();
-
-    /// <summary>
-    /// Number of items in the channel
-    /// </summary>
-    public int Count =>
-        queue.Count;
-
-    /// <summary>
-    /// Post an event
-    /// </summary>
-    /// <param name="event">Event</param>
-    internal Unit Post(Ev<A> @event)
-    {
-        queue.Enqueue(@event);
-        wait.Set();
-        return default;
-    }
-
-    /// <summary>
-    /// Post an item
-    /// </summary>
-    /// <param name="value">Value</param>
-    public Unit Post(A value) =>
-        Post(Ev.Item(value));
-
-    /// <summary>
-    /// Stop event
-    /// </summary>
-    public Unit Stop() =>
-        Post(Ev<A>.Stop);
-
-    public async IAsyncEnumerator<A> GetAsyncEnumerator(CancellationToken cancellationToken = default)
-    {
-        while (true)
-        {
-            await wait.WaitOneAsync(cancellationToken).ConfigureAwait(false);
-            if (cancellationToken.IsCancellationRequested) yield break;
-
-            while (queue.TryDequeue(out var item))
-            {
-                if (cancellationToken.IsCancellationRequested) yield break;
-
-                switch (item)
-                {
-                    case ItemEv<A> e:
-                        yield return e.Value;
-                        break;
-
-                    case StopEv<A>:
-                        yield break;
-                }
-            }
-        }
-    }
-}
-
-/// <summary>
-/// Event 
-/// </summary>
-static class Ev
-{
-    public static Ev<A> Item<A>(A value) => new ItemEv<A>(value);
-}
-
-/// <summary>
-/// Event 
-/// </summary>
-abstract record Ev<A>
-{
-    public static readonly Ev<A> Stop = StopEv<A>.Default;
-}
-
-/// <summary>
-/// New value event
-/// </summary>
-sealed record ItemEv<A>(A Value) : Ev<A>;
-
-/// <summary>
-/// Stop event
-/// </summary>
-sealed record StopEv<A> : Ev<A>
-{
-    public static readonly Ev<A> Default = new StopEv<A>();
-}