From 55da8d9d8ab3f3e2f46ddd78529fab20c99a507a Mon Sep 17 00:00:00 2001
From: Paul Louth <p.louth@gmail.com>
Date: Fri, 14 Feb 2025 19:12:24 +0000
Subject: [PATCH] Enhance IO Monad with new robustness and utilities

Added extensive functionality to the IO Monad, including local cancellation, retry, repeat, and fold mechanisms to improve resource management and scheduling options. Updated method implementations and removed obsolete functionality for improved consistency and performance.
---
 LanguageExt.Core/Common/Errors.cs             |  12 +-
 LanguageExt.Core/Common/Exceptions.cs         |   2 +-
 .../Extensions/Eff.Extensions.cs              |   8 +-
 .../Extensions/Eff.Extensions.cs              |  11 +-
 LanguageExt.Core/Effects/IO/IO.Extensions.cs  | 196 ++-------
 LanguageExt.Core/Effects/IO/IO.Module.cs      |  20 +-
 LanguageExt.Core/Effects/IO/IO.Monad.cs       | 390 ++++++++++++++++++
 LanguageExt.Core/Effects/IO/IO.Prelude.cs     |  72 +---
 .../Prelude.Collections.cs                    |  16 +
 .../Traits/Monads/MonadIO/MonadIO.Trait.cs    | 389 ++++++++++++++++-
 .../Concurrent/Inbox/Inbox.DSL.cs             |  20 +-
 LanguageExt.Pipes/Concurrent/Inbox/Inbox.cs   |   4 +-
 .../Concurrent/Mailbox/Mailbox.Module.cs      |  10 +-
 .../Concurrent/Outbox/Outbox.DSL.cs           |  18 +-
 LanguageExt.Pipes/Concurrent/Outbox/Outbox.cs |   3 +-
 LanguageExt.Pipes/Consumer/Consumer.Module.cs |  30 +-
 LanguageExt.Pipes/Effect/Effect.Module.cs     |  13 +
 LanguageExt.Pipes/Effect/Effect.Monad.cs      |   5 +
 .../EffectT/EffectT.Extensions.cs             |   6 +
 LanguageExt.Pipes/EffectT/EffectT.Monad.cs    |   5 +
 LanguageExt.Pipes/Pipe/Pipe.Module.cs         |  51 +++
 LanguageExt.Pipes/Pipe/Pipe.cs                |   3 +-
 LanguageExt.Pipes/PipeT/PipeT.Module.cs       |  22 +
 LanguageExt.Pipes/PipeT/PipeT.Monad.cs        |   5 +
 LanguageExt.Pipes/Producer/Producer.Module.cs |  77 ++--
 .../ProducerT/ProducerT.Module.cs             |  46 ++-
 LanguageExt.Tests/PipesTests.cs               |  19 +-
 LanguageExt.Tests/Sys/Diag/ActivityTests.cs   |   6 +-
 .../EffectsExamples/Examples/QueueExample.cs  |  11 +-
 Samples/PipesExamples/Program.cs              |  56 +--
 Samples/TestBed.Web/Program.cs                |   3 +-
 Samples/TestBed/PipesTest.cs                  |  42 +-
 Samples/TestBed/Program.cs                    |  65 +--
 33 files changed, 1152 insertions(+), 484 deletions(-)

diff --git a/LanguageExt.Core/Common/Errors.cs b/LanguageExt.Core/Common/Errors.cs
index 9c66cfe3e..989f75cf9 100644
--- a/LanguageExt.Core/Common/Errors.cs
+++ b/LanguageExt.Core/Common/Errors.cs
@@ -120,22 +120,22 @@ public static class Errors
     public static readonly Error LiftIONotSupported = (LiftIONotSupportedCode, LiftIONotSupportedText);
 
     /// <summary>
-    /// Transformer stack has no unliftIO support error text
+    /// Transformer stack has no `ToIO` support error text
     /// </summary>
-    public const string UnliftIONotSupportedText =
+    public const string ToIONotSupportedText =
         "The IO monad is not in the monad-transformer stack or MonadIO.ToIO has not been implemented in the trait " +
         "implementation for your monad-type.  Therefore it's not possible to leverage `MonadIO` unlifting trait "   +
         "functionality. To resolve this, implement `MonadIO.ToIO` and/or `MonadIO,MapIO`.";
 
     /// <summary>
-    /// Transformer stack has no unliftIO support error code
+    /// Transformer stack has no `ToIO` support error code
     /// </summary>
-    public const int UnliftIONotSupportedCode = -2000000008;
+    public const int ToIONotSupportedCode = -2000000008;
 
     /// <summary>
-    /// Transformer stack has no unliftIO support error
+    /// Transformer stack has no `ToIO` support error
     /// </summary>
-    public static readonly Error UnliftIONotSupported = (UnliftIONotSupportedCode, UnliftIONotSupportedText);
+    public static readonly Error ToIONotSupported = (ToIONotSupportedCode, ToIONotSupportedText);
 
     /// <summary>
     /// End-of-stream error text
diff --git a/LanguageExt.Core/Common/Exceptions.cs b/LanguageExt.Core/Common/Exceptions.cs
index 17d4c172a..d6eee28ad 100644
--- a/LanguageExt.Core/Common/Exceptions.cs
+++ b/LanguageExt.Core/Common/Exceptions.cs
@@ -50,7 +50,7 @@ public class Exceptions
     /// <summary>
     /// Transformer stack has no unliftIO support error
     /// </summary>
-    public static readonly ExceptionalException UnliftIONotSupported = new (Errors.UnliftIONotSupportedText, Errors.UnliftIONotSupportedCode);
+    public static readonly ExceptionalException UnliftIONotSupported = new (Errors.ToIONotSupportedText, Errors.ToIONotSupportedCode);
 
     /// <summary>
     /// End-of-stream error
diff --git a/LanguageExt.Core/Effects/Eff/Eff no runtime/Extensions/Eff.Extensions.cs b/LanguageExt.Core/Effects/Eff/Eff no runtime/Extensions/Eff.Extensions.cs
index 6c49d7434..ed41e0006 100644
--- a/LanguageExt.Core/Effects/Eff/Eff no runtime/Extensions/Eff.Extensions.cs	
+++ b/LanguageExt.Core/Effects/Eff/Eff no runtime/Extensions/Eff.Extensions.cs	
@@ -163,7 +163,7 @@ public static Eff<D> SelectMany<A, B, C, D>(
         this (K<Eff, A> First, K<Eff, B> Second) self,
         Func<(A First, B Second), K<Eff, C>> bind,
         Func<(A First, B Second), C, D> project) =>
-        self.ZipIO().Bind(ab => bind(ab).Map(c => project(ab, c))).As();
+        self.Zip().Bind(ab => bind(ab).Map(c => project(ab, c))).As();
 
     /// <summary>
     /// Monadic bind and project with paired IO monads
@@ -172,7 +172,7 @@ public static Eff<D> SelectMany<A, B, C, D>(
         this K<Eff, A> self,
         Func<A, (K<Eff, B> First, K<Eff, C> Second)> bind,
         Func<A, (B First, C Second), D> project) =>
-        self.As().Bind(a => bind(a).ZipIO().Map(cd => project(a, cd)));
+        self.As().Bind(a => bind(a).Zip().Map(cd => project(a, cd)));
 
     /// <summary>
     /// Monadic bind and project with paired IO monads
@@ -181,7 +181,7 @@ public static Eff<E> SelectMany<A, B, C, D, E>(
         this (K<Eff, A> First, K<Eff, B> Second, K<Eff, C> Third) self,
         Func<(A First, B Second, C Third), K<Eff, D>> bind,
         Func<(A First, B Second, C Third), D, E> project) =>
-        self.ZipIO().Bind(ab => bind(ab).Map(c => project(ab, c))).As();
+        self.Zip().Bind(ab => bind(ab).Map(c => project(ab, c))).As();
 
     /// <summary>
     /// Monadic bind and project with paired IO monads
@@ -190,5 +190,5 @@ public static Eff<E> SelectMany<A, B, C, D, E>(
         this K<Eff, A> self,
         Func<A, (K<Eff, B> First, K<Eff, C> Second, K<Eff, D> Third)> bind,
         Func<A, (B First, C Second, D Third), E> project) =>
-        self.As().Bind(a => bind(a).ZipIO().Map(cd => project(a, cd)));
+        self.As().Bind(a => bind(a).Zip().Map(cd => project(a, cd)));
 }
diff --git a/LanguageExt.Core/Effects/Eff/Eff with runtime/Extensions/Eff.Extensions.cs b/LanguageExt.Core/Effects/Eff/Eff with runtime/Extensions/Eff.Extensions.cs
index 7e6a78961..f9c8d3c66 100644
--- a/LanguageExt.Core/Effects/Eff/Eff with runtime/Extensions/Eff.Extensions.cs	
+++ b/LanguageExt.Core/Effects/Eff/Eff with runtime/Extensions/Eff.Extensions.cs	
@@ -1,11 +1,8 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
-using LanguageExt.Common;
 using LanguageExt.Traits;
-using static LanguageExt.Prelude;
 
 namespace LanguageExt;
 
@@ -185,7 +182,7 @@ public static Eff<RT, D> SelectMany<RT, A, B, C, D>(
         this (K<Eff<RT>, A> First, K<Eff<RT>, B> Second) self,
         Func<(A First, B Second), K<Eff<RT>, C>> bind,
         Func<(A First, B Second), C, D> project) =>
-        self.ZipIO().Bind(ab => bind(ab).Map(c => project(ab, c))).As();
+        self.Zip().Bind(ab => bind(ab).Map(c => project(ab, c))).As();
 
     /// <summary>
     /// Monadic bind and project with paired IO monads
@@ -194,7 +191,7 @@ public static Eff<RT, D> SelectMany<RT, A, B, C, D>(
         this K<Eff<RT>, A> self,
         Func<A, (K<Eff<RT>, B> First, K<Eff<RT>, C> Second)> bind,
         Func<A, (B First, C Second), D> project) =>
-        self.As().Bind(a => bind(a).ZipIO().Map(cd => project(a, cd)));
+        self.As().Bind(a => bind(a).Zip().Map(cd => project(a, cd)));
 
     /// <summary>
     /// Monadic bind and project with paired IO monads
@@ -203,7 +200,7 @@ public static Eff<RT, E> SelectMany<RT, A, B, C, D, E>(
         this (K<Eff<RT>, A> First, K<Eff<RT>, B> Second, K<Eff<RT>, C> Third) self,
         Func<(A First, B Second, C Third), K<Eff<RT>, D>> bind,
         Func<(A First, B Second, C Third), D, E> project) =>
-        self.ZipIO().Bind(ab => bind(ab).Map(c => project(ab, c))).As();
+        self.Zip().Bind(ab => bind(ab).Map(c => project(ab, c))).As();
 
     /// <summary>
     /// Monadic bind and project with paired IO monads
@@ -212,5 +209,5 @@ public static Eff<RT, E> SelectMany<RT, A, B, C, D, E>(
         this K<Eff<RT>, A> self,
         Func<A, (K<Eff<RT>, B> First, K<Eff<RT>, C> Second, K<Eff<RT>, D> Third)> bind,
         Func<A, (B First, C Second, D Third), E> project) =>
-        self.As().Bind(a => bind(a).ZipIO().Map(cd => project(a, cd)));
+        self.As().Bind(a => bind(a).Zip().Map(cd => project(a, cd)));
 }
diff --git a/LanguageExt.Core/Effects/IO/IO.Extensions.cs b/LanguageExt.Core/Effects/IO/IO.Extensions.cs
index 82d805bb3..7b46173a1 100644
--- a/LanguageExt.Core/Effects/IO/IO.Extensions.cs
+++ b/LanguageExt.Core/Effects/IO/IO.Extensions.cs
@@ -83,7 +83,7 @@ public static IO<C> SelectMany<A, B, C>(this K<IO, A> ma, Func<A, K<IO, B>> bind
     /// <returns>Result of the computation</returns>
     public static K<M, A> LocalIO<M, A>(this K<M, A> ma) 
         where M : Monad<M> =>
-        ma.MapIO(io => io.Local());
+        M.LocalIO(ma);
 
     /// <summary>
     /// Make this IO computation run on the `SynchronizationContext` that was captured at the start
@@ -94,7 +94,7 @@ public static K<M, A> LocalIO<M, A>(this K<M, A> ma)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static K<M, A> PostIO<M, A>(this K<M, A> ma)
         where M : Monad<M> =>
-        ma.MapIO(io => io.Post());        
+        M.PostIO(ma);
 
     /// <summary>
     /// Await a forked operation
@@ -103,7 +103,7 @@ public static K<M, A> PostIO<M, A>(this K<M, A> ma)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static K<M, A> Await<M, A>(this K<M, ForkIO<A>> ma)
         where M : Monad<M> =>
-        ma.MapIO(io => io.Bind(f => f.Await));
+        M.Await(ma);
 
     /// <summary>
     /// Queue this IO operation to run on the thread-pool. 
@@ -116,8 +116,7 @@ public static K<M, A> Await<M, A>(this K<M, ForkIO<A>> ma)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static K<M, ForkIO<A>> ForkIO<M, A>(this K<M, A> ma, Option<TimeSpan> timeout = default)
         where M : Monad<M> =>
-        ma.MapIO(io => io.Fork(timeout));
-    
+        M.ForkIO(ma, timeout);
 
     /// <summary>
     /// Queue this IO operation to run on the thread-pool. 
@@ -133,7 +132,6 @@ public static K<M, ForkIO<Option<A>>> ForkIO<M, A>(this StreamT<M, A> ma, Option
         ma.Run()
           .Map(oht => oht.Map(ht => ht.Item1))
           .ForkIO(timeout);
-    
 
     /// <summary>
     /// Timeout operation if it takes too long
@@ -142,7 +140,7 @@ public static K<M, ForkIO<Option<A>>> ForkIO<M, A>(this StreamT<M, A> ma, Option
     [MethodImpl(Opt.Default)]
     public static K<M, A> TimeoutIO<M, A>(this K<M, A> ma, TimeSpan timeout)
         where M : Monad<M>, MonadIO<M> =>
-        ma.MapIO(io => io.Timeout(timeout));
+        M.TimeoutIO(ma, timeout);
     
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //
@@ -156,9 +154,9 @@ public static K<M, A> TimeoutIO<M, A>(this K<M, A> ma, TimeSpan timeout)
     /// </summary>
     [Pure]
     [MethodImpl(Opt.Default)]
-    public static K<M, A> BracketIO<M, A>(this K<M, A> ma)         
+    public static K<M, A> BracketIO<M, A>(this K<M, A> ma)
         where M : Monad<M> =>
-        ma.MapIO(io => io.Bracket());
+        M.BracketIO(ma);
 
     /// <summary>
     /// When acquiring, using, and releasing various resources, it can be quite convenient to write a function to manage
@@ -173,7 +171,7 @@ public static K<M, C> BracketIO<M, A, B, C>(
         Func<A, IO<C>> Use, 
         Func<A, IO<B>> Fin) 
         where M : Monad<M> =>
-        acq.MapIO(io => io.Bracket(Use, Fin));
+        M.BracketIO(acq, Use, Fin);
 
     /// <summary>
     /// When acquiring, using, and releasing various resources, it can be quite convenient to write a function to manage
@@ -190,7 +188,7 @@ public static K<M, C> BracketIO<M, A, B, C>(
         Func<Error, IO<C>> Catch,
         Func<A, IO<B>> Fin)
         where M : Monad<M> =>
-        acq.MapIO(io => io.Bracket(Use, Catch, Fin));
+        M.BracketIO(acq, Use, Catch, Fin);
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //
@@ -207,7 +205,7 @@ public static K<M, C> BracketIO<M, A, B, C>(
     /// <returns>The result of the last invocation</returns>
     public static K<M, A> RepeatIO<M, A>(this K<M, A> ma)
         where M : Monad<M> =>
-        ma.MapIO(io => io.Repeat());
+        M.RepeatIO(ma);
 
     /// <summary>
     /// Keeps repeating the computation, until the scheduler expires, or an error occurs  
@@ -222,7 +220,7 @@ public static K<M, A> RepeatIO<M, A>(
         this K<M, A> ma, 
         Schedule schedule)
         where M : Monad<M> =>
-        ma.MapIO(io => io.Repeat(schedule));
+        M.RepeatIO(ma, schedule);
 
     /// <summary>
     /// Keeps repeating the computation until the predicate returns false, or an error occurs 
@@ -237,7 +235,7 @@ public static K<M, A> RepeatWhileIO<M, A>(
         this K<M, A> ma, 
         Func<A, bool> predicate) 
         where M : Monad<M> =>
-        ma.MapIO(io => io.RepeatWhile(predicate));
+        M.RepeatWhileIO(ma, predicate);
 
     /// <summary>
     /// Keeps repeating the computation, until the scheduler expires, or the predicate returns false, or an error occurs
@@ -254,7 +252,7 @@ public static K<M, A> RepeatWhileIO<M, A>(
         Schedule schedule,
         Func<A, bool> predicate)
         where M : Monad<M> =>
-        ma.MapIO(io => io.RepeatWhile(schedule, predicate));
+        M.RepeatWhileIO(ma, schedule, predicate);
 
     /// <summary>
     /// Keeps repeating the computation until the predicate returns true, or an error occurs
@@ -269,7 +267,7 @@ public static K<M, A> RepeatUntilIO<M, A>(
         this K<M, A> ma, 
         Func<A, bool> predicate)
         where M : Monad<M> =>
-        ma.MapIO(io => io.RepeatUntil(predicate));
+        M.RepeatUntilIO(ma, predicate);
 
     /// <summary>
     /// Keeps repeating the computation, until the scheduler expires, or the predicate returns true, or an error occurs
@@ -286,7 +284,7 @@ public static K<M, A> RepeatUntilIO<M, A>(
         Schedule schedule,
         Func<A, bool> predicate)
         where M : Monad<M> =>
-        ma.MapIO(io => io.RepeatUntil(schedule, predicate));
+        M.RepeatUntilIO(ma, schedule, predicate);
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //
@@ -306,7 +304,7 @@ public static K<M, A> RepeatUntilIO<M, A>(
     /// </remarks>
     public static K<M, A> RetryIO<M, A>(this K<M, A> ma) 
         where M : Monad<M> =>
-        ma.MapIO(io => io.Retry());
+        M.RetryIO(ma);
 
     /// <summary>
     /// Retry if the IO computation fails 
@@ -323,7 +321,7 @@ public static K<M, A> RetryIO<M, A>(
         this K<M, A> ma,
         Schedule schedule) 
         where M : Monad<M> =>
-        ma.MapIO(io => io.Retry(schedule));
+        M.RetryIO(ma, schedule);
 
     /// <summary>
     /// Retry if the IO computation fails 
@@ -341,7 +339,7 @@ public static K<M, A> RetryWhileIO<M, A>(
         this K<M, A> ma,
         Func<Error, bool> predicate)  
         where M : Monad<M> =>
-        ma.MapIO(io => io.RetryWhile(predicate));
+        M.RetryWhileIO(ma, predicate);
 
     /// <summary>
     /// Retry if the IO computation fails 
@@ -360,7 +358,7 @@ public static K<M, A> RetryWhileIO<M, A>(
         Schedule schedule,
         Func<Error, bool> predicate) 
         where M : Monad<M> =>
-        ma.MapIO(io => io.RetryWhile(schedule, predicate));
+        M.RetryWhileIO(ma, schedule, predicate);
 
     /// <summary>
     /// Retry if the IO computation fails 
@@ -378,7 +376,7 @@ public static K<M, A> RetryUntilIO<M, A>(
         this K<M, A> ma,
         Func<Error, bool> predicate)
         where M : Monad<M> =>
-        ma.MapIO(io => io.RetryUntil(predicate));
+        M.RetryUntilIO(ma, predicate);
 
     /// <summary>
     /// Retry if the IO computation fails 
@@ -397,7 +395,7 @@ public static K<M, A> RetryUntilIO<M, A>(
         Schedule schedule,
         Func<Error, bool> predicate) 
         where M : Monad<M> =>
-        ma.MapIO(io => io.RetryUntil(schedule, predicate));
+        M.RetryUntilIO(ma, schedule, predicate);
     
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     // 
@@ -410,14 +408,14 @@ public static K<M, S> FoldIO<S, M, A>(
         S initialState,
         Func<S, A, S> folder)
         where M : Monad<M> =>
-        ma.MapIO(io => io.Fold(schedule, initialState, folder));
+        M.FoldIO(ma, schedule, initialState, folder);
 
     public static K<M, S> FoldIO<S, M, A>(
         this K<M, A> ma,
         S initialState,
         Func<S, A, S> folder)
         where M : Monad<M> =>
-        ma.MapIO(io => io.Fold(initialState, folder));
+        M.FoldIO(ma, initialState, folder);
 
     public static K<M, S> FoldWhileIO<S, M, A>(
         this K<M, A> ma,
@@ -426,7 +424,7 @@ public static K<M, S> FoldWhileIO<S, M, A>(
         Func<S, A, S> folder,
         Func<S, bool> stateIs)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldWhile(schedule, initialState, folder, stateIs));
+        M.FoldWhileIO(ma, schedule, initialState, folder, stateIs);
 
     public static K<M, S> FoldWhileIO<S, M, A>(
         this K<M, A> ma,
@@ -434,7 +432,7 @@ public static K<M, S> FoldWhileIO<S, M, A>(
         Func<S, A, S> folder,
         Func<S, bool> stateIs)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldWhile(initialState, folder, stateIs));
+        M.FoldWhileIO(ma, initialState, folder, stateIs);
 
     public static K<M, S> FoldWhileIO<S, M, A>(
         this K<M, A> ma,
@@ -443,7 +441,7 @@ public static K<M, S> FoldWhileIO<S, M, A>(
         Func<S, A, S> folder,
         Func<A, bool> valueIs)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldWhile(schedule, initialState, folder, valueIs));
+        M.FoldWhileIO(ma, schedule, initialState, folder, valueIs);
 
     public static K<M, S> FoldWhileIO<S, M, A>(
         this K<M, A> ma,
@@ -451,7 +449,7 @@ public static K<M, S> FoldWhileIO<S, M, A>(
         Func<S, A, S> folder,
         Func<A, bool> valueIs)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldWhile(initialState, folder, valueIs));
+        M.FoldWhileIO(ma, initialState, folder, valueIs);
     
     public static K<M, S> FoldWhileIO<S, M, A>(
         this K<M, A> ma,
@@ -460,7 +458,7 @@ public static K<M, S> FoldWhileIO<S, M, A>(
         Func<S, A, S> folder,
         Func<(S State, A Value), bool> predicate)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldWhile(schedule, initialState, folder, predicate));
+        M.FoldWhileIO(ma, schedule, initialState, folder, predicate);
 
     public static K<M, S> FoldWhileIO<S, M, A>(
         this K<M, A> ma,
@@ -468,7 +466,7 @@ public static K<M, S> FoldWhileIO<S, M, A>(
         Func<S, A, S> folder,
         Func<(S State, A Value), bool> predicate)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldWhile(initialState, folder, predicate));
+        M.FoldWhileIO(ma, initialState, folder, predicate);
     
     public static K<M, S> FoldUntilIO<S, M, A>(
         this K<M, A> ma,
@@ -477,7 +475,7 @@ public static K<M, S> FoldUntilIO<S, M, A>(
         Func<S, A, S> folder,
         Func<S, bool> stateIs)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldUntil(schedule, initialState, folder, stateIs));
+        M.FoldUntilIO(ma, schedule, initialState, folder, stateIs);
     
     public static K<M, S> FoldUntilIO<S, M, A>(
         this K<M, A> ma,
@@ -485,7 +483,7 @@ public static K<M, S> FoldUntilIO<S, M, A>(
         Func<S, A, S> folder,
         Func<S, bool> stateIs)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldUntil(initialState, folder, stateIs));
+        M.FoldUntilIO(ma, initialState, folder, stateIs);
     
     public static K<M, S> FoldUntilIO<S, M, A>(
         this K<M, A> ma,
@@ -494,7 +492,7 @@ public static K<M, S> FoldUntilIO<S, M, A>(
         Func<S, A, S> folder,
         Func<A, bool> valueIs)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldUntil(schedule, initialState, folder, valueIs));
+        M.FoldUntilIO(ma, schedule, initialState, folder, valueIs);
     
     public static K<M, S> FoldUntilIO<S, M, A>(
         this K<M, A> ma,
@@ -502,7 +500,7 @@ public static K<M, S> FoldUntilIO<S, M, A>(
         Func<S, A, S> folder,
         Func<A, bool> valueIs)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldUntil(initialState, folder, valueIs));
+        M.FoldUntilIO(ma, initialState, folder, valueIs);
     
     public static K<M, S> FoldUntilIO<S, M, A>(
         this K<M, A> ma,
@@ -510,7 +508,7 @@ public static K<M, S> FoldUntilIO<S, M, A>(
         Func<S, A, S> folder,
         Func<(S State, A Value), bool> predicate)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldUntil(initialState, folder, predicate));
+        M.FoldUntilIO(ma, initialState, folder, predicate);
 
     public static K<M, S> FoldUntilIO<S, M, A>(
         this K<M, A> ma,
@@ -519,129 +517,5 @@ public static K<M, S> FoldUntilIO<S, M, A>(
         Func<S, A, S> folder,
         Func<(S State, A Value), bool> predicate)
         where M : Monad<M> =>
-        ma.MapIO(io => io.FoldUntil(schedule, initialState, folder, predicate));
-    
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    //
-    //  Zipping
-    //
-
-    /// <summary>
-    /// Takes two IO monads and zips their result
-    /// </summary>
-    /// <remarks>
-    /// Asynchronous operations will run concurrently
-    /// </remarks>
-    /// <param name="tuple">Tuple of IO monads to run</param>
-    /// <typeparam name="M">Monad trait type</typeparam>
-    /// <typeparam name="A">First IO monad bound value type</typeparam>
-    /// <typeparam name="B">Second IO monad bound value type</typeparam>
-    /// <returns>IO monad</returns>
-    public static K<M, (A First, B Second)> ZipIO<M, A, B>(
-        this (K<M, A> First, K<M, B> Second) tuple)
-        where M : Monad<M> =>
-        fun((A a, B b) => (a, b))
-           .Map(tuple.First)
-           .Apply(tuple.Second);
-
-    /// <summary>
-    /// Takes two IO monads and zips their result
-    /// </summary>
-    /// <remarks>
-    /// Asynchronous operations will run concurrently
-    /// </remarks>
-    /// <param name="tuple">Tuple of IO monads to run</param>
-    /// <typeparam name="M">Monad trait type</typeparam>
-    /// <typeparam name="A">First IO monad bound value type</typeparam>
-    /// <typeparam name="B">Second IO monad bound value type</typeparam>
-    /// <typeparam name="C">Third IO monad bound value type</typeparam>
-    /// <returns>IO monad</returns>
-    public static K<M, (A First, B Second, C Third)> ZipIO<M, A, B, C>(
-        this (K<M, A> First,
-            K<M, B> Second,
-            K<M, C> Third) tuple)
-        where M : Monad<M> =>
-        fun((A a, B b, C c) => (a, b, c))
-           .Map(tuple.First)
-           .Apply(tuple.Second)
-           .Apply(tuple.Third);
-
-    /// <summary>
-    /// Takes two IO monads and zips their result
-    /// </summary>
-    /// <remarks>
-    /// Asynchronous operations will run concurrently
-    /// </remarks>
-    /// <param name="tuple">Tuple of IO monads to run</param>
-    /// <typeparam name="M">Monad trait type</typeparam>
-    /// <typeparam name="A">First IO monad bound value type</typeparam>
-    /// <typeparam name="B">Second IO monad bound value type</typeparam>
-    /// <typeparam name="C">Third IO monad bound value type</typeparam>
-    /// <typeparam name="D">Fourth IO monad bound value type</typeparam>
-    /// <returns>IO monad</returns>
-    public static K<M, (A First, B Second, C Third, D Fourth)> ZipIO<M, A, B, C, D>(
-        this (K<M, A> First, 
-              K<M, B> Second, 
-              K<M, C> Third, 
-              K<M, D> Fourth) tuple) 
-        where M : Monad<M> =>
-        fun((A a, B b, C c, D d) => (a, b, c, d))
-           .Map(tuple.First)
-           .Apply(tuple.Second)
-           .Apply(tuple.Third)
-           .Apply(tuple.Fourth);
-    
-    /// <summary>
-    /// Takes two IO monads and zips their result
-    /// </summary>
-    /// <remarks>
-    /// Asynchronous operations will run concurrently
-    /// </remarks>
-    /// <typeparam name="M">Monad trait type</typeparam>
-    /// <typeparam name="A">First IO monad bound value type</typeparam>
-    /// <typeparam name="B">Second IO monad bound value type</typeparam>
-    /// <returns>IO monad</returns>
-    public static K<M, (A First, B Second)> ZipIO<M, A, B>(
-        this K<M, A> First,
-        K<M, B> Second) 
-        where M : Monad<M> =>
-        (First, Second).ZipIO();
-
-    /// <summary>
-    /// Takes two IO monads and zips their result
-    /// </summary>
-    /// <remarks>
-    /// Asynchronous operations will run concurrently
-    /// </remarks>
-    /// <typeparam name="M">Monad trait type</typeparam>
-    /// <typeparam name="A">First IO monad bound value type</typeparam>
-    /// <typeparam name="B">Second IO monad bound value type</typeparam>
-    /// <typeparam name="C">Third IO monad bound value type</typeparam>
-    /// <returns>IO monad</returns>
-    public static K<M, (A First, B Second, C Third)> ZipIO<M, A, B, C>(
-        this K<M, A> First, 
-        K<M, B> Second, 
-        K<M, C> Third) 
-        where M : Monad<M> =>
-        (First, Second, Third).ZipIO();
-    
-    /// <summary>
-    /// Takes two IO monads and zips their result
-    /// </summary>
-    /// <remarks>
-    /// Asynchronous operations will run concurrently
-    /// </remarks>
-    /// <typeparam name="M">Monad trait type</typeparam>
-    /// <typeparam name="A">First IO monad bound value type</typeparam>
-    /// <typeparam name="B">Second IO monad bound value type</typeparam>
-    /// <typeparam name="C">Third IO monad bound value type</typeparam>
-    /// <typeparam name="D">Fourth IO monad bound value type</typeparam>
-    /// <returns>IO monad</returns>
-    public static K<M, (A First, B Second, C Third, D Fourth)> ZipIO<M, A, B, C, D>(
-        this K<M, A> First, 
-        K<M, B> Second, 
-        K<M, C> Third, 
-        K<M, D> Fourth) 
-        where M : Monad<M> =>
-        (First, Second, Third, Fourth).ZipIO();    
+        M.FoldUntilIO(ma, schedule, initialState, folder, predicate);
 }
diff --git a/LanguageExt.Core/Effects/IO/IO.Module.cs b/LanguageExt.Core/Effects/IO/IO.Module.cs
index c0a0e522c..7e7db7475 100644
--- a/LanguageExt.Core/Effects/IO/IO.Module.cs
+++ b/LanguageExt.Core/Effects/IO/IO.Module.cs
@@ -74,7 +74,7 @@ public static IO<Unit> lift(Action f) =>
     /// <returns>Result of the computation</returns>
     public static K<M, A> local<M, A>(K<M, A> ma) 
         where M : Monad<M> =>
-        ma.LocalIO();
+        M.LocalIO(ma);
 
     /// <summary>
     /// Creates a local cancellation environment
@@ -163,18 +163,6 @@ public static IO<A> combine<A>(K<IO, A> ma, K<IO, A> mb) =>
     public static K<M, B> mapIO<M, A, B>(K<M, A> ma, Func<IO<A>, IO<B>> f)
         where M : Monad<M> =>
         M.MapIO(ma, f);    
-    
-    /// <summary>
-    /// Queue this IO operation to run on the thread-pool. 
-    /// </summary>
-    /// <param name="timeout">Maximum time that the forked IO operation can run for. `None` for no timeout.</param>
-    /// <returns>Returns a `ForkIO` data-structure that contains two IO effects that can be used to either cancel
-    /// the forked IO operation or to await the result of it.
-    /// </returns>
-    [Pure]
-    [MethodImpl(Opt.Default)]
-    public static IO<ForkIO<A>> fork<A>(K<IO, A> ma, Option<TimeSpan> timeout = default) =>
-        ma.As().Fork(timeout);
 
     /// <summary>
     /// Queue this IO operation to run on the thread-pool. 
@@ -187,7 +175,7 @@ public static IO<ForkIO<A>> fork<A>(K<IO, A> ma, Option<TimeSpan> timeout = defa
     [MethodImpl(Opt.Default)]
     public static K<M, ForkIO<A>> fork<M, A>(K<M, A> ma, Option<TimeSpan> timeout = default)
         where M : Monad<M> =>
-        mapIO(ma, mio => fork(mio , timeout));
+        M.ForkIO(ma, timeout);
 
     /// <summary>
     /// Yield the thread for the specified duration or until cancelled.
@@ -199,7 +187,7 @@ public static K<M, ForkIO<A>> fork<M, A>(K<M, A> ma, Option<TimeSpan> timeout =
     public static IO<Unit> yieldFor(Duration duration) =>
         Math.Abs(duration.Milliseconds) < 0.00000001
             ? unitIO
-            : IO<Unit>.LiftAsync(env => yieldFor(duration, env.Token));
+            : IO<Unit>.LiftAsync(e => yieldFor(duration, e.Token));
 
     /// <summary>
     /// Yield the thread for the specified duration or until cancelled.
@@ -211,7 +199,7 @@ public static IO<Unit> yieldFor(Duration duration) =>
     public static IO<Unit> yieldFor(TimeSpan timeSpan) =>
         Math.Abs(timeSpan.TotalMilliseconds) < 0.00000001
             ? unitIO
-            : IO<Unit>.LiftAsync(env => yieldFor(timeSpan, env.Token));
+            : IO<Unit>.LiftAsync(e => yieldFor(timeSpan, e.Token));
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //
diff --git a/LanguageExt.Core/Effects/IO/IO.Monad.cs b/LanguageExt.Core/Effects/IO/IO.Monad.cs
index 508f00582..1ef80f6c6 100644
--- a/LanguageExt.Core/Effects/IO/IO.Monad.cs
+++ b/LanguageExt.Core/Effects/IO/IO.Monad.cs
@@ -59,4 +59,394 @@ static K<IO, B> MonadIO<IO>.MapIO<A, B>(K<IO, A> ma, Func<IO<A>, IO<B>> f) =>
 
     static K<IO, A> Final<IO>.Finally<X, A>(K<IO, A> fa, K<IO, X> @finally) =>
         new IOFinal<X, A, A>(fa, @finally, pure);
+    
+    
+    
+    
+    /// <summary>
+    /// Creates a local cancellation environment
+    /// </summary>
+    /// <remarks>
+    /// A local cancellation environment stops other IO computations, that rely on the same
+    /// environmental cancellation token, from being taken down by a regional cancellation.
+    ///
+    /// If a `IO.cancel` is invoked locally then it will still create an exception that
+    /// propagates upwards and so catching cancellations is still important. 
+    /// </remarks>
+    /// <param name="ma">Computation to run within the local context</param>
+    /// <typeparam name="A">Bound value</typeparam>
+    /// <returns>Result of the computation</returns>
+    static K<IO, A> MonadIO<IO>.LocalIO<A>(K<IO, A> ma) =>
+        ma.As().Local();
+
+    /// <summary>
+    /// Make this IO computation run on the `SynchronizationContext` that was captured at the start
+    /// of the IO chain (i.e. the one embedded within the `EnvIO` environment that is passed through
+    /// all IO computations)
+    /// </summary>
+    static K<IO, A> MonadIO<IO>.PostIO<A>(K<IO, A> ma) =>
+        ma.As().Post();        
+
+    /// <summary>
+    /// Await a forked operation
+    /// </summary>
+    static K<IO, A> MonadIO<IO>.Await<A>(K<IO, ForkIO<A>> ma) =>
+        ma.As().Bind(f => f.Await);    
+
+    /// <summary>
+    /// Queue this IO operation to run on the thread-pool. 
+    /// </summary>
+    /// <param name="timeout">Maximum time that the forked IO operation can run for. `None` for no timeout.</param>
+    /// <returns>Returns a `ForkIO` data-structure that contains two IO effects that can be used to either cancel
+    /// the forked IO operation or to await the result of it.
+    /// </returns>
+    static K<IO, ForkIO<A>> MonadIO<IO>.ForkIO<A>(K<IO, A> ma, Option<TimeSpan> timeout) =>
+        ma.As().Fork(timeout);
+
+    /// <summary>
+    /// Timeout operation if it takes too long
+    /// </summary>
+    static K<IO, A> MonadIO<IO>.TimeoutIO<A>(K<IO, A> ma, TimeSpan timeout) =>
+        ma.As().Timeout(timeout);
+
+    /// <summary>
+    /// The IO monad tracks resources automatically, this creates a local resource environment
+    /// to run this computation in.  Once the computation has completed any resources acquired
+    /// are automatically released.  Imagine this as the ultimate `using` statement.
+    /// </summary>
+    static K<IO, A> MonadIO<IO>.BracketIO<A>(K<IO, A> ma) =>
+        ma.As().Bracket();
+
+    /// <summary>
+    /// When acquiring, using, and releasing various resources, it can be quite convenient to write a function to manage
+    /// the acquisition and releasing, taking a function of the acquired value that specifies an action to be performed
+    /// in between.
+    /// </summary>
+    /// <param name="Acq">Resource acquisition</param>
+    /// <param name="Use">Function to use the acquired resource</param>
+    /// <param name="Fin">Function to invoke to release the resource</param>
+    static K<IO, C> MonadIO<IO>.BracketIO<A, B, C>(
+        K<IO, A> Acq,
+        Func<A, IO<C>> Use,
+        Func<A, IO<B>> Fin) =>
+        Acq.As().Bracket(Use, Fin);
+
+    /// <summary>
+    /// When acquiring, using, and releasing various resources, it can be quite convenient to write a function to manage
+    /// the acquisition and releasing, taking a function of the acquired value that specifies an action to be performed
+    /// in between.
+    /// </summary>
+    /// <param name="Acq">Resource acquisition</param>
+    /// <param name="Use">Function to use the acquired resource</param>
+    /// <param name="Catch">Function to run to handle any exceptions</param>
+    /// <param name="Fin">Function to invoke to release the resource</param>
+    static K<IO, C> MonadIO<IO>.BracketIO<A, B, C>(
+        K<IO, A> Acq,
+        Func<A, IO<C>> Use,
+        Func<Error, IO<C>> Catch,
+        Func<A, IO<B>> Fin) =>
+        Acq.As().Bracket(Use, Catch, Fin);
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //
+    //  Repeating the effect
+    //
+
+    /// <summary>
+    /// Keeps repeating the computation forever, or until an error occurs
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <returns>The result of the last invocation</returns>
+    static K<IO, A> MonadIO<IO>.RepeatIO<A>(K<IO, A> ma) =>
+        ma.As().Repeat();
+
+    /// <summary>
+    /// Keeps repeating the computation, until the scheduler expires, or an error occurs  
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <param name="schedule">Scheduler strategy for repeating</param>
+    /// <returns>The result of the last invocation</returns>
+    static K<IO, A> MonadIO<IO>.RepeatIO<A>(
+        K<IO, A> ma,
+        Schedule schedule) =>
+        ma.As().Repeat(schedule);
+
+    /// <summary>
+    /// Keeps repeating the computation until the predicate returns false, or an error occurs 
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <param name="predicate">Keep repeating while this predicate returns `true` for each computed value</param>
+    /// <returns>The result of the last invocation</returns>
+    static K<IO, A> MonadIO<IO>.RepeatWhileIO<A>(
+        K<IO, A> ma,
+        Func<A, bool> predicate) =>
+        ma.As().RepeatWhile(predicate);
+
+    /// <summary>
+    /// Keeps repeating the computation, until the scheduler expires, or the predicate returns false, or an error occurs
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <param name="schedule">Scheduler strategy for repeating</param>
+    /// <param name="predicate">Keep repeating while this predicate returns `true` for each computed value</param>
+    /// <returns>The result of the last invocation</returns>
+    static K<IO, A> MonadIO<IO>.RepeatWhileIO<A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        Func<A, bool> predicate) =>
+        ma.As().RepeatWhile(schedule, predicate);
+
+    /// <summary>
+    /// Keeps repeating the computation until the predicate returns true, or an error occurs
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <param name="predicate">Keep repeating until this predicate returns `true` for each computed value</param>
+    /// <returns>The result of the last invocation</returns>
+    static K<IO, A> MonadIO<IO>.RepeatUntilIO<A>(
+        K<IO, A> ma,
+        Func<A, bool> predicate) =>
+        ma.As().RepeatUntil(predicate);
+
+    /// <summary>
+    /// Keeps repeating the computation, until the scheduler expires, or the predicate returns true, or an error occurs
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <param name="schedule">Scheduler strategy for repeating</param>
+    /// <param name="predicate">Keep repeating until this predicate returns `true` for each computed value</param>
+    /// <returns>The result of the last invocation</returns>
+    static K<IO, A> MonadIO<IO>.RepeatUntilIO<A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        Func<A, bool> predicate) =>
+        ma.As().RepeatUntil(schedule, predicate);
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //
+    //  Retrying the effect when it fails
+    //
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will retry forever
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    static K<IO, A> MonadIO<IO>.RetryIO<A>(K<IO, A> ma) =>
+        ma.As().Retry();
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will retry until the schedule expires
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    static K<IO, A> MonadIO<IO>.RetryIO<A>(
+        K<IO, A> ma,
+        Schedule schedule) =>
+        ma.As().Retry(schedule);
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will keep retrying whilst the predicate returns `true` for the error generated at each iteration;
+    /// at which point the last raised error will be thrown.
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    static K<IO, A> MonadIO<IO>.RetryWhileIO<A>(
+        K<IO, A> ma,
+        Func<Error, bool> predicate) =>
+        ma.As().RetryWhile(predicate);
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will keep retrying whilst the predicate returns `true` for the error generated at each iteration;
+    /// or, until the schedule expires; at which point the last raised error will be thrown.
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    static K<IO, A> MonadIO<IO>.RetryWhileIO<A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        Func<Error, bool> predicate) =>
+        ma.As().RetryWhile(schedule, predicate);
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will keep retrying until the predicate returns `true` for the error generated at each iteration;
+    /// at which point the last raised error will be thrown.
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    static K<IO, A> MonadIO<IO>.RetryUntilIO<A>(
+        K<IO, A> ma,
+        Func<Error, bool> predicate) =>
+        ma.As().RetryUntil(predicate);
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will keep retrying until the predicate returns `true` for the error generated at each iteration;
+    /// or, until the schedule expires; at which point the last raised error will be thrown.
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    static K<IO, A> MonadIO<IO>.RetryUntilIO<A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        Func<Error, bool> predicate) =>
+        ma.As().RetryUntil(schedule, predicate);
+    
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // 
+    //  Folding
+    //
+
+    static K<IO, S> MonadIO<IO>.FoldIO<S, A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder) =>
+        ma.As().Fold(schedule, initialState, folder);
+
+    static K<IO, S> MonadIO<IO>.FoldIO<S, A>(
+        K<IO, A> ma,
+        S initialState,
+        Func<S, A, S> folder) =>
+        ma.As().Fold(initialState, folder);
+
+    static K<IO, S> MonadIO<IO>.FoldWhileIO<S, A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<S, bool> stateIs) =>
+        ma.As().FoldWhile(schedule, initialState, folder, stateIs);
+
+    static K<IO, S> MonadIO<IO>.FoldWhileIO<S, A>(
+        K<IO, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<S, bool> stateIs) =>
+        ma.As().FoldWhile(initialState, folder, stateIs);
+
+    static K<IO, S> MonadIO<IO>.FoldWhileIO<S, A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<A, bool> valueIs) =>
+        ma.As().FoldWhile(schedule, initialState, folder, valueIs);
+
+    static K<IO, S> MonadIO<IO>.FoldWhileIO<S, A>(
+        K<IO, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<A, bool> valueIs) =>
+        ma.As().FoldWhile(initialState, folder, valueIs);
+    
+    static K<IO, S> MonadIO<IO>.FoldWhileIO<S, A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<(S State, A Value), bool> predicate) =>
+        ma.As().FoldWhile(schedule, initialState, folder, predicate);
+
+    static K<IO, S> MonadIO<IO>.FoldWhileIO<S, A>(
+        K<IO, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<(S State, A Value), bool> predicate) =>
+        ma.As().FoldWhile(initialState, folder, predicate);
+    
+    static K<IO, S> MonadIO<IO>.FoldUntilIO<S, A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<S, bool> stateIs) =>
+        ma.As().FoldUntil(schedule, initialState, folder, stateIs);
+    
+    static K<IO, S> MonadIO<IO>.FoldUntilIO<S, A>(
+        K<IO, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<S, bool> stateIs) =>
+        ma.As().FoldUntil(initialState, folder, stateIs);
+    
+    static K<IO, S> MonadIO<IO>.FoldUntilIO<S, A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<A, bool> valueIs) =>
+        ma.As().FoldUntil(schedule, initialState, folder, valueIs);
+    
+    static K<IO, S> MonadIO<IO>.FoldUntilIO<S, A>(
+        K<IO, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<A, bool> valueIs) =>
+        ma.As().FoldUntil(initialState, folder, valueIs);
+    
+    static K<IO, S> MonadIO<IO>.FoldUntilIO<S, A>(
+        K<IO, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<(S State, A Value), bool> predicate) =>
+        ma.As().FoldUntil(initialState, folder, predicate);
+
+    static K<IO, S> MonadIO<IO>.FoldUntilIO<S, A>(
+        K<IO, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<(S State, A Value), bool> predicate) =>
+        ma.As().FoldUntil(schedule, initialState, folder, predicate);       
 }
diff --git a/LanguageExt.Core/Effects/IO/IO.Prelude.cs b/LanguageExt.Core/Effects/IO/IO.Prelude.cs
index 19eb59bda..23028acf4 100644
--- a/LanguageExt.Core/Effects/IO/IO.Prelude.cs
+++ b/LanguageExt.Core/Effects/IO/IO.Prelude.cs
@@ -72,29 +72,7 @@ public static K<M, A> tailIO<M, A>(K<M, A> ma)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static K<M, A> postIO<M, A>(K<M, A> ma)
         where M : Monad<M> =>
-        ma.PostIO();        
-    
-    /// <summary>
-    /// Make this IO computation run on the `SynchronizationContext` that was captured at the start
-    /// of the IO chain (i.e. the one embedded within the `EnvIO` environment that is passed through
-    /// all IO computations)
-    /// </summary>
-    [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static K<IO, A> post<A>(K<IO, A> ma) =>
-        ma.As().PostIO();        
-
-    /// <summary>
-    /// Queue this IO operation to run on the thread-pool. 
-    /// </summary>
-    /// <param name="timeout">Maximum time that the forked IO operation can run for. `None` for no timeout.</param>
-    /// <returns>Returns a `ForkIO` data-structure that contains two IO effects that can be used to either cancel
-    /// the forked IO operation or to await the result of it.
-    /// </returns>
-    [Pure]
-    [MethodImpl(Opt.Default)]
-    public static IO<ForkIO<A>> fork<A>(K<IO, A> ma, Option<TimeSpan> timeout = default) =>
-        ma.ForkIO(timeout).As();
+        M.PostIO(ma);        
 
     /// <summary>
     /// Queue this IO operation to run on the thread-pool. 
@@ -107,7 +85,7 @@ public static IO<ForkIO<A>> fork<A>(K<IO, A> ma, Option<TimeSpan> timeout = defa
     [MethodImpl(Opt.Default)]
     public static K<M, ForkIO<A>> fork<M, A>(K<M, A> ma, Option<TimeSpan> timeout = default)
         where M : Monad<M> =>
-        ma.ForkIO(timeout);
+        M.ForkIO(ma, timeout);
 
     /// <summary>
     /// Queue this IO operation to run on the thread-pool. 
@@ -150,19 +128,7 @@ public static IO<ForkIO<Option<A>>> fork<A>(StreamT<IO, A> ma, Option<TimeSpan>
     [MethodImpl(Opt.Default)]
     public static K<M, A> awaitIO<M, A>(K<M, ForkIO<A>> ma)
         where M : Monad<M> =>
-        ma.Await();
-
-    /// <summary>
-    /// Queue this IO operation to run on the thread-pool. 
-    /// </summary>
-    /// <param name="timeout">Maximum time that the forked IO operation can run for. `None` for no timeout.</param>
-    /// <returns>Returns a `ForkIO` data-structure that contains two IO effects that can be used to either cancel
-    /// the forked IO operation or to await the result of it.
-    /// </returns>
-    [Pure]
-    [MethodImpl(Opt.Default)]
-    public static IO<A> awaitIO<A>(K<IO, ForkIO<A>> ma) =>
-        ma.Await().As();
+        M.Await(ma);
 
     /// <summary>
     /// Yield the thread for the specified duration or until cancelled.
@@ -193,22 +159,6 @@ public static K<M, Seq<A>> awaitAll<M, A>(params K<M, A>[] ms)
         where M : Monad<M> =>
         awaitAll(ms.ToSeqUnsafe());
     
-    /// <summary>
-    /// Awaits all operations
-    /// </summary>
-    /// <param name="ms">Operations to await</param>
-    /// <returns>Sequence of results</returns>
-    public static IO<Seq<A>> awaitAll<A>(params K<IO, A>[] ms) =>
-        awaitAll(ms.ToSeqUnsafe());
-    
-    /// <summary>
-    /// Awaits all operations
-    /// </summary>
-    /// <param name="ms">Operations to await</param>
-    /// <returns>Sequence of results</returns>
-    public static IO<Seq<A>> awaitAll<A>(params IO<A>[] ms) =>
-        awaitAll(ms.ToSeqUnsafe());
-    
     /// <summary>
     /// Awaits all forks
     /// </summary>
@@ -218,14 +168,6 @@ public static K<M, Seq<A>> awaitAll<M, A>(params K<M, ForkIO<A>>[] forks)
         where M : Monad<M> =>
         awaitAll(forks.ToSeqUnsafe());
 
-    /// <summary>
-    /// Awaits all 
-    /// </summary>
-    /// <param name="forks">IO operations to await</param>
-    /// <returns>Sequence of results</returns>
-    public static IO<Seq<A>> awaitAll<A>(params IO<ForkIO<A>>[] forks) =>
-        awaitAll(forks.ToSeqUnsafe());
-
     /// <summary>
     /// Awaits all 
     /// </summary>
@@ -243,14 +185,6 @@ public static K<M, Seq<A>> awaitAll<M, A>(Seq<K<M, A>> ms)
         where M : Monad<M> =>
         ms.Traverse(f => f.ToIO())
           .Bind(awaitAll);
-    
-    /// <summary>
-    /// Awaits all operations
-    /// </summary>
-    /// <param name="ms">Operations to await</param>
-    /// <returns>Sequence of results</returns>
-    public static IO<Seq<A>> awaitAll<A>(Seq<K<IO, A>> ms) =>
-        awaitAll(ms.Map(f => f.As()));
 
     /// <summary>
     /// Awaits all operations
diff --git a/LanguageExt.Core/Immutable Collections/Prelude.Collections.cs b/LanguageExt.Core/Immutable Collections/Prelude.Collections.cs
index 45bcd52d1..6b565e6bf 100644
--- a/LanguageExt.Core/Immutable Collections/Prelude.Collections.cs	
+++ b/LanguageExt.Core/Immutable Collections/Prelude.Collections.cs	
@@ -192,6 +192,22 @@ public static Arr<A> Sort<OrdA, A>(this Arr<A> xs) where OrdA : Ord<A> =>
     public static A[] Sort<OrdA, A>(this A[] xs) where OrdA : Ord<A> =>
         xs.OrderBy(identity, OrdComparer<OrdA, A>.Default).ToArray();
 
+    /// <summary>
+    /// Forever sequence of units
+    /// </summary>
+    [Pure]
+    public static Iterable<Unit> Units
+    {
+        get
+        {
+            return Go().AsIterable();
+            IEnumerable<Unit> Go()
+            {
+                while (true) yield return default;
+            }
+        }
+    }
+
     /// <summary>
     /// Lazy sequence of natural numbers up to Int32.MaxValue
     /// </summary>
diff --git a/LanguageExt.Core/Traits/Monads/MonadIO/MonadIO.Trait.cs b/LanguageExt.Core/Traits/Monads/MonadIO/MonadIO.Trait.cs
index adc90cbef..deab4a6af 100644
--- a/LanguageExt.Core/Traits/Monads/MonadIO/MonadIO.Trait.cs
+++ b/LanguageExt.Core/Traits/Monads/MonadIO/MonadIO.Trait.cs
@@ -53,7 +53,7 @@ public static virtual K<M, A> LiftIO<A>(IO<A> ma) =>
     /// Extract the IO monad from within the M monad (usually as part of a monad-transformer stack).
     /// </summary>
     public static virtual K<M, IO<A>> ToIO<A>(K<M, A> ma) =>
-        throw new ExceptionalException(Errors.UnliftIONotSupported);
+        throw new ExceptionalException(Errors.ToIONotSupported);
 
     /// <summary>
     /// Extract the IO monad from within the `M` monad (usually as part of a monad-transformer stack).  Then perform
@@ -61,4 +61,391 @@ public static virtual K<M, IO<A>> ToIO<A>(K<M, A> ma) =>
     /// </summary>
     public static virtual K<M, B> MapIO<A, B>(K<M, A> ma, Func<IO<A>, IO<B>> f) =>
         M.ToIO(ma).Bind(io => M.LiftIO(f(io)));
+    
+    /// <summary>
+    /// Creates a local cancellation environment
+    /// </summary>
+    /// <remarks>
+    /// A local cancellation environment stops other IO computations, that rely on the same
+    /// environmental cancellation token, from being taken down by a regional cancellation.
+    ///
+    /// If a `IO.cancel` is invoked locally then it will still create an exception that
+    /// propagates upwards and so catching cancellations is still important. 
+    /// </remarks>
+    /// <param name="ma">Computation to run within the local context</param>
+    /// <typeparam name="A">Bound value</typeparam>
+    /// <returns>Result of the computation</returns>
+    public static virtual K<M, A> LocalIO<A>(K<M, A> ma) =>
+        ma.MapIO(io => io.Local());
+
+    /// <summary>
+    /// Make this IO computation run on the `SynchronizationContext` that was captured at the start
+    /// of the IO chain (i.e. the one embedded within the `EnvIO` environment that is passed through
+    /// all IO computations)
+    /// </summary>
+    public static virtual K<M, A> PostIO<A>(K<M, A> ma) =>
+        ma.MapIO(io => io.Post());        
+
+    /// <summary>
+    /// Await a forked operation
+    /// </summary>
+    public static virtual K<M, A> Await<A>(K<M, ForkIO<A>> ma) =>
+        ma.MapIO(io => io.Bind(f => f.Await));    
+
+    /// <summary>
+    /// Queue this IO operation to run on the thread-pool. 
+    /// </summary>
+    /// <param name="timeout">Maximum time that the forked IO operation can run for. `None` for no timeout.</param>
+    /// <returns>Returns a `ForkIO` data-structure that contains two IO effects that can be used to either cancel
+    /// the forked IO operation or to await the result of it.
+    /// </returns>
+    public static virtual K<M, ForkIO<A>> ForkIO<A>(K<M, A> ma, Option<TimeSpan> timeout = default) =>
+        ma.MapIO(io => io.Fork(timeout));
+
+    /// <summary>
+    /// Timeout operation if it takes too long
+    /// </summary>
+    public static virtual K<M, A> TimeoutIO<A>(K<M, A> ma, TimeSpan timeout) =>
+        ma.MapIO(io => io.Timeout(timeout));
+
+    /// <summary>
+    /// The IO monad tracks resources automatically, this creates a local resource environment
+    /// to run this computation in.  Once the computation has completed any resources acquired
+    /// are automatically released.  Imagine this as the ultimate `using` statement.
+    /// </summary>
+    public static virtual K<M, A> BracketIO<A>(K<M, A> ma) =>
+        ma.MapIO(io => io.Bracket());
+
+    /// <summary>
+    /// When acquiring, using, and releasing various resources, it can be quite convenient to write a function to manage
+    /// the acquisition and releasing, taking a function of the acquired value that specifies an action to be performed
+    /// in between.
+    /// </summary>
+    /// <param name="Acq">Resource acquisition</param>
+    /// <param name="Use">Function to use the acquired resource</param>
+    /// <param name="Fin">Function to invoke to release the resource</param>
+    public static virtual K<M, C> BracketIO<A, B, C>(
+        K<M, A> Acq,
+        Func<A, IO<C>> Use,
+        Func<A, IO<B>> Fin) =>
+        Acq.MapIO(io => io.Bracket(Use, Fin));
+
+    /// <summary>
+    /// When acquiring, using, and releasing various resources, it can be quite convenient to write a function to manage
+    /// the acquisition and releasing, taking a function of the acquired value that specifies an action to be performed
+    /// in between.
+    /// </summary>
+    /// <param name="Acq">Resource acquisition</param>
+    /// <param name="Use">Function to use the acquired resource</param>
+    /// <param name="Catch">Function to run to handle any exceptions</param>
+    /// <param name="Fin">Function to invoke to release the resource</param>
+    public static virtual K<M, C> BracketIO<A, B, C>(
+        K<M, A> Acq,
+        Func<A, IO<C>> Use,
+        Func<Error, IO<C>> Catch,
+        Func<A, IO<B>> Fin) =>
+        Acq.MapIO(io => io.Bracket(Use, Catch, Fin));
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //
+    //  Repeating the effect
+    //
+
+    /// <summary>
+    /// Keeps repeating the computation forever, or until an error occurs
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <returns>The result of the last invocation</returns>
+    public static virtual K<M, A> RepeatIO<A>(K<M, A> ma) =>
+        ma.MapIO(io => io.Repeat());
+
+    /// <summary>
+    /// Keeps repeating the computation, until the scheduler expires, or an error occurs  
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <param name="schedule">Scheduler strategy for repeating</param>
+    /// <returns>The result of the last invocation</returns>
+    public static virtual K<M, A> RepeatIO<A>(
+        K<M, A> ma,
+        Schedule schedule) =>
+        ma.MapIO(io => io.Repeat(schedule));
+
+    /// <summary>
+    /// Keeps repeating the computation until the predicate returns false, or an error occurs 
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <param name="predicate">Keep repeating while this predicate returns `true` for each computed value</param>
+    /// <returns>The result of the last invocation</returns>
+    public static virtual K<M, A> RepeatWhileIO<A>(
+        K<M, A> ma,
+        Func<A, bool> predicate) =>
+        ma.MapIO(io => io.RepeatWhile(predicate));
+
+    /// <summary>
+    /// Keeps repeating the computation, until the scheduler expires, or the predicate returns false, or an error occurs
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <param name="schedule">Scheduler strategy for repeating</param>
+    /// <param name="predicate">Keep repeating while this predicate returns `true` for each computed value</param>
+    /// <returns>The result of the last invocation</returns>
+    public static virtual K<M, A> RepeatWhileIO<A>(
+        K<M, A> ma,
+        Schedule schedule,
+        Func<A, bool> predicate) =>
+        ma.MapIO(io => io.RepeatWhile(schedule, predicate));
+
+    /// <summary>
+    /// Keeps repeating the computation until the predicate returns true, or an error occurs
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <param name="predicate">Keep repeating until this predicate returns `true` for each computed value</param>
+    /// <returns>The result of the last invocation</returns>
+    public static virtual K<M, A> RepeatUntilIO<A>(
+        K<M, A> ma,
+        Func<A, bool> predicate) =>
+        ma.MapIO(io => io.RepeatUntil(predicate));
+
+    /// <summary>
+    /// Keeps repeating the computation, until the scheduler expires, or the predicate returns true, or an error occurs
+    /// </summary>
+    /// <remarks>
+    /// Any resources acquired within a repeated IO computation will automatically be released.  This also means you can't
+    /// acquire resources and return them from within a repeated computation.
+    /// </remarks>
+    /// <param name="schedule">Scheduler strategy for repeating</param>
+    /// <param name="predicate">Keep repeating until this predicate returns `true` for each computed value</param>
+    /// <returns>The result of the last invocation</returns>
+    public static virtual K<M, A> RepeatUntilIO<A>(
+        K<M, A> ma,
+        Schedule schedule,
+        Func<A, bool> predicate) =>
+        ma.MapIO(io => io.RepeatUntil(schedule, predicate));
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //
+    //  Retrying the effect when it fails
+    //
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will retry forever
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    public static virtual K<M, A> RetryIO<A>(K<M, A> ma) =>
+        ma.MapIO(io => io.Retry());
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will retry until the schedule expires
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    public static virtual K<M, A> RetryIO<A>(
+        K<M, A> ma,
+        Schedule schedule) =>
+        ma.MapIO(io => io.Retry(schedule));
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will keep retrying whilst the predicate returns `true` for the error generated at each iteration;
+    /// at which point the last raised error will be thrown.
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    public static virtual K<M, A> RetryWhileIO<A>(
+        K<M, A> ma,
+        Func<Error, bool> predicate) =>
+        ma.MapIO(io => io.RetryWhile(predicate));
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will keep retrying whilst the predicate returns `true` for the error generated at each iteration;
+    /// or, until the schedule expires; at which point the last raised error will be thrown.
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    public static virtual K<M, A> RetryWhileIO<A>(
+        K<M, A> ma,
+        Schedule schedule,
+        Func<Error, bool> predicate) =>
+        ma.MapIO(io => io.RetryWhile(schedule, predicate));
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will keep retrying until the predicate returns `true` for the error generated at each iteration;
+    /// at which point the last raised error will be thrown.
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    public static virtual K<M, A> RetryUntilIO<A>(
+        K<M, A> ma,
+        Func<Error, bool> predicate) =>
+        ma.MapIO(io => io.RetryUntil(predicate));
+
+    /// <summary>
+    /// Retry if the IO computation fails 
+    /// </summary>
+    /// <remarks>
+    /// This variant will keep retrying until the predicate returns `true` for the error generated at each iteration;
+    /// or, until the schedule expires; at which point the last raised error will be thrown.
+    /// </remarks>
+    /// <remarks>
+    /// Any resources acquired within a retrying IO computation will automatically be released *if* the operation fails.
+    /// So, successive retries will not grow the acquired resources on each retry iteration.  Any successful operation that
+    /// acquires resources will have them tracked in the usual way. 
+    /// </remarks>
+    public static virtual K<M, A> RetryUntilIO<A>(
+        K<M, A> ma,
+        Schedule schedule,
+        Func<Error, bool> predicate) =>
+        ma.MapIO(io => io.RetryUntil(schedule, predicate));
+    
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // 
+    //  Folding
+    //
+
+    public static virtual K<M, S> FoldIO<S, A>(
+        K<M, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder) =>
+        ma.MapIO(io => io.Fold(schedule, initialState, folder));
+
+    public static virtual K<M, S> FoldIO<S, A>(
+        K<M, A> ma,
+        S initialState,
+        Func<S, A, S> folder) =>
+        ma.MapIO(io => io.Fold(initialState, folder));
+
+    public static virtual K<M, S> FoldWhileIO<S, A>(
+        K<M, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<S, bool> stateIs) =>
+        ma.MapIO(io => io.FoldWhile(schedule, initialState, folder, stateIs));
+
+    public static virtual K<M, S> FoldWhileIO<S, A>(
+        K<M, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<S, bool> stateIs) =>
+        ma.MapIO(io => io.FoldWhile(initialState, folder, stateIs));
+
+    public static virtual K<M, S> FoldWhileIO<S, A>(
+        K<M, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<A, bool> valueIs) =>
+        ma.MapIO(io => io.FoldWhile(schedule, initialState, folder, valueIs));
+
+    public static virtual K<M, S> FoldWhileIO<S, A>(
+        K<M, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<A, bool> valueIs) =>
+        ma.MapIO(io => io.FoldWhile(initialState, folder, valueIs));
+    
+    public static virtual K<M, S> FoldWhileIO<S, A>(
+        K<M, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<(S State, A Value), bool> predicate) =>
+        ma.MapIO(io => io.FoldWhile(schedule, initialState, folder, predicate));
+
+    public static virtual K<M, S> FoldWhileIO<S, A>(
+        K<M, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<(S State, A Value), bool> predicate) =>
+        ma.MapIO(io => io.FoldWhile(initialState, folder, predicate));
+    
+    public static virtual K<M, S> FoldUntilIO<S, A>(
+        K<M, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<S, bool> stateIs) =>
+        ma.MapIO(io => io.FoldUntil(schedule, initialState, folder, stateIs));
+    
+    public static virtual K<M, S> FoldUntilIO<S, A>(
+        K<M, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<S, bool> stateIs) =>
+        ma.MapIO(io => io.FoldUntil(initialState, folder, stateIs));
+    
+    public static virtual K<M, S> FoldUntilIO<S, A>(
+        K<M, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<A, bool> valueIs) =>
+        ma.MapIO(io => io.FoldUntil(schedule, initialState, folder, valueIs));
+    
+    public static virtual K<M, S> FoldUntilIO<S, A>(
+        K<M, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<A, bool> valueIs) =>
+        ma.MapIO(io => io.FoldUntil(initialState, folder, valueIs));
+    
+    public static virtual K<M, S> FoldUntilIO<S, A>(
+        K<M, A> ma,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<(S State, A Value), bool> predicate) =>
+        ma.MapIO(io => io.FoldUntil(initialState, folder, predicate));
+
+    public static virtual K<M, S> FoldUntilIO<S, A>(
+        K<M, A> ma,
+        Schedule schedule,
+        S initialState,
+        Func<S, A, S> folder,
+        Func<(S State, A Value), bool> predicate) =>
+        ma.MapIO(io => io.FoldUntil(schedule, initialState, folder, predicate));    
 }
diff --git a/LanguageExt.Pipes/Concurrent/Inbox/Inbox.DSL.cs b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.DSL.cs
index 632b3e531..2748c40d0 100644
--- a/LanguageExt.Pipes/Concurrent/Inbox/Inbox.DSL.cs
+++ b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.DSL.cs
@@ -5,14 +5,26 @@
 
 namespace LanguageExt.Pipes.Concurrent;
 
-record InboxWriter<A>(ChannelWriter<A> Writer) : Inbox<A>
+record InboxWriter<A>(ChannelWriter<A> Writer, string Label) : Inbox<A>
 {
     public override Inbox<B> ContraMap<B>(Func<B, A> f) => 
         new InboxContraMap<A, B>(f, this);
 
     public override IO<Unit> Post(A value) =>
-        from f in IO.liftVAsync(e => Writer.WaitToWriteAsync(e.Token))
-        from r in f ? IO.liftVAsync(() => Writer.WriteAsync(value).ToUnit()) 
+        from f in IO.liftVAsync(async e =>
+                                {
+                                    Console.WriteLine($"Post({value}) to {Label} - Pre: WaitToWriteAsync");
+                                    var r = await Writer.WaitToWriteAsync(e.Token);
+                                    Console.WriteLine($"Post({value}) '{r}' to {Label} - Post: WaitToWriteAsync");
+                                    return r;
+                                })
+        from r in f ? IO.liftVAsync(async () =>
+                                    {
+                                        Console.WriteLine($"Post({value}) to {Label} - Pre: WriteAsync");
+                                        var r = await Writer.WriteAsync(value).ToUnit();
+                                        Console.WriteLine($"Post({value}) to {Label} - Post: WriteAsync");
+                                        return r;
+                                    }) 
                     : IO.fail<Unit>(Errors.NoSpaceInInbox)
         select r;
 
@@ -90,7 +102,7 @@ public override IO<Unit> Post(A value) =>
                                {
                                    [] => unitIO,
                                    _  => IO.fail<Unit>(Error.Many(es))
-                               })
+                               }).As()
         };
 
     public override IO<Unit> Complete() =>
diff --git a/LanguageExt.Pipes/Concurrent/Inbox/Inbox.cs b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.cs
index de61d7316..19e22d68e 100644
--- a/LanguageExt.Pipes/Concurrent/Inbox/Inbox.cs
+++ b/LanguageExt.Pipes/Concurrent/Inbox/Inbox.cs
@@ -83,9 +83,7 @@ public Inbox<X> Combine<X, B>(Func<X, (A Left, B Right)> f, Inbox<B> rhs) =>
     /// <returns>`ConsumerT`</returns>
     public ConsumerT<A, M, Unit> ToConsumerT<M>()
         where M : Monad<M> =>
-        ConsumerT.awaiting<M, A>()
-                 .Bind(Post)
-                 .Bind(_ => ToConsumerT<M>());
+        ConsumerT.repeat(ConsumerT.awaiting<M, A>().Bind(Post));
 
     /// <summary>
     /// Convert the `Inbox` to a `Consumer` pipe component
diff --git a/LanguageExt.Pipes/Concurrent/Mailbox/Mailbox.Module.cs b/LanguageExt.Pipes/Concurrent/Mailbox/Mailbox.Module.cs
index 9d88b2928..937245e4c 100644
--- a/LanguageExt.Pipes/Concurrent/Mailbox/Mailbox.Module.cs
+++ b/LanguageExt.Pipes/Concurrent/Mailbox/Mailbox.Module.cs
@@ -7,19 +7,21 @@ public static class Mailbox
     /// <summary>
     /// Create a new unbounded mailbox 
     /// </summary>
+    /// <param name="label">Label for debugging purposes</param>
     /// <typeparam name="A">Value type</typeparam>
     /// <returns>Constructed mailbox with an `Inbox` and an `Outbox`</returns>
-    public static Mailbox<A, A> spawn<A>() =>
-        spawn(Buffer<A>.Unbounded);
+    public static Mailbox<A, A> spawn<A>(string label = "[unlabeled]") =>
+        spawn(Buffer<A>.Unbounded, label);
 
     /// <summary>
     /// Create a new mailbox with the buffer settings provided 
     /// </summary>
     /// <param name="buffer">Buffer settings</param>
+    /// <param name="label">Label for debugging purposes</param>
     /// <typeparam name="A">Value type</typeparam>
     /// <returns>Constructed mailbox with an `Inbox` and an `Outbox`</returns>
     /// <exception cref="NotSupportedException">Thrown for invalid buffer settings</exception>
-    public static Mailbox<A, A> spawn<A>(Buffer<A> buffer)
+    public static Mailbox<A, A> spawn<A>(Buffer<A> buffer, string label = "[unlabeled]")
     {
         Ch.Channel<A> channel;
         switch (buffer)
@@ -68,6 +70,6 @@ public static Mailbox<A, A> spawn<A>(Buffer<A> buffer)
                 throw new NotSupportedException();
         }
 
-        return new Mailbox<A, A>(new InboxWriter<A>(channel.Writer), new OutboxReader<A>(channel.Reader));
+        return new Mailbox<A, A>(new InboxWriter<A>(channel.Writer, label), new OutboxReader<A>(channel.Reader, label));
     }
 }
diff --git a/LanguageExt.Pipes/Concurrent/Outbox/Outbox.DSL.cs b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.DSL.cs
index a0a2801e2..47cb45ace 100644
--- a/LanguageExt.Pipes/Concurrent/Outbox/Outbox.DSL.cs
+++ b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.DSL.cs
@@ -44,7 +44,7 @@ internal override ValueTask<bool> ReadyToRead(CancellationToken token) =>
         new(false);
 }
 
-record OutboxReader<A>(ChannelReader<A> Reader) : Outbox<A>
+record OutboxReader<A>(ChannelReader<A> Reader, string Label) : Outbox<A>
 {
     public override Outbox<B> Map<B>(Func<A, B> f) => 
         new OutboxMap<A, B>(this, f);
@@ -56,8 +56,20 @@ public override Outbox<B> ApplyBack<B>(Outbox<Func<A, B>> ff) =>
         new OutboxApply<A, B>(this, ff);
 
     public override IO<A> Read() =>
-        IO.liftVAsync(e => Reader.WaitToReadAsync(e.Token))
-          .Bind(f => f ? IO.liftVAsync(e => Reader.ReadAsync(e.Token))
+        IO.liftVAsync(async e =>
+                      {
+                          Console.WriteLine($"Read from {Label} - Pre: WaitToReadAsync");
+                          var r = await Reader.WaitToReadAsync(e.Token);
+                          Console.WriteLine($"Read '{r}' from {Label} - Post: WaitToReadAsync");
+                          return r;
+                      })
+          .Bind(f => f ? IO.liftVAsync(async e =>
+                                       {
+                                           Console.WriteLine($"Read from {Label} - Pre: ReadAsync");
+                                           var r = await Reader.ReadAsync(e.Token);
+                                           Console.WriteLine($"Read '{r}' from {Label} - Post: ReadAsync");
+                                           return r;
+                                       })
                        : IO.fail<A>(Errors.OutboxChannelClosed));
     
     internal override ValueTask<bool> ReadyToRead(CancellationToken token) =>
diff --git a/LanguageExt.Pipes/Concurrent/Outbox/Outbox.cs b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.cs
index d43d72f6b..ebfd574e4 100644
--- a/LanguageExt.Pipes/Concurrent/Outbox/Outbox.cs
+++ b/LanguageExt.Pipes/Concurrent/Outbox/Outbox.cs
@@ -80,8 +80,7 @@ public Outbox<B> Bind<B>(Func<A, K<Outbox, B>> f) =>
     /// <returns>`ProducerT`</returns>
     public ProducerT<A, M, Unit> ToProducerT<M>()
         where M : Monad<M> =>
-        Read().Bind(ProducerT.yield<M, A>)
-              .Bind(_ => ToProducerT<M>());
+        PipeT.yieldRepeatIO<M, Unit, A>(Read());
 
     /// <summary>
     /// Convert `Outbox` to a `Producer` pipe component
diff --git a/LanguageExt.Pipes/Consumer/Consumer.Module.cs b/LanguageExt.Pipes/Consumer/Consumer.Module.cs
index 4d770323f..289d93ca3 100644
--- a/LanguageExt.Pipes/Consumer/Consumer.Module.cs
+++ b/LanguageExt.Pipes/Consumer/Consumer.Module.cs
@@ -13,8 +13,8 @@ public static class Consumer
     /// <summary>
     /// Await a value from upstream
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, IN> awaiting<RT, IN>() =>
         PipeT.awaiting<Eff<RT>, IN, Void>().ToConsumer();
@@ -22,8 +22,8 @@ public static Consumer<RT, IN, IN> awaiting<RT, IN>() =>
     /// <summary>
     /// Await a value from upstream and then ignore it
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, Unit> awaitIgnore<RT, IN>() =>
         new PipeTAwait<IN, Void, Eff<RT>, Unit>(_ => PipeT.pure<IN, Void, Eff<RT>, Unit>(default)).ToConsumer();
@@ -31,8 +31,8 @@ public static Consumer<RT, IN, Unit> awaitIgnore<RT, IN>() =>
     /// <summary>
     /// Create a consumer that simply returns a bound value without awaiting anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to await</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> pure<RT, IN, A>(A value) =>
@@ -41,8 +41,8 @@ public static Consumer<RT, IN, A> pure<RT, IN, A>(A value) =>
     /// <summary>
     /// Create a consumer that always fails
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to await</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> error<RT, IN, A>(Error value) =>
@@ -51,8 +51,8 @@ public static Consumer<RT, IN, A> error<RT, IN, A>(Error value) =>
     /// <summary>
     /// Create a consumer that yields nothing at all
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> empty<RT, IN, A>() =>
@@ -61,8 +61,8 @@ public static Consumer<RT, IN, A> empty<RT, IN, A>() =>
     /// <summary>
     /// Create a consumer that simply returns a bound value without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> lift<RT, IN, A>(Func<A> f) =>
@@ -71,8 +71,8 @@ public static Consumer<RT, IN, A> lift<RT, IN, A>(Func<A> f) =>
     /// <summary>
     /// Create a lazy consumer 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> liftT<RT, IN, A>(Func<Consumer<RT, IN, A>> f) =>
@@ -81,8 +81,8 @@ public static Consumer<RT, IN, A> liftT<RT, IN, A>(Func<Consumer<RT, IN, A>> f)
     /// <summary>
     /// Create an asynchronous lazy consumer 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> liftT<RT, IN, A>(Func<ValueTask<Consumer<RT, IN, A>>> f) =>
@@ -91,8 +91,8 @@ public static Consumer<RT, IN, A> liftT<RT, IN, A>(Func<ValueTask<Consumer<RT, I
     /// <summary>
     /// Create an asynchronous consumer 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> liftT<RT, IN, A>(ValueTask<Consumer<RT, IN, A>> f) =>
@@ -101,8 +101,8 @@ public static Consumer<RT, IN, A> liftT<RT, IN, A>(ValueTask<Consumer<RT, IN, A>
     /// <summary>
     /// Create a consumer that simply returns the bound value of the lifted monad without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> liftM<RT, IN, A>(K<Eff<RT>, A> ma) =>
@@ -111,8 +111,8 @@ public static Consumer<RT, IN, A> liftM<RT, IN, A>(K<Eff<RT>, A> ma) =>
     /// <summary>
     /// Create a consumer that simply returns the bound value of the lifted monad without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> liftIO<RT, IN, A>(IO<A> ma) =>
@@ -121,8 +121,8 @@ public static Consumer<RT, IN, A> liftIO<RT, IN, A>(IO<A> ma) =>
     /// <summary>
     /// Continually repeat the provided operation
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> repeat<RT, IN, A>(Consumer<RT, IN, A> ma) =>
@@ -131,8 +131,8 @@ public static Consumer<RT, IN, A> repeat<RT, IN, A>(Consumer<RT, IN, A> ma) =>
     /// <summary>
     /// Repeat the provided operation based on the schedule provided
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> repeat<RT, IN, A>(Schedule schedule, Consumer<RT, IN, A> ma) =>
@@ -141,8 +141,8 @@ public static Consumer<RT, IN, A> repeat<RT, IN, A>(Schedule schedule, Consumer<
     /// <summary>
     /// Continually lift & repeat the provided operation
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> repeatM<RT, IN, A>(K<Eff<RT>, A> ma) =>
@@ -151,8 +151,8 @@ public static Consumer<RT, IN, A> repeatM<RT, IN, A>(K<Eff<RT>, A> ma) =>
     /// <summary>
     /// Repeat the provided operation based on the schedule provided
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Consumer<RT, IN, A> repeatM<RT, IN, A>(Schedule schedule, K<Eff<RT>, A> ma) =>
diff --git a/LanguageExt.Pipes/Effect/Effect.Module.cs b/LanguageExt.Pipes/Effect/Effect.Module.cs
index 423237c92..22ae47ded 100644
--- a/LanguageExt.Pipes/Effect/Effect.Module.cs
+++ b/LanguageExt.Pipes/Effect/Effect.Module.cs
@@ -13,6 +13,7 @@ public static class Effect
     /// <summary>
     /// Create an effect that simply returns a bound value without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> pure<RT, A>(A value) =>
@@ -21,6 +22,7 @@ public static Effect<RT, A> pure<RT, A>(A value) =>
     /// <summary>
     /// Create an effect that always fails
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> error<RT, A>(Error value) =>
@@ -29,6 +31,7 @@ public static Effect<RT, A> error<RT, A>(Error value) =>
     /// <summary>
     /// Create an effect that yields nothing at all
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> empty<RT, A>() =>
@@ -37,6 +40,7 @@ public static Effect<RT, A> empty<RT, A>() =>
     /// <summary>
     /// Create an effect that lazily returns a bound value without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> lift<RT, A>(Func<A> f) =>
@@ -45,6 +49,7 @@ public static Effect<RT, A> lift<RT, A>(Func<A> f) =>
     /// <summary>
     /// Create an effect that simply returns the bound value of the lifted monad without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> liftM<RT, A>(K<Eff<RT>, A> ma) =>
@@ -53,6 +58,7 @@ public static Effect<RT, A> liftM<RT, A>(K<Eff<RT>, A> ma) =>
     /// <summary>
     /// Create an effect that simply returns the bound value of the lifted monad without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> liftIO<RT, A>(IO<A> ma) =>
@@ -61,6 +67,7 @@ public static Effect<RT, A> liftIO<RT, A>(IO<A> ma) =>
     /// <summary>
     /// Create a lazy proxy 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> liftT<RT, A>(Func<Effect<RT, A>> f) =>
@@ -69,6 +76,7 @@ public static Effect<RT, A> liftT<RT, A>(Func<Effect<RT, A>> f) =>
     /// <summary>
     /// Create an asynchronous lazy proxy 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> liftT<RT, A>(Func<ValueTask<Effect<RT, A>>> f) =>
@@ -77,6 +85,7 @@ public static Effect<RT, A> liftT<RT, A>(Func<ValueTask<Effect<RT, A>>> f) =>
     /// <summary>
     /// Create an asynchronous proxy 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> liftT<RT, A>(ValueTask<Effect<RT, A>> f) =>
@@ -85,6 +94,7 @@ public static Effect<RT, A> liftT<RT, A>(ValueTask<Effect<RT, A>> f) =>
     /// <summary>
     /// Continually repeat the provided operation
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> repeat<RT, A>(Effect<RT, A> ma) =>
@@ -93,6 +103,7 @@ public static Effect<RT, A> repeat<RT, A>(Effect<RT, A> ma) =>
     /// <summary>
     /// Repeat the provided operation based on the schedule provided
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> repeat<RT, A>(Schedule schedule, Effect<RT, A> ma) =>
@@ -101,6 +112,7 @@ public static Effect<RT, A> repeat<RT, A>(Schedule schedule, Effect<RT, A> ma) =
     /// <summary>
     /// Continually lift & repeat the provided operation
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> repeatM<RT, A>(K<Eff<RT>, A> ma) =>
@@ -109,6 +121,7 @@ public static Effect<RT, A> repeatM<RT, A>(K<Eff<RT>, A> ma) =>
     /// <summary>
     /// Repeat the provided operation based on the schedule provided
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Effect<RT, A> repeatM<RT, A>(Schedule schedule, K<Eff<RT>, A> ma) =>
diff --git a/LanguageExt.Pipes/Effect/Effect.Monad.cs b/LanguageExt.Pipes/Effect/Effect.Monad.cs
index dd7c25087..7e5a034fb 100644
--- a/LanguageExt.Pipes/Effect/Effect.Monad.cs
+++ b/LanguageExt.Pipes/Effect/Effect.Monad.cs
@@ -48,4 +48,9 @@ static K<Effect<RT>, A> Applicative<Effect<RT>>.Actions<A>(
         fas.Select(fa => fa.As().Proxy)
            .Actions()
            .ToEffect();
+
+    static K<Effect<RT>, ForkIO<A>> MonadIO<Effect<RT>>.ForkIO<A>(
+        K<Effect<RT>, A> ma,
+        Option<TimeSpan> timeout) =>
+        Effect.liftM(ma.As().Run().ForkIO(timeout));
 }
diff --git a/LanguageExt.Pipes/EffectT/EffectT.Extensions.cs b/LanguageExt.Pipes/EffectT/EffectT.Extensions.cs
index 10a1b5dc3..db9f3a7ba 100644
--- a/LanguageExt.Pipes/EffectT/EffectT.Extensions.cs
+++ b/LanguageExt.Pipes/EffectT/EffectT.Extensions.cs
@@ -25,6 +25,12 @@ public static EffectT<M, A> As<M, A>(this K<EffectT<M>, A> ma)
     public static Effect<RT, A> ToEff<RT, A>(this K<EffectT<Eff<RT>>, A> ma) =>
         ma.As();
 
+    /// <summary>
+    /// Convert to the `Eff` version of `Effect`
+    /// </summary>
+    public static EffectT<Eff<RT>, A> FromEff<RT, A>(this K<Effect<RT>, A> ma) =>
+        new(ma.As().Proxy);
+
     /// <summary>
     /// Monad bind
     /// </summary>
diff --git a/LanguageExt.Pipes/EffectT/EffectT.Monad.cs b/LanguageExt.Pipes/EffectT/EffectT.Monad.cs
index 3e07491f0..a3f070db6 100644
--- a/LanguageExt.Pipes/EffectT/EffectT.Monad.cs
+++ b/LanguageExt.Pipes/EffectT/EffectT.Monad.cs
@@ -49,4 +49,9 @@ static K<EffectT<M>, A> Applicative<EffectT<M>>.Actions<A>(
         fas.Select(fa => fa.As().Proxy)
            .Actions()
            .ToEffect();
+    
+    static K<EffectT<M>, ForkIO<A>> MonadIO<EffectT<M>>.ForkIO<A>(
+        K<EffectT<M>, A> ma,
+        Option<TimeSpan> timeout) =>
+        MonadT.lift<EffectT<M>, M, ForkIO<A>>(ma.As().Run().ForkIO(timeout));    
 }
diff --git a/LanguageExt.Pipes/Pipe/Pipe.Module.cs b/LanguageExt.Pipes/Pipe/Pipe.Module.cs
index ad94ca4f2..443231dbc 100644
--- a/LanguageExt.Pipes/Pipe/Pipe.Module.cs
+++ b/LanguageExt.Pipes/Pipe/Pipe.Module.cs
@@ -14,6 +14,7 @@ public static class Pipe
     /// <summary>
     /// Yield a value downstream
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns></returns>
@@ -23,6 +24,7 @@ public static Pipe<RT, IN, OUT, Unit> yield<RT, IN, OUT>(OUT value) =>
     /// <summary>
     /// Yield all values downstream
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns></returns>
@@ -32,15 +34,37 @@ public static Pipe<RT, IN, OUT, Unit> yieldAll<RT, IN, OUT>(IEnumerable<OUT> val
     /// <summary>
     /// Yield all values downstream
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns></returns>
     public static Pipe<RT, IN, OUT, Unit> yieldAll<RT, IN, OUT>(IAsyncEnumerable<OUT> values) =>
         PipeT.yieldAll<Eff<RT>, IN, OUT>(values);
     
+    /// <summary>
+    /// Evaluate the `M` monad repeatedly, yielding its bound values downstream
+    /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
+    /// <typeparam name="IN">Stream value to consume</typeparam>
+    /// <typeparam name="OUT">Stream value to produce</typeparam>
+    /// <returns></returns>
+    public static Pipe<RT, IN, OUT, Unit> yieldRepeat<RT, IN, OUT>(K<Eff<RT>, OUT> ma) =>
+        PipeT.yieldRepeat<Eff<RT>, IN, OUT>(ma);
+
+    /// <summary>
+    /// Evaluate the `IO` monad repeatedly, yielding its bound values downstream
+    /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
+    /// <typeparam name="IN">Stream value to consume</typeparam>
+    /// <typeparam name="OUT">Stream value to produce</typeparam>
+    /// <returns></returns>
+    public static Pipe<RT, IN, OUT, Unit> yieldRepeatIO<RT, IN, OUT>(IO<OUT> ma) =>
+        PipeT.yieldRepeatIO<Eff<RT>, IN, OUT>(ma);
+    
     /// <summary>
     /// Await a value from upstream
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns>Pipe</returns>
@@ -51,6 +75,7 @@ public static Pipe<RT, IN, OUT, IN> awaiting<RT, IN, OUT>() =>
     /// Create a pipe that filters out values that return `false` when applied to a predicate function
     /// </summary>
     /// <param name="f">Predicate function</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="A">Stream value to consume and produce</typeparam>
     /// <returns>Pipe</returns>
     public static Pipe<RT, A, A, Unit> filter<RT, A>(Func<A, bool> f) =>
@@ -60,6 +85,7 @@ public static Pipe<RT, A, A, Unit> filter<RT, A>(Func<A, bool> f) =>
     /// Create a pipe from a mapping function
     /// </summary>
     /// <param name="f">Mapping function</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns>Pipe</returns>
@@ -70,6 +96,7 @@ public static Pipe<RT, IN, OUT, Unit> map<RT, IN, OUT>(Func<IN, OUT> f) =>
     /// Create a pipe from a mapping function
     /// </summary>
     /// <param name="f">Mapping function</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns>Pipe</returns>
@@ -79,6 +106,7 @@ public static Pipe<RT, IN, OUT, Unit> mapM<RT, IN, OUT>(Func<IN, K<Eff<RT>, OUT>
     /// <summary>
     /// Create a pipe that simply returns a bound value without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -89,6 +117,7 @@ public static Pipe<RT, IN, OUT, A> pure<RT, IN, OUT, A>(A value) =>
     /// <summary>
     /// Create a pipe that always fails
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -99,6 +128,7 @@ public static Pipe<RT, IN, OUT, A> error<RT, IN, OUT, A>(Error value) =>
     /// <summary>
     /// Create a pipe that yields nothing at all
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -109,6 +139,7 @@ public static Pipe<RT, IN, OUT, A> empty<RT, IN, OUT, A>() =>
     /// <summary>
     /// Create a pipe that simply returns a bound value without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -119,6 +150,7 @@ public static Pipe<RT, IN, OUT, A> lift<RT, IN, OUT, A>(Func<A> f) =>
     /// <summary>
     /// Create a lazy pipe 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -129,6 +161,7 @@ public static Pipe<RT, IN, OUT, A> liftT<RT, IN, OUT, A>(Func<Pipe<RT, IN, OUT,
     /// <summary>
     /// Create an asynchronous lazy pipe 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -139,6 +172,7 @@ public static Pipe<RT, IN, OUT, A> liftT<RT, IN, OUT, A>(Func<ValueTask<Pipe<RT,
     /// <summary>
     /// Create an asynchronous pipe 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -149,6 +183,7 @@ public static Pipe<RT, IN, OUT, A> liftT<RT, IN, OUT, A>(ValueTask<Pipe<RT, IN,
     /// <summary>
     /// Create a pipe that simply returns the bound value of the lifted monad without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -159,6 +194,7 @@ public static Pipe<RT, IN, OUT, A> liftM<RT, IN, OUT, A>(K<Eff<RT>, A> ma) =>
     /// <summary>
     /// Create a pipe that simply returns the bound value of the lifted monad without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -169,6 +205,7 @@ public static Pipe<RT, IN, OUT, A> liftM<RT, IN, OUT, A>(ValueTask<K<Eff<RT>, A>
     /// <summary>
     /// Create a pipe that simply returns the bound value of the lifted monad without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -179,6 +216,7 @@ public static Pipe<RT, IN, OUT, A> liftIO<RT, IN, OUT, A>(IO<A> ma) =>
     /// <summary>
     /// Continually repeat the provided operation
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -189,6 +227,7 @@ public static Pipe<RT, IN, OUT, A> repeat<RT, IN, OUT, A>(Pipe<RT, IN, OUT, A> m
     /// <summary>
     /// Repeat the provided operation based on the schedule provided
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -199,6 +238,7 @@ public static Pipe<RT, IN, OUT, A> repeat<RT, IN, OUT, A>(Schedule schedule, Pip
     /// <summary>
     /// Continually lift & repeat the provided operation
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -209,6 +249,7 @@ public static Pipe<RT, IN, OUT, A> repeatM<RT, IN, OUT, A>(K<Eff<RT>, A> ma) =>
     /// <summary>
     /// Repeat the provided operation based on the schedule provided
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -224,6 +265,7 @@ public static Pipe<RT, IN, OUT, A> repeatM<RT, IN, OUT, A>(Schedule schedule, K<
     /// <param name="Fold">Fold function</param>
     /// <param name="Init">Initial state</param>
     /// <param name="Item">Pipe to fold</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -243,6 +285,7 @@ public static Pipe<RT, IN, OUT, Unit> fold<RT, IN, OUT, A>(
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
     /// <param name="Item">Pipe to fold</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -263,6 +306,7 @@ public static Pipe<RT, IN, OUT, Unit> foldUntil<RT, IN, OUT, A>(
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
     /// <param name="Item">Pipe to fold</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -283,6 +327,7 @@ public static Pipe<RT, IN, OUT, Unit> foldUntil<RT, IN, OUT, A>(
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
     /// <param name="Item">Pipe to fold</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -303,6 +348,7 @@ public static Pipe<RT, IN, OUT, Unit> foldWhile<RT, IN, OUT, A>(
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
     /// <param name="Item">Pipe to fold</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
@@ -322,6 +368,7 @@ public static Pipe<RT, IN, OUT, Unit> foldWhile<RT, IN, OUT, A>(
     /// <param name="Time">Schedule to run each item</param>
     /// <param name="Fold">Fold function</param>
     /// <param name="Init">Initial state</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns></returns>
@@ -338,6 +385,7 @@ public static Pipe<RT, IN, OUT, Unit> fold<RT, IN, OUT>(
     /// <param name="Fold">Fold function</param>
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns></returns>
@@ -355,6 +403,7 @@ public static Pipe<RT, IN, OUT, Unit> foldUntil<RT, IN, OUT>(
     /// <param name="Fold">Fold function</param>
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns></returns>
@@ -372,6 +421,7 @@ public static Pipe<RT, IN, OUT, Unit> foldUntil<RT, IN, OUT>(
     /// <param name="Fold">Fold function</param>
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns></returns>
@@ -389,6 +439,7 @@ public static Pipe<RT, IN, OUT, Unit> foldWhile<RT, IN, OUT>(
     /// <param name="Fold">Fold function</param>
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="IN">Stream value to consume</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
     /// <returns></returns>
diff --git a/LanguageExt.Pipes/Pipe/Pipe.cs b/LanguageExt.Pipes/Pipe/Pipe.cs
index 7b5a5e419..789f4f27f 100644
--- a/LanguageExt.Pipes/Pipe/Pipe.cs
+++ b/LanguageExt.Pipes/Pipe/Pipe.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics.Contracts;
 using System.Threading.Tasks;
+using LanguageExt.Pipes.Concurrent;
 using LanguageExt.Traits;
 
 namespace LanguageExt.Pipes;
@@ -36,7 +37,7 @@ public Consumer<RT, IN, A> Compose(Consumer<RT, OUT, A> rhs) =>
     [Pure]
     public Consumer<RT, IN, A> Compose(ConsumerT<OUT, Eff<RT>, A> rhs) =>
         Proxy.Compose(rhs.Proxy);
-
+    
     [Pure]
     public static Pipe<RT, IN, OUT, A> operator | (Pipe<RT, IN, OUT, A> lhs, Pipe<RT, OUT, OUT, A> rhs) =>
         lhs.Compose(rhs);
diff --git a/LanguageExt.Pipes/PipeT/PipeT.Module.cs b/LanguageExt.Pipes/PipeT/PipeT.Module.cs
index 3ee934cd1..412855289 100644
--- a/LanguageExt.Pipes/PipeT/PipeT.Module.cs
+++ b/LanguageExt.Pipes/PipeT/PipeT.Module.cs
@@ -46,6 +46,28 @@ public static PipeT<IN, OUT, M, Unit> yieldAll<M, IN, OUT>(IEnumerable<OUT> valu
     public static PipeT<IN, OUT, M, Unit> yieldAll<M, IN, OUT>(IAsyncEnumerable<OUT> values) 
         where M : Monad<M> =>
         new PipeTYieldAllAsync<IN, OUT, M, Unit>(values.Select(yield<M, IN, OUT>), pure<IN, OUT, M, Unit>);
+
+    /// <summary>
+    /// Evaluate the `M` monad repeatedly, yielding its bound values downstream
+    /// </summary>
+    /// <typeparam name="IN">Stream value to consume</typeparam>
+    /// <typeparam name="OUT">Stream value to produce</typeparam>
+    /// <typeparam name="M">Lifted monad type</typeparam>
+    /// <returns></returns>
+    public static PipeT<IN, OUT, M, Unit> yieldRepeat<M, IN, OUT>(K<M, OUT> ma)
+        where M : Monad<M> =>
+        new PipeTYieldAll<IN, OUT, M, Unit>(Units.Select(_ => ma.Bind(yield<M, IN, OUT>)), pure<IN, OUT, M, Unit>);
+
+    /// <summary>
+    /// Evaluate the `IO` monad repeatedly, yielding its bound values downstream
+    /// </summary>
+    /// <typeparam name="IN">Stream value to consume</typeparam>
+    /// <typeparam name="OUT">Stream value to produce</typeparam>
+    /// <typeparam name="M">Lifted monad type</typeparam>
+    /// <returns></returns>
+    public static PipeT<IN, OUT, M, Unit> yieldRepeatIO<M, IN, OUT>(IO<OUT> ma)
+        where M : Monad<M> =>
+        new PipeTYieldAll<IN, OUT, M, Unit>(Units.Select(_ => ma.Bind(yield<M, IN, OUT>)), pure<IN, OUT, M, Unit>);
     
     /// <summary>
     /// Await a value from upstream
diff --git a/LanguageExt.Pipes/PipeT/PipeT.Monad.cs b/LanguageExt.Pipes/PipeT/PipeT.Monad.cs
index b4264e878..fa56916e5 100644
--- a/LanguageExt.Pipes/PipeT/PipeT.Monad.cs
+++ b/LanguageExt.Pipes/PipeT/PipeT.Monad.cs
@@ -50,4 +50,9 @@ static K<PipeT<IN, OUT, M>, B> MonadIO<PipeT<IN, OUT, M>>.MapIO<A, B>(K<PipeT<IN
 
     static K<PipeT<IN, OUT, M>, IO<A>> MonadIO<PipeT<IN, OUT, M>>.ToIO<A>(K<PipeT<IN, OUT, M>, A> ma) => 
         ma.MapIO(IO.pure);
+    
+    static K<PipeT<IN, OUT, M>, ForkIO<A>> MonadIO<PipeT<IN, OUT, M>>.ForkIO<A>(
+        K<PipeT<IN, OUT, M>, A> ma,
+        Option<TimeSpan> timeout) =>
+        MonadT.lift<PipeT<IN, OUT, M>, M, ForkIO<A>>(ma.As().Run().ForkIO(timeout));    
 }
diff --git a/LanguageExt.Pipes/Producer/Producer.Module.cs b/LanguageExt.Pipes/Producer/Producer.Module.cs
index b3398b425..98ed1f998 100644
--- a/LanguageExt.Pipes/Producer/Producer.Module.cs
+++ b/LanguageExt.Pipes/Producer/Producer.Module.cs
@@ -1,10 +1,7 @@
 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;
@@ -19,8 +16,8 @@ public static class Producer
     /// <summary>
     /// Yield a value downstream
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, Unit> yield<RT, OUT>(OUT value) =>
         PipeT.yield<Eff<RT>, Unit, OUT>(value);
@@ -28,8 +25,8 @@ public static Producer<RT, OUT, Unit> yield<RT, OUT>(OUT value) =>
     /// <summary>
     /// Yield all values downstream
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, Unit> yieldAll<RT, OUT>(IEnumerable<OUT> values) =>
         PipeT.yieldAll<Eff<RT>, Unit, OUT>(values);
@@ -37,17 +34,37 @@ public static Producer<RT, OUT, Unit> yieldAll<RT, OUT>(IEnumerable<OUT> values)
     /// <summary>
     /// Yield all values downstream
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, Unit> yieldAll<RT, OUT>(IAsyncEnumerable<OUT> values) =>
         PipeT.yieldAll<Eff<RT>, Unit, OUT>(values);
     
+    /// <summary>
+    /// Evaluate the `M` monad repeatedly, yielding its bound values downstream
+    /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
+    /// <typeparam name="IN">Stream value to consume</typeparam>
+    /// <typeparam name="OUT">Stream value to produce</typeparam>
+    /// <returns></returns>
+    public static Producer<RT, OUT, Unit> yieldRepeat<RT, OUT>(K<Eff<RT>, OUT> ma) =>
+        PipeT.yieldRepeat<Eff<RT>, Unit, OUT>(ma);
+
+    /// <summary>
+    /// Evaluate the `IO` monad repeatedly, yielding its bound values downstream
+    /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
+    /// <typeparam name="IN">Stream value to consume</typeparam>
+    /// <typeparam name="OUT">Stream value to produce</typeparam>
+    /// <returns></returns>
+    public static Producer<RT, OUT, Unit> yieldRepeatIO<RT, OUT>(IO<OUT> ma) =>
+        PipeT.yieldRepeatIO<Eff<RT>, Unit, OUT>(ma);
+    
     /// <summary>
     /// Create a producer that simply returns a bound value without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> pure<RT, OUT, A>(A value) =>
@@ -56,8 +73,8 @@ public static Producer<RT, OUT, A> pure<RT, OUT, A>(A value) =>
     /// <summary>
     /// Create a producer that always fails
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> error<RT, OUT, A>(Error value) =>
@@ -66,8 +83,8 @@ public static Producer<RT, OUT, A> error<RT, OUT, A>(Error value) =>
     /// <summary>
     /// Create a producer that yields nothing at all
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> empty<RT, OUT, A>() =>
@@ -76,8 +93,8 @@ public static Producer<RT, OUT, A> empty<RT, OUT, A>() =>
     /// <summary>
     /// Create a producer that lazily returns a bound value without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> lift<RT, OUT, A>(Func<A> f)  =>
@@ -86,8 +103,8 @@ public static Producer<RT, OUT, A> lift<RT, OUT, A>(Func<A> f)  =>
     /// <summary>
     /// Create a producer that simply returns the bound value of the lifted monad without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> liftM<RT, OUT, A>(K<Eff<RT>, A> ma) =>
@@ -96,8 +113,8 @@ public static Producer<RT, OUT, A> liftM<RT, OUT, A>(K<Eff<RT>, A> ma) =>
     /// <summary>
     /// Create a producer that simply returns the bound value of the lifted monad without yielding anything
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> liftIO<RT, OUT, A>(IO<A> ma) =>
@@ -107,7 +124,6 @@ public static Producer<RT, OUT, A> liftIO<RT, OUT, A>(IO<A> ma) =>
     /// Create a lazy proxy 
     /// </summary>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> liftT<RT, OUT, A>(Func<Producer<RT, OUT, A>> f) =>
@@ -116,8 +132,8 @@ public static Producer<RT, OUT, A> liftT<RT, OUT, A>(Func<Producer<RT, OUT, A>>
     /// <summary>
     /// Create an asynchronous lazy proxy 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> liftT<RT, OUT, A>(Func<ValueTask<Producer<RT, OUT, A>>> f) =>
@@ -126,8 +142,8 @@ public static Producer<RT, OUT, A> liftT<RT, OUT, A>(Func<ValueTask<Producer<RT,
     /// <summary>
     /// Create an asynchronous proxy 
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> liftT<RT, OUT, A>(ValueTask<Producer<RT, OUT, A>> f) =>
@@ -136,8 +152,8 @@ public static Producer<RT, OUT, A> liftT<RT, OUT, A>(ValueTask<Producer<RT, OUT,
     /// <summary>
     /// Continually repeat the provided operation
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> repeat<RT, OUT, A>(Producer<RT, OUT, A> ma) =>
@@ -146,8 +162,8 @@ public static Producer<RT, OUT, A> repeat<RT, OUT, A>(Producer<RT, OUT, A> ma) =
     /// <summary>
     /// Repeat the provided operation based on the schedule provided
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> repeat<RT, OUT, A>(Schedule schedule, Producer<RT, OUT, A> ma) =>
@@ -157,7 +173,6 @@ public static Producer<RT, OUT, A> repeat<RT, OUT, A>(Schedule schedule, Produce
     /// Continually lift & repeat the provided operation
     /// </summary>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> repeatM<RT, OUT, A>(K<Eff<RT>, A> ma) =>
@@ -166,8 +181,8 @@ public static Producer<RT, OUT, A> repeatM<RT, OUT, A>(K<Eff<RT>, A> ma) =>
     /// <summary>
     /// Repeat the provided operation based on the schedule provided
     /// </summary>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, A> repeatM<RT, OUT, A>(Schedule schedule, K<Eff<RT>, A> ma) =>
@@ -181,8 +196,8 @@ public static Producer<RT, OUT, A> repeatM<RT, OUT, A>(Schedule schedule, K<Eff<
     /// <param name="Fold">Fold function</param>
     /// <param name="Init">Initial state</param>
     /// <param name="Item">Pipe to fold</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, Unit> fold<RT, OUT, A>(
@@ -200,8 +215,8 @@ public static Producer<RT, OUT, Unit> fold<RT, OUT, A>(
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
     /// <param name="Item">Pipe to fold</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, Unit> foldUntil<RT, OUT, A>(
@@ -220,8 +235,8 @@ public static Producer<RT, OUT, Unit> foldUntil<RT, OUT, A>(
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
     /// <param name="Item">Pipe to fold</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, Unit> foldUntil<RT, OUT, A>(
@@ -240,8 +255,8 @@ public static Producer<RT, OUT, Unit> foldUntil<RT, OUT, A>(
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
     /// <param name="Item">Pipe to fold</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, Unit> foldWhile<RT, OUT, M, A>(
@@ -260,8 +275,8 @@ public static Producer<RT, OUT, Unit> foldWhile<RT, OUT, M, A>(
     /// <param name="Pred">Until predicate</param>
     /// <param name="Init">Initial state</param>
     /// <param name="Item">Pipe to fold</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <typeparam name="A">Bound value type</typeparam>
     /// <returns></returns>
     public static Producer<RT, OUT, Unit> foldWhile<RT, OUT, A>(
@@ -271,14 +286,26 @@ public static Producer<RT, OUT, Unit> foldWhile<RT, OUT, A>(
         OUT Init,
         Producer<RT, OUT, A> Item) =>
         PipeT.foldWhile(Time, Fold, Pred, Init, Item.Proxy);
+
+    /// <summary>
+    /// Merge multiple producers
+    /// </summary>
+    /// <param name="producers">Producers to merge</param>
+    /// <param name="settings">Buffer settings</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
+    /// <typeparam name="OUT">Stream value to produce</typeparam>
+    /// <returns>Merged producer</returns>
+    public static Producer<RT, OUT, Unit> merge<RT, OUT>(
+        params Producer<RT, OUT, Unit>[] producers) =>
+        merge(toSeq(producers));
     
     /// <summary>
     /// Merge multiple producers
     /// </summary>
     /// <param name="producers">Producers to merge</param>
     /// <param name="settings">Buffer settings</param>
+    /// <typeparam name="RT">Effect runtime type</typeparam>
     /// <typeparam name="OUT">Stream value to produce</typeparam>
-    /// <typeparam name="M">Lifted monad type</typeparam>
     /// <returns>Merged producer</returns>
     public static Producer<RT, OUT, Unit> merge<RT, OUT>(
         Seq<Producer<RT, OUT, Unit>> producers, 
diff --git a/LanguageExt.Pipes/ProducerT/ProducerT.Module.cs b/LanguageExt.Pipes/ProducerT/ProducerT.Module.cs
index 6c8678c16..7e1bac8e1 100644
--- a/LanguageExt.Pipes/ProducerT/ProducerT.Module.cs
+++ b/LanguageExt.Pipes/ProducerT/ProducerT.Module.cs
@@ -46,6 +46,28 @@ public static ProducerT<OUT, M, Unit> yieldAll<M, OUT>(IAsyncEnumerable<OUT> val
         where M : Monad<M> =>
         PipeT.yieldAll<M, Unit, OUT>(values);
     
+    /// <summary>
+    /// Evaluate the `M` monad repeatedly, yielding its bound values downstream
+    /// </summary>
+    /// <typeparam name="IN">Stream value to consume</typeparam>
+    /// <typeparam name="OUT">Stream value to produce</typeparam>
+    /// <typeparam name="M">Lifted monad type</typeparam>
+    /// <returns></returns>
+    public static ProducerT<OUT, M, Unit> yieldRepeat<M, OUT>(K<M, OUT> ma)
+        where M : Monad<M> =>
+        PipeT.yieldRepeat<M, Unit, OUT>(ma);
+
+    /// <summary>
+    /// Evaluate the `IO` monad repeatedly, yielding its bound values downstream
+    /// </summary>
+    /// <typeparam name="IN">Stream value to consume</typeparam>
+    /// <typeparam name="OUT">Stream value to produce</typeparam>
+    /// <typeparam name="M">Lifted monad type</typeparam>
+    /// <returns></returns>
+    public static ProducerT<OUT, M, Unit> yieldRepeatIO<M, OUT>(IO<OUT> ma)
+        where M : Monad<M> =>
+        PipeT.yieldRepeatIO<M, Unit, OUT>(ma);
+    
     /// <summary>
     /// Create a producer that simply returns a bound value without yielding anything
     /// </summary>
@@ -304,6 +326,19 @@ public static ProducerT<OUT, M, Unit> foldWhile<OUT, M, A>(
         ProducerT<OUT, M, A> Item)
         where M : Monad<M> =>
         PipeT.foldWhile(Time, Fold, Pred, Init, Item.Proxy);
+
+    /// <summary>
+    /// Merge multiple producers
+    /// </summary>
+    /// <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>(
+        params ProducerT<OUT, M, Unit>[] producers)
+        where M : Monad<M> =>
+        merge(toSeq(producers));
     
     /// <summary>
     /// Merge multiple producers
@@ -320,10 +355,17 @@ public static ProducerT<OUT, M, Unit> merge<OUT, M>(
     {
         if (producers.Count == 0) return pure<OUT, M, Unit>(default);
 
-        return from mailbox in Pure(Mailbox.spawn(settings ?? Buffer<OUT>.Unbounded))
-               from forks   in producers.Traverse(p => (p | mailbox.ToConsumerT<M>()).ForkIO()).As().Run()
+        return from mailbox in Pure(Mailbox.spawn(settings ?? Buffer<OUT>.Unbounded, "merge"))
+               from forks   in forkEffects(producers, mailbox)
                from _       in mailbox.ToProducerT<M>()
                from x       in forks.Traverse(f => f.Cancel).As()
                select unit;
     }
+
+    static K<M, Seq<ForkIO<Unit>>> forkEffects<M, OUT>(
+        Seq<ProducerT<OUT, M, Unit>> producers,
+        Mailbox<OUT, OUT> mailbox)
+        where M : Monad<M> =>
+        producers.Map(p => (p | mailbox.ToConsumerT<M>()).Run())
+                 .Traverse(ma => ma.ForkIO());
 }
diff --git a/LanguageExt.Tests/PipesTests.cs b/LanguageExt.Tests/PipesTests.cs
index c9a6da735..845ac9ffb 100644
--- a/LanguageExt.Tests/PipesTests.cs
+++ b/LanguageExt.Tests/PipesTests.cs
@@ -1,7 +1,7 @@
-using LanguageExt.Pipes;
-using LanguageExt.Sys.Test;
+using LanguageExt.Sys.Test;
 using Xunit;
-using static LanguageExt.Pipes.Proxy;
+using static LanguageExt.Pipes.Producer;
+using static LanguageExt.Pipes.Consumer;
 
 namespace LanguageExt.Tests;
 
@@ -11,12 +11,11 @@ public class PipesTests
     public void MergeSynchronousProducersSucceeds()
     {
         using var rt = Runtime.New();
-        compose(Producer.merge<int, Eff<Runtime>>(
-                    yield(1),
-                    yield(1)),
-                awaiting<int>().Map(ignore))
-              .RunEffect().As()
-              .Run(rt, EnvIO.New())
-              .Ignore();
+        
+        (merge(yield<Runtime, int>(1), yield<Runtime, int>(1))
+       | awaiting<Runtime, int>().Map(ignore))
+           .Run().As()
+           .Run(rt, EnvIO.New())
+           .Ignore();
     }
 }
diff --git a/LanguageExt.Tests/Sys/Diag/ActivityTests.cs b/LanguageExt.Tests/Sys/Diag/ActivityTests.cs
index ac6a15551..846846dc8 100644
--- a/LanguageExt.Tests/Sys/Diag/ActivityTests.cs
+++ b/LanguageExt.Tests/Sys/Diag/ActivityTests.cs
@@ -273,7 +273,7 @@ public static void Case24()
                 "test",
                 ActivityKind.Client,
                 HashMap(("1", "a" as object), ("2", "b")),
-                A.kind.ZipIO(A.tags))
+                A.kind.Zip(A.tags))
             .ArrangeAndAct();
         kind.IsSome.Should().BeTrue();
         kind.Case.Should().Be(ActivityKind.Client);
@@ -299,7 +299,7 @@ public static void Case27()
         var (kind, tags) = A.span("test",
                                   ActivityKind.Client,
                                   HashMap(("1", "a" as object), ("2", "b")),
-                                  A.kind.ZipIO(A.tags))
+                                  A.kind.Zip(A.tags))
                             .ArrangeAndAct();
         
         Assert.True(kind.IsSome);
@@ -323,7 +323,7 @@ from result in A.span(
                     HashMap(("1", "a" as object), ("2", "b")),
                     Seq<ActivityLink>.Empty,
                     DateTimeOffset.Now,
-                    A.kind.ZipIO(A.tags))
+                    A.kind.Zip(A.tags))
                 select result
             )
             .ArrangeAndAct();
diff --git a/Samples/EffectsExamples/Examples/QueueExample.cs b/Samples/EffectsExamples/Examples/QueueExample.cs
index 267d3d755..09684860f 100644
--- a/Samples/EffectsExamples/Examples/QueueExample.cs
+++ b/Samples/EffectsExamples/Examples/QueueExample.cs
@@ -29,8 +29,8 @@ public static class QueueExample<RT>
     public static Eff<RT, Unit> main()
     {
         // Create two queues.  Queues are Producers that have an Enqueue function
-        var queue1 = Mailbox.spawn<string>();
-        var queue2 = Mailbox.spawn<string>();
+        var queue1 = Mailbox.spawn<string>("mailbox-1");
+        var queue2 = Mailbox.spawn<string>("mailbox-2");
 
         // Compose the queues with a pipe that prepends some text to what they produce
         var queues = Seq(queue1.ToProducer<RT>() | prepend("Queue 1: "), 
@@ -39,8 +39,8 @@ public static Eff<RT, Unit> main()
         // Run the queues in a forked task
         // Repeatedly read from the console and write to one of the two queues depending on
         // whether the first char is 1 or 2
-        var effect = from f in fork(Producer.merge(queues) | writeLine)
-                     from x in repeat(Console<RT>.readLines | writeToQueue(queue1, queue2))
+        var effect = from f in fork(Producer.merge(queues) | Consumer.repeat(writeLine))
+                     from x in Console<RT>.readLines | writeToQueue(queue1, queue2) | Schedule.Forever
                      from _ in f.Cancel // cancels the forked task
                      select unit;
 
@@ -66,7 +66,8 @@ from u in guard(x.Length > 0, Error.New("exiting"))
     /// Pipe that prepends the text provided to the awaited value and then yields it
     /// </summary>
     static Pipe<RT, string, string, Unit> prepend(string x) =>
-        from l in Pipe.awaiting<RT, string, string>()         
+        from l in Pipe.awaiting<RT, string, string>()
+        from TO_REMOVE in Console<RT>.writeLine($"PREPENDING: {x}")
         from _ in Pipe.yield<RT, string, string>($"{x}{l}")
         select unit;
         
diff --git a/Samples/PipesExamples/Program.cs b/Samples/PipesExamples/Program.cs
index 5add49694..9faf5e9f6 100644
--- a/Samples/PipesExamples/Program.cs
+++ b/Samples/PipesExamples/Program.cs
@@ -35,7 +35,7 @@ from _2 in Consumer.lift<int, IO, Unit>(writeLine($"post-await: {x}"))
 
 var p = yieldAll<IO, int>(Range(1, 10000000));
 
-var o = foldUntil(Time: Schedule.recurs(50), 
+var o = foldUntil(Time: Schedule.spaced(10) | Schedule.recurs(3), 
                   Fold: (s, v) => s + v,
                   Pred: v => v.Value % 10000 == 0,
                   Init: 0,
@@ -53,57 +53,3 @@ from _ in writeLine($"{x}")
 
 static IO<Unit> writeLine(object? value) =>
     IO.lift(() => Console.WriteLine(value));
-
-public record DbEnv;
-public record Db<A>(ReaderT<DbEnv, IO, A> RunDb) : K<Db, A>
-{
-    public Db<B> Select<B>(Func<A, B> m) => this.Kind().Select(m).As();
-    public Db<C> SelectMany<B, C>(Func<A, K<Db, B>> b, Func<A, B, C> p) => this.Kind().SelectMany(b, p).As();
-    public Db<C> SelectMany<B, C>(Func<A, K<IO, B>> b, Func<A, B, C> p) => this.Kind().SelectMany(b, p).As();
-}
-
-public static class DbExtensions
-{
-    public static Db<A> As<A>(this K<Db, A> ma) =>
-        (Db<A>)ma;
-}
-public class Db : Monad<Db>, Fallible<Db>, Readable<Db, DbEnv>
-{
-    public static K<Db, B> Bind<A, B>(K<Db, A> ma, Func<A, K<Db, B>> f) =>
-        new Db<B>(ma.As().RunDb.Bind(x => f(x).As().RunDb));
-
-    public static K<Db, B> Map<A, B>(Func<A, B> f, K<Db, A> ma) => 
-        new Db<B>(ma.As().RunDb.Map(f));
-
-    public static K<Db, A> Pure<A>(A value) => 
-        new Db<A>(ReaderT.pure<DbEnv, IO, A>(value));
-
-    public static K<Db, B> Apply<A, B>(K<Db, Func<A, B>> mf, K<Db, A> ma) => 
-        new Db<B>(mf.As().RunDb.Apply(ma.As().RunDb));
-
-    public static K<Db, A> Fail<A>(Error error) => 
-        new Db<A>(ReaderT.liftIO<DbEnv, IO, A>(error));
-
-    public static K<Db, A> Catch<A>(K<Db, A> fa, Func<Error, bool> Predicate, Func<Error, K<Db, A>> Fail) =>
-        from env in Readable.ask<Db, DbEnv>()
-        from res in fa.As()
-                      .RunDb
-                      .runReader(env)
-                      .Catch(Predicate, x => Fail(x).As().RunDb.runReader(env)) 
-        select res;
-
-    public static K<Db, A> Asks<A>(Func<DbEnv, A> f) => 
-        new Db<A>(ReaderT.asks<IO, A, DbEnv>(f));
-
-    public static K<Db, A> Local<A>(Func<DbEnv, DbEnv> f, K<Db, A> ma) => 
-        new Db<A>(ReaderT.local(f, ma.As().RunDb));
-
-    public static K<Db, A> LiftIO<A>(IO<A> ma) => 
-        new Db<A>(ReaderT.liftIO<DbEnv, IO, A>(ma));
-
-    public static K<Db, B> MapIO<A, B>(K<Db, A> ma, Func<IO<A>, IO<B>> f) => 
-        new Db<B>(ma.As().RunDb.MapIO(f).As());
-
-    public static K<Db, IO<A>> ToIO<A>(K<Db, A> ma) =>
-        ma.MapIO(IO.pure);
-}
diff --git a/Samples/TestBed.Web/Program.cs b/Samples/TestBed.Web/Program.cs
index 031a7557f..13f2209b0 100644
--- a/Samples/TestBed.Web/Program.cs
+++ b/Samples/TestBed.Web/Program.cs
@@ -1,4 +1,5 @@
-using static LanguageExt.Prelude;
+using LanguageExt;
+using static LanguageExt.Prelude;
 var builder = WebApplication.CreateBuilder(args);
 var app     = builder.Build();
 
diff --git a/Samples/TestBed/PipesTest.cs b/Samples/TestBed/PipesTest.cs
index ac2783602..12c8b87a4 100644
--- a/Samples/TestBed/PipesTest.cs
+++ b/Samples/TestBed/PipesTest.cs
@@ -5,15 +5,17 @@
 using LanguageExt.Sys;
 using LanguageExt.Sys.Live;
 using static LanguageExt.Prelude;
-using static LanguageExt.Pipes.Proxy;
+using static LanguageExt.Pipes.Producer;
+using static LanguageExt.Pipes.Consumer;
+using static LanguageExt.Pipes.Pipe;
 using static LanguageExt.UnitsOfMeasure;
 
 namespace TestBed;
 
 public static class PipesTestBed
 {
-    static Producer<int, Eff<Runtime>, Unit> numbers(int n, int failOn) =>
-        from _ in yield(n)
+    static Producer<Runtime, int, Unit> numbers(int n, int failOn) =>
+        from _ in yield<Runtime, int>(n)
         from t in Time<Runtime>.sleepFor(1000 * ms)
         from x in failOn == n 
                     ? FailEff<Runtime, Unit>(Error.New($"failed on {n}")) 
@@ -23,42 +25,32 @@ from r in n < 0
                     : numbers(n - 1, failOn)
         select r;
     
-    public static Effect<Eff<Runtime>, Unit> effect => 
-        Producer.merge(numbers(10, 5), numbers(20, 0)) | writeLine<int>();
+    public static Effect<Runtime, Unit> effect => 
+        merge(numbers(10, 5), numbers(20, 0)) | writeLine<int>();
     
-    static Consumer<X, Eff<Runtime>, Unit> writeLine<X>() =>
-        from x in awaiting<X>()
+    static Consumer<Runtime, X, Unit> writeLine<X>() =>
+        from x in awaiting<Runtime, X>()
         from _ in Console<Runtime>.writeLine($"{x}")
         from r in writeLine<X>()
         select r;
     
-    public static Effect<Eff<Runtime>, Unit> effect1 => 
+    public static Effect<Runtime, Unit> effect1 => 
         repeat(producer) | doubleIt | consumer;
 
-    static Producer<int, Eff<Runtime>, Unit> producer =>
+    static Producer<Runtime, int, Unit> producer =>
         from _1 in Console<Runtime>.writeLine("before")
-        from _2 in yieldAll(Range(1, 5))
+        from _2 in yieldAll<Runtime, int>(Range(1, 5))
         from _3 in Console<Runtime>.writeLine("after")
         select unit;
 
-     static Pipe<int, int, Eff<Runtime>, Unit> doubleIt =>
-        from x in awaiting<int>()
-        from _ in yield(x * 2)
+     static Pipe<Runtime, int, int, Unit> doubleIt =>
+        from x in awaiting<Runtime, int, int>()
+        from _ in yield<Runtime, int, int>(x * 2)
         select unit;
     
-    static Consumer<int, Eff<Runtime>, Unit> consumer =>
-        from i in awaiting<int>()
+    static Consumer<Runtime, int, Unit> consumer =>
+        from i in awaiting<Runtime, int>()
         from _ in Console<Runtime>.writeLine(i.ToString())
         from r in consumer
         select r;
-    
-    public static Effect<Eff<Runtime>, Unit> effect2 =>
-        Producer.repeatM(Time<Runtime>.nowUTC)
-      | Pipe.mapM<DateTime, DateTime, Eff<Runtime>, Unit>(dt => 
-            from _1 in Console<Runtime>.setColour(ConsoleColor.Green)
-            from _2 in Console<Runtime>.writeLine(dt.ToLongTimeString())
-            from _3 in Console<Runtime>.resetColour
-            select dt)
-      | writeLine<DateTime>();
-    
 }
diff --git a/Samples/TestBed/Program.cs b/Samples/TestBed/Program.cs
index 51855533e..085c93981 100644
--- a/Samples/TestBed/Program.cs
+++ b/Samples/TestBed/Program.cs
@@ -7,71 +7,11 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using LanguageExt;
-using System.Text;
-using LanguageExt.Sys;
-using LanguageExt.Pipes;
-using LanguageExt.Sys.IO;
-using System.Reactive.Linq;
-using System.Threading;
-using LanguageExt.Sys.Live;
 using System.Threading.Tasks;
-using LanguageExt.Common;
-using LanguageExt.Traits;
 using TestBed;
 using static LanguageExt.Prelude;
-using static LanguageExt.Pipes.Proxy;
 
-public interface IAsyncQueue<A>
-{
-    Task<A> DequeueAsync();
-}
-
-public static class Ext
-{
-    static Producer<A, Eff<RT>, Unit> ToProducer<RT, A>(this IAsyncQueue<A> q) 
-    {
-        return yieldAll(go());
-
-        async IAsyncEnumerable<A> go()
-        {
-            while (true)
-            {
-                yield return await q.DequeueAsync();
-            }
-        }
-    }
-
-    public static Producer<A, Eff<RT>, Unit> ToProducer<RT, A>(this IAsyncQueue<A>[] qs) =>
-        Producer.merge(qs.AsIterable().Map(q => q.ToProducer<RT, A>()).ToSeq());
-}
-
-public static class YourPrelude
-{
-    public static Eff<A> OptionalAff<A>(this Func<Task<A?>> task) =>
-        OptionalEff(task, Errors.None);
-    
-    public static Eff<A> OptionalEff<A>(this Func<Task<A?>> task, Error fail) =>
-        liftEff(async () => 
-            await task() switch
-            {
-                null => fail,
-                var x => FinSucc(x)
-            });
-    
-    public static Eff<A> OptionalAff<A>(this Func<ValueTask<A?>> task) =>
-        OptionalAff(task, Errors.None);
-    
-    public static Eff<A> OptionalAff<A>(this Func<ValueTask<A?>> task, Error fail) =>
-        liftEff(async () => 
-            await task() switch
-            {
-                null => fail,
-                var x => FinSucc(x)
-            });
-}
 
 public class Program
 {
@@ -168,6 +108,7 @@ from y in IO.lift(() => Console.WriteLine(t))
         var mr = my.Run("Paul").Run().Run();
     }
 
+    /*
     public static void PipesTest()
     {
         // Create two queues.  Queues are Producers that have an Enqueue function
@@ -356,6 +297,7 @@ from l in Consumer.awaiting<Eff<Runtime>, string>()
         from a in Console<Eff<Runtime>, Runtime>.writeLine(l)
         from n in writeLine2
         select unit;
+        */
 
 
     /*static Server<Runtime, int, int, Unit> incrementer(int question) =>
@@ -372,6 +314,7 @@ from _2 in Client.lift<Runtime, int, int, Unit>(Console<Runtime>.writeLine($"Cli
         select unit;*/
 
 
+    /*
     static Pipe<string, string, Eff<Runtime>, Unit> pipeMap =>
-        Pipe.map((string x) => $"Hello {x}");
+        Pipe.map((string x) => $"Hello {x}");*/
 }