From de4801bdc735dd2c9643813af2a5e82b395c7895 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 9 Aug 2024 12:21:58 -0700
Subject: [PATCH] [FEATURE]: Improve builder pattern (#35)

* Refactor builders to eliminate reliance on partial interfaces and classes

---------

Co-authored-by: Brenton Farmer <brent.farmer@wagglebee.net>
---
 docs/syntax.md                                | 17 +++-
 .../Binders/Abstractions/Binder.cs            |  1 +
 .../Builders/CallBlockBuilder.cs              | 42 ++++++----
 .../Builders/CallIfBlockBuilder.cs            | 44 +++++++---
 .../Builders/CallStatementBuilder.cs          | 74 +++++++++++++----
 .../Builders/ForEachBlockBuilder.cs           | 42 +++++++---
 src/Hyperbee.Pipeline/Builders/HookBuilder.cs | 46 +++++++---
 .../Builders/PipeBlockBuilder.cs              | 43 ++++++----
 .../Builders/PipeIfBlockBuilder.cs            | 43 +++++++---
 .../Builders/PipeStatementBuilder.cs          | 72 ++++++++++++----
 .../Builders/ReduceBlockBuilder.cs            | 49 ++++++++---
 .../Builders/WaitAllBlockBuilder.cs           | 83 +++++++++++++------
 src/Hyperbee.Pipeline/Builders/WrapBuilder.cs | 62 ++++++++++----
 src/Hyperbee.Pipeline/IPipelineBuilder.cs     |  4 +-
 src/Hyperbee.Pipeline/IPipelineFunction.cs    | 10 ++-
 src/Hyperbee.Pipeline/PipelineBuilder.cs      | 10 +--
 .../PipelineEnumerationTests.cs               |  4 +-
 17 files changed, 468 insertions(+), 178 deletions(-)

diff --git a/docs/syntax.md b/docs/syntax.md
index a449bd7..ead930b 100644
--- a/docs/syntax.md
+++ b/docs/syntax.md
@@ -101,7 +101,7 @@ var count = 0;
 var command = PipelineFactory
     .Start<string>()
     .Pipe( ( ctx, arg ) => arg.Split( ' ' ) )
-    .ForEach<string>( builder => builder
+    .ForEach().Type<string>( builder => builder
         .Pipe( ( ctx, arg ) => count += 10 )
     )
     .Pipe( ( ctx, arg ) => count += 5 )
@@ -117,6 +117,21 @@ Assert.AreEqual( count, 25 );
 `Reduce` and `ReduceAync` allow you to transform an enumerable pipeline input to a single value. You can specify a reducer function
 that defines how the elements should be combined, and a builder function that creates the pipeline for processing the elements.### Cancel
 
+```csharp
+var command = PipelineFactory
+     .Start<string>()
+     .Pipe( ( ctx, arg ) => arg.Split( ' ' ) )
+     .Reduce().Type<string, int>( ( aggregate, value ) => aggregate + value, builder => builder
+         .Pipe( ( ctx, arg ) => int.Parse( arg ) + 10 )
+     )
+     .Pipe( ( ctx, arg ) => arg + 5 )
+     .Build();
+
+var result = await command( new PipelineContext(), "1 2 3 4 5" );
+
+Assert.AreEqual( result, 70 );
+```
+
 ### WaitAll
 
 `WaitAll` allows you to wait for concurrent pipelines to complete before continuing. You can specify a set of builders that create
diff --git a/src/Hyperbee.Pipeline/Binders/Abstractions/Binder.cs b/src/Hyperbee.Pipeline/Binders/Abstractions/Binder.cs
index 599b072..eb97279 100644
--- a/src/Hyperbee.Pipeline/Binders/Abstractions/Binder.cs
+++ b/src/Hyperbee.Pipeline/Binders/Abstractions/Binder.cs
@@ -2,6 +2,7 @@
 using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline.Binders.Abstractions;
+
 internal abstract class Binder<TInput, TOutput>
 {
     protected FunctionAsync<TInput, TOutput> Pipeline { get; }
diff --git a/src/Hyperbee.Pipeline/Builders/CallBlockBuilder.cs b/src/Hyperbee.Pipeline/Builders/CallBlockBuilder.cs
index 39ec168..3d57e25 100644
--- a/src/Hyperbee.Pipeline/Builders/CallBlockBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/CallBlockBuilder.cs
@@ -1,33 +1,47 @@
 using Hyperbee.Pipeline.Binders;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
-public partial interface IPipelineBuilder<TInput, TOutput>
+public static class CallBlockBuilder
 {
-    IPipelineBuilder<TInput, TOutput> Call( Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder );
-    IPipelineBuilder<TInput, TOutput> Call( bool inheritMiddleware, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder );
-}
-
-public partial class PipelineBuilder<TInput, TOutput>
-{
-    // Call an inner builder discarding the final result. Acts like an Action.
+    public static IPipelineBuilder<TInput, TOutput> Call<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder
+    )
+    {
+        return CallBlockBuilder<TInput, TOutput>.Call( parent, true, builder );
+    }
 
-    public IPipelineBuilder<TInput, TOutput> Call( Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder )
+    public static IPipelineBuilder<TInput, TOutput> Call<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        bool inheritMiddleware,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder
+    )
     {
-        return Call( true, builder );
+        return CallBlockBuilder<TInput, TOutput>.Call( parent, inheritMiddleware, builder );
     }
+}
 
-    public IPipelineBuilder<TInput, TOutput> Call( bool inheritMiddleware, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder )
+internal static class CallBlockBuilder<TInput, TOutput>
+{
+    public static IPipelineBuilder<TInput, TOutput> Call(
+        IPipelineBuilder<TInput, TOutput> parent,
+        bool inheritMiddleware,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder
+    )
     {
         ArgumentNullException.ThrowIfNull( builder );
 
-        var block = PipelineFactory.Start<TOutput>( inheritMiddleware ? Middleware : null );
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
+        var block = PipelineFactory.Start<TOutput>( inheritMiddleware ? parentMiddleware : null );
         var function = builder( block ).CastFunction<TOutput, object>(); // cast because we don't know the final Pipe output value
 
         return new PipelineBuilder<TInput, TOutput>
         {
-            Function = new CallBlockBinder<TInput, TOutput>( Function ).Bind( function ),
-            Middleware = Middleware
+            Function = new CallBlockBinder<TInput, TOutput>( parentFunction ).Bind( function ),
+            Middleware = parentMiddleware
         };
     }
 }
diff --git a/src/Hyperbee.Pipeline/Builders/CallIfBlockBuilder.cs b/src/Hyperbee.Pipeline/Builders/CallIfBlockBuilder.cs
index c2e8cfa..90b7993 100644
--- a/src/Hyperbee.Pipeline/Builders/CallIfBlockBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/CallIfBlockBuilder.cs
@@ -1,32 +1,50 @@
 using Hyperbee.Pipeline.Binders;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
-public partial interface IPipelineBuilder<TInput, TOutput>
+public static class CallIfBuilder
 {
-    IPipelineBuilder<TInput, TOutput> CallIf( Function<TOutput, bool> condition, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder );
-    IPipelineBuilder<TInput, TOutput> CallIf( Function<TOutput, bool> condition, bool inheritMiddleware, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder );
-}
-
-public partial class PipelineBuilder<TInput, TOutput>
-{
-    public IPipelineBuilder<TInput, TOutput> CallIf( Function<TOutput, bool> condition, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder )
+    public static IPipelineBuilder<TInput, TOutput> CallIf<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Function<TOutput, bool> condition,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder
+    )
+    {
+        return CallIfBuilder<TInput, TOutput>.CallIf( parent, condition, true, builder );
+    }
+    public static IPipelineBuilder<TInput, TOutput> CallIf<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Function<TOutput, bool> condition,
+        bool inheritMiddleware,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder
+    )
     {
-        return CallIf( condition, true, builder );
+        return CallIfBuilder<TInput, TOutput>.CallIf( parent, condition, inheritMiddleware, builder );
     }
+}
 
-    public IPipelineBuilder<TInput, TOutput> CallIf( Function<TOutput, bool> condition, bool inheritMiddleware, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder )
+internal static class CallIfBuilder<TInput, TOutput>
+{
+    public static IPipelineBuilder<TInput, TOutput> CallIf(
+        IPipelineBuilder<TInput, TOutput> parent,
+        Function<TOutput, bool> condition,
+        bool inheritMiddleware,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder> builder
+    )
     {
         ArgumentNullException.ThrowIfNull( builder );
         ArgumentNullException.ThrowIfNull( condition );
 
-        var block = PipelineFactory.Start<TOutput>( inheritMiddleware ? Middleware : null );
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
+        var block = PipelineFactory.Start<TOutput>( inheritMiddleware ? parentMiddleware : null );
         var function = builder( block ).CastFunction<TOutput, object>(); // cast because we don't know the final Pipe output value
 
         return new PipelineBuilder<TInput, TOutput>
         {
-            Function = new CallIfBlockBinder<TInput, TOutput>( condition, Function ).Bind( function ),
-            Middleware = Middleware
+            Function = new CallIfBlockBinder<TInput, TOutput>( condition, parentFunction ).Bind( function ),
+            Middleware = parentMiddleware
         };
     }
 }
diff --git a/src/Hyperbee.Pipeline/Builders/CallStatementBuilder.cs b/src/Hyperbee.Pipeline/Builders/CallStatementBuilder.cs
index f9c8e0c..e061065 100644
--- a/src/Hyperbee.Pipeline/Builders/CallStatementBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/CallStatementBuilder.cs
@@ -1,28 +1,64 @@
-using Hyperbee.Pipeline.Binders;
+using System.Xml.Linq;
+using Hyperbee.Pipeline.Binders;
 using Hyperbee.Pipeline.Context;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
-public partial interface IPipelineBuilder<TInput, TOutput>
+public static class CallStatementBuilder
 {
-    IPipelineBuilder<TInput, TOutput> Call( Procedure<TOutput> next, string name );
-    IPipelineBuilder<TInput, TOutput> Call( Procedure<TOutput> next, Action<IPipelineContext> config = null );
-    IPipelineBuilder<TInput, TOutput> CallAsync( ProcedureAsync<TOutput> next, string name );
-    IPipelineBuilder<TInput, TOutput> CallAsync( ProcedureAsync<TOutput> next, Action<IPipelineContext> config = null );
+    public static IPipelineBuilder<TInput, TOutput> Call<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Procedure<TOutput> next, string name
+    )
+    {
+        return CallStatementBuilder<TInput, TOutput>.Call( parent, next, config => config.Name = name );
+    }
+
+    public static IPipelineBuilder<TInput, TOutput> Call<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Procedure<TOutput> next,
+        Action<IPipelineContext> config = null
+    )
+    {
+        return CallStatementBuilder<TInput, TOutput>.Call( parent, next, config );
+    }
+
+    public static IPipelineBuilder<TInput, TOutput> CallAsync<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        ProcedureAsync<TOutput> next,
+        string name
+    )
+    {
+        return CallStatementBuilder<TInput, TOutput>.CallAsync( parent, next, config => config.Name = name );
+    }
+
+    public static IPipelineBuilder<TInput, TOutput> CallAsync<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        ProcedureAsync<TOutput> next,
+        Action<IPipelineContext> config = null
+    )
+    {
+        return CallStatementBuilder<TInput, TOutput>.CallAsync( parent, next, config );
+    }
 }
 
-public partial class PipelineBuilder<TInput, TOutput>
+internal static class CallStatementBuilder<TInput, TOutput>
 {
-    public IPipelineBuilder<TInput, TOutput> Call( Procedure<TOutput> next, string name ) => Call( next, config => config.Name = name );
-
-    public IPipelineBuilder<TInput, TOutput> Call( Procedure<TOutput> next, Action<IPipelineContext> config = null )
+    public static IPipelineBuilder<TInput, TOutput> Call(
+        IPipelineBuilder<TInput, TOutput> parent,
+        Procedure<TOutput> next,
+        Action<IPipelineContext> config = null
+    )
     {
         ArgumentNullException.ThrowIfNull( next );
 
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
         return new PipelineBuilder<TInput, TOutput>
         {
-            Function = new CallStatementBinder<TInput, TOutput>( Function, Middleware, config ).Bind( AsyncNext, next.Method ),
-            Middleware = Middleware
+            Function = new CallStatementBinder<TInput, TOutput>( parentFunction, parentMiddleware, config ).Bind( AsyncNext, next.Method ),
+            Middleware = parentMiddleware
         };
 
         // task wrapper
@@ -34,16 +70,20 @@ Task AsyncNext( IPipelineContext context, TOutput argument )
         }
     }
 
-    public IPipelineBuilder<TInput, TOutput> CallAsync( ProcedureAsync<TOutput> next, string name ) => CallAsync( next, config => config.Name = name );
-
-    public IPipelineBuilder<TInput, TOutput> CallAsync( ProcedureAsync<TOutput> next, Action<IPipelineContext> config = null )
+    public static IPipelineBuilder<TInput, TOutput> CallAsync(
+        IPipelineBuilder<TInput, TOutput> parent,
+        ProcedureAsync<TOutput> next,
+        Action<IPipelineContext> config = null
+    )
     {
         ArgumentNullException.ThrowIfNull( next );
 
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
         return new PipelineBuilder<TInput, TOutput>
         {
-            Function = new CallStatementBinder<TInput, TOutput>( Function, Middleware, config ).Bind( next ),
-            Middleware = Middleware
+            Function = new CallStatementBinder<TInput, TOutput>( parentFunction, parentMiddleware, config ).Bind( next ),
+            Middleware = parentMiddleware
         };
     }
 }
diff --git a/src/Hyperbee.Pipeline/Builders/ForEachBlockBuilder.cs b/src/Hyperbee.Pipeline/Builders/ForEachBlockBuilder.cs
index 384c1bf..2456159 100644
--- a/src/Hyperbee.Pipeline/Builders/ForEachBlockBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/ForEachBlockBuilder.cs
@@ -1,31 +1,49 @@
 using Hyperbee.Pipeline.Binders;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
-public partial interface IPipelineBuilder<TInput, TOutput>
+public static class ForEachBlockBuilder
 {
-    IPipelineBuilder<TInput, TOutput> ForEach<TElement>( Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder> builder );
-    IPipelineBuilder<TInput, TOutput> ForEachAsync<TElement>( bool inheritMiddleware, Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder> builder );
-}
+    public static ForEachBlockBuilderWrapper<TInput, TOutput> ForEach<TInput, TOutput>( this IPipelineBuilder<TInput, TOutput> parent )
+    {
+        return new ForEachBlockBuilderWrapper<TInput, TOutput>( parent );
+    }
 
-public partial class PipelineBuilder<TInput, TOutput>
-{
-    public IPipelineBuilder<TInput, TOutput> ForEach<TElement>( Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder> builder )
+    public class ForEachBlockBuilderWrapper<TInput, TOutput>( IPipelineBuilder<TInput, TOutput> parent )
     {
-        return ForEachAsync( true, builder );
+        public IPipelineBuilder<TInput, TOutput> Type<TElement>( Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder> builder )
+        {
+            return ForEachBlockBuilder<TInput, TOutput, TElement>.ForEach( parent, true, builder );
+        }
+
+        public IPipelineBuilder<TInput, TOutput> Type<TElement>( bool inheritMiddleware, Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder> builder )
+        {
+            return ForEachBlockBuilder<TInput, TOutput, TElement>.ForEach( parent, inheritMiddleware, builder );
+        }
     }
+}
 
-    public IPipelineBuilder<TInput, TOutput> ForEachAsync<TElement>( bool inheritMiddleware, Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder> builder )
+internal static class ForEachBlockBuilder<TInput, TOutput, TElement>
+{
+    public static IPipelineBuilder<TInput, TOutput> ForEach(
+        IPipelineBuilder<TInput, TOutput> parent,
+        bool inheritMiddleware,
+        Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder> builder
+    )
     {
         ArgumentNullException.ThrowIfNull( builder );
 
-        var block = PipelineFactory.Start<TElement>( inheritMiddleware ? Middleware : null );
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
+        var block = PipelineFactory.Start<TElement>( inheritMiddleware ? parentMiddleware : null );
         var function = builder( block ).CastFunction<TElement, object>(); // cast because we don't know the final Pipe output value
 
         return new PipelineBuilder<TInput, TOutput>
         {
-            Function = new ForEachBlockBinder<TInput, TOutput, TElement>( Function ).Bind( function ),
-            Middleware = Middleware
+            Function = new ForEachBlockBinder<TInput, TOutput, TElement>( parentFunction ).Bind( function ),
+            Middleware = parentMiddleware
         };
     }
 }
+
diff --git a/src/Hyperbee.Pipeline/Builders/HookBuilder.cs b/src/Hyperbee.Pipeline/Builders/HookBuilder.cs
index e28d8a7..41ae3ee 100644
--- a/src/Hyperbee.Pipeline/Builders/HookBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/HookBuilder.cs
@@ -1,37 +1,59 @@
 using Hyperbee.Pipeline.Binders;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
-public partial interface IPipelineStartBuilder<TInput, TOutput>
+public static class HookBuilder
 {
-    IPipelineStartBuilder<TInput, TOutput> HookAsync( MiddlewareAsync<object, object> functionMiddleware );
-    IPipelineStartBuilder<TInput, TOutput> HookAsync( IEnumerable<MiddlewareAsync<object, object>> functionMiddleware );
+    public static IPipelineStartBuilder<TInput, TOutput> HookAsync<TInput, TOutput>(
+        this IPipelineStartBuilder<TInput, TOutput> parent,
+        MiddlewareAsync<object, object> functionMiddleware
+    )
+    {
+        return HookBuilder<TInput, TOutput>.HookAsync( parent, functionMiddleware );
+    }
+
+    public static IPipelineStartBuilder<TInput, TOutput> HookAsync<TInput, TOutput>(
+        this IPipelineStartBuilder<TInput, TOutput> parent,
+        IEnumerable<MiddlewareAsync<object, object>> functionMiddleware
+    )
+    {
+        return HookBuilder<TInput, TOutput>.HookAsync( parent, functionMiddleware );
+    }
 }
 
-public partial class PipelineBuilder<TInput, TOutput>
+internal static class HookBuilder<TInput, TOutput>
 {
-    public IPipelineStartBuilder<TInput, TOutput> HookAsync( MiddlewareAsync<object, object> functionMiddleware )
+    public static IPipelineStartBuilder<TInput, TOutput> HookAsync(
+        IPipelineStartBuilder<TInput, TOutput> parent,
+        MiddlewareAsync<object, object> functionMiddleware
+    )
     {
         if ( functionMiddleware == null )
-            return this;
+            return parent;
+
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
 
         return new PipelineBuilder<TInput, TOutput>
         {
-            Function = Function,
-            Middleware = new HookBinder<object, object>( Middleware ).Bind( functionMiddleware )
+            Function = parentFunction,
+            Middleware = new HookBinder<object, object>( parentMiddleware ).Bind( functionMiddleware )
         };
     }
 
-    public IPipelineStartBuilder<TInput, TOutput> HookAsync( IEnumerable<MiddlewareAsync<object, object>> functionMiddleware )
+    public static IPipelineStartBuilder<TInput, TOutput> HookAsync(
+        IPipelineStartBuilder<TInput, TOutput> parent,
+        IEnumerable<MiddlewareAsync<object, object>> functionMiddleware
+    )
     {
         if ( functionMiddleware == null )
-            return this;
+            return parent;
 
-        var builder = this as IPipelineStartBuilder<TInput, TOutput>;
+        var builder = parent;
 
         foreach ( var middleware in functionMiddleware )
         {
-            builder = HookAsync( middleware );
+            builder = HookAsync( parent, middleware );
         }
 
         return builder;
diff --git a/src/Hyperbee.Pipeline/Builders/PipeBlockBuilder.cs b/src/Hyperbee.Pipeline/Builders/PipeBlockBuilder.cs
index 334a28d..aa9adbd 100644
--- a/src/Hyperbee.Pipeline/Builders/PipeBlockBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/PipeBlockBuilder.cs
@@ -1,33 +1,48 @@
 using Hyperbee.Pipeline.Binders;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
-public partial interface IPipelineBuilder<TInput, TOutput>
+public static class PipeBlockBuilderExtensions
 {
-    IPipelineBuilder<TInput, TNext> Pipe<TNext>( Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder );
-    IPipelineBuilder<TInput, TNext> Pipe<TNext>( bool inheritMiddleware, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder );
-}
-
-public partial class PipelineBuilder<TInput, TOutput>
-{
-    // Pipe the result of an inner builder to the next pipeline step. Acts like a Func.
+    public static IPipelineBuilder<TInput, TNext> Pipe<TInput, TOutput, TNext>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder
+    )
+    {
+        return PipeBlockBuilder<TInput, TOutput, TNext>.Pipe( parent, true, builder );
+    }
 
-    public IPipelineBuilder<TInput, TNext> Pipe<TNext>( Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder )
+    public static IPipelineBuilder<TInput, TNext> Pipe<TInput, TOutput, TNext>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        bool inheritMiddleware,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder
+    )
     {
-        return Pipe( true, builder );
+        return PipeBlockBuilder<TInput, TOutput, TNext>.Pipe( parent, inheritMiddleware, builder );
     }
+}
 
-    public IPipelineBuilder<TInput, TNext> Pipe<TNext>( bool inheritMiddleware, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder )
+internal static class PipeBlockBuilder<TInput, TOutput, TNext>
+{
+    public static IPipelineBuilder<TInput, TNext> Pipe(
+        IPipelineBuilder<TInput, TOutput> parent,
+        bool inheritMiddleware,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder
+    )
     {
         ArgumentNullException.ThrowIfNull( builder );
 
-        var block = PipelineFactory.Start<TOutput>( inheritMiddleware ? Middleware : null );
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
+        var block = PipelineFactory.Start<TOutput>( inheritMiddleware ? parentMiddleware : null );
         var function = ((PipelineBuilder<TOutput, TNext>) builder( block )).Function;
 
         return new PipelineBuilder<TInput, TNext>
         {
-            Function = new PipeBlockBinder<TInput, TOutput>( Function ).Bind( function ),
-            Middleware = Middleware
+            Function = new PipeBlockBinder<TInput, TOutput>( parentFunction ).Bind( function ),
+            Middleware = parentMiddleware
         };
     }
 }
+
diff --git a/src/Hyperbee.Pipeline/Builders/PipeIfBlockBuilder.cs b/src/Hyperbee.Pipeline/Builders/PipeIfBlockBuilder.cs
index 311391d..596744e 100644
--- a/src/Hyperbee.Pipeline/Builders/PipeIfBlockBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/PipeIfBlockBuilder.cs
@@ -1,32 +1,51 @@
 using Hyperbee.Pipeline.Binders;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
-public partial interface IPipelineBuilder<TInput, TOutput>
+public static class PipeIfBlockBuilder
 {
-    IPipelineBuilder<TInput, TNext> PipeIf<TNext>( Function<TOutput, bool> condition, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder );
-    IPipelineBuilder<TInput, TNext> PipeIf<TNext>( Function<TOutput, bool> condition, bool inheritMiddleware, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder );
-}
+    public static IPipelineBuilder<TInput, TNext> PipeIf<TInput, TOutput, TNext>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Function<TOutput, bool> condition,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder
+    )
+    {
+        return PipeIfBlockBuilder<TInput, TOutput>.PipeIf( parent, condition, true, builder );
+    }
 
-public partial class PipelineBuilder<TInput, TOutput>
-{
-    public IPipelineBuilder<TInput, TNext> PipeIf<TNext>( Function<TOutput, bool> condition, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder )
+    public static IPipelineBuilder<TInput, TNext> PipeIf<TInput, TOutput, TNext>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Function<TOutput, bool> condition,
+        bool inheritMiddleware,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder
+    )
     {
-        return PipeIf( condition, true, builder );
+        return PipeIfBlockBuilder<TInput, TOutput>.PipeIf( parent, condition, inheritMiddleware, builder );
     }
+}
 
-    public IPipelineBuilder<TInput, TNext> PipeIf<TNext>( Function<TOutput, bool> condition, bool inheritMiddleware, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder )
+internal static class PipeIfBlockBuilder<TInput, TOutput>
+{
+    public static IPipelineBuilder<TInput, TNext> PipeIf<TNext>(
+        IPipelineBuilder<TInput, TOutput> parent,
+        Function<TOutput, bool> condition,
+        bool inheritMiddleware,
+        Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder<TOutput, TNext>> builder
+    )
     {
         ArgumentNullException.ThrowIfNull( builder );
         ArgumentNullException.ThrowIfNull( condition );
 
-        var block = PipelineFactory.Start<TOutput>( inheritMiddleware ? Middleware : null );
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
+        var block = PipelineFactory.Start<TOutput>( inheritMiddleware ? parentMiddleware : null );
         var function = ((PipelineBuilder<TOutput, TNext>) builder( block )).Function;
 
         return new PipelineBuilder<TInput, TNext>
         {
-            Function = new PipeIfBlockBinder<TInput, TOutput>( condition, Function ).Bind( function ),
-            Middleware = Middleware
+            Function = new PipeIfBlockBinder<TInput, TOutput>( condition, parentFunction ).Bind( function ),
+            Middleware = parentMiddleware
         };
     }
 }
diff --git a/src/Hyperbee.Pipeline/Builders/PipeStatementBuilder.cs b/src/Hyperbee.Pipeline/Builders/PipeStatementBuilder.cs
index 146f1da..28f4846 100644
--- a/src/Hyperbee.Pipeline/Builders/PipeStatementBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/PipeStatementBuilder.cs
@@ -1,28 +1,64 @@
 using Hyperbee.Pipeline.Binders;
 using Hyperbee.Pipeline.Context;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
-public partial interface IPipelineBuilder<TInput, TOutput>
+public static class PipeStatementBuilder
 {
-    IPipelineBuilder<TInput, TNext> Pipe<TNext>( Function<TOutput, TNext> next, string name );
-    IPipelineBuilder<TInput, TNext> Pipe<TNext>( Function<TOutput, TNext> next, Action<IPipelineContext> config = null );
-    IPipelineBuilder<TInput, TNext> PipeAsync<TNext>( FunctionAsync<TOutput, TNext> next, string name );
-    IPipelineBuilder<TInput, TNext> PipeAsync<TNext>( FunctionAsync<TOutput, TNext> next, Action<IPipelineContext> config = null );
+    public static IPipelineBuilder<TInput, TNext> Pipe<TInput, TOutput, TNext>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Function<TOutput, TNext> next,
+        string name
+    )
+    {
+        return PipeStatementBuilder<TInput, TOutput>.Pipe( parent, next, config => config.Name = name );
+    }
+
+    public static IPipelineBuilder<TInput, TNext> Pipe<TInput, TOutput, TNext>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Function<TOutput, TNext> next,
+        Action<IPipelineContext> config = null
+    )
+    {
+        return PipeStatementBuilder<TInput, TOutput>.Pipe( parent, next, config );
+    }
+
+    public static IPipelineBuilder<TInput, TNext> PipeAsync<TInput, TOutput, TNext>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        FunctionAsync<TOutput, TNext> next,
+        string name
+    )
+    {
+        return PipeStatementBuilder<TInput, TOutput>.PipeAsync( parent, next, config => config.Name = name );
+    }
+
+    public static IPipelineBuilder<TInput, TNext> PipeAsync<TInput, TOutput, TNext>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        FunctionAsync<TOutput, TNext> next,
+        Action<IPipelineContext> config = null
+    )
+    {
+        return PipeStatementBuilder<TInput, TOutput>.PipeAsync( parent, next, config );
+    }
 }
 
-public partial class PipelineBuilder<TInput, TOutput>
+internal static class PipeStatementBuilder<TInput, TOutput>
 {
-    public IPipelineBuilder<TInput, TNext> Pipe<TNext>( Function<TOutput, TNext> next, string name ) => Pipe( next, config => config.Name = name );
-
-    public IPipelineBuilder<TInput, TNext> Pipe<TNext>( Function<TOutput, TNext> next, Action<IPipelineContext> config = null )
+    public static IPipelineBuilder<TInput, TNext> Pipe<TNext>(
+        IPipelineBuilder<TInput, TOutput> parent,
+        Function<TOutput, TNext> next,
+        Action<IPipelineContext> config = null
+    )
     {
         ArgumentNullException.ThrowIfNull( next );
 
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
         return new PipelineBuilder<TInput, TNext>
         {
-            Function = new PipeStatementBinder<TInput, TOutput>( Function, Middleware, config ).Bind( AsyncNext, next.Method ),
-            Middleware = Middleware
+            Function = new PipeStatementBinder<TInput, TOutput>( parentFunction, parentMiddleware, config ).Bind( AsyncNext, next.Method ),
+            Middleware = parentMiddleware
         };
 
         // task wrapper
@@ -33,16 +69,20 @@ Task<TNext> AsyncNext( IPipelineContext context, TOutput argument )
         }
     }
 
-    public IPipelineBuilder<TInput, TNext> PipeAsync<TNext>( FunctionAsync<TOutput, TNext> next, string name ) => PipeAsync( next, config => config.Name = name );
-
-    public IPipelineBuilder<TInput, TNext> PipeAsync<TNext>( FunctionAsync<TOutput, TNext> next, Action<IPipelineContext> config = null )
+    public static IPipelineBuilder<TInput, TNext> PipeAsync<TNext>(
+        IPipelineBuilder<TInput, TOutput> parent,
+        FunctionAsync<TOutput, TNext> next,
+        Action<IPipelineContext> config = null
+    )
     {
         ArgumentNullException.ThrowIfNull( next );
 
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
         return new PipelineBuilder<TInput, TNext>
         {
-            Function = new PipeStatementBinder<TInput, TOutput>( Function, Middleware, config ).Bind( next ),
-            Middleware = Middleware
+            Function = new PipeStatementBinder<TInput, TOutput>( parentFunction, parentMiddleware, config ).Bind( next ),
+            Middleware = parentMiddleware
         };
     }
 }
diff --git a/src/Hyperbee.Pipeline/Builders/ReduceBlockBuilder.cs b/src/Hyperbee.Pipeline/Builders/ReduceBlockBuilder.cs
index 2910aad..da7dc2c 100644
--- a/src/Hyperbee.Pipeline/Builders/ReduceBlockBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/ReduceBlockBuilder.cs
@@ -1,32 +1,55 @@
 using Hyperbee.Pipeline.Binders;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
-public partial interface IPipelineBuilder<TInput, TOutput>
+public static class ReduceBlockBuilder
 {
-    IPipelineBuilder<TInput, TNext> Reduce<TElement, TNext>( Func<TNext, TNext, TNext> reducer, Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder<TElement, TNext>> builder );
-    IPipelineBuilder<TInput, TNext> ReduceAsync<TElement, TNext>( bool inheritMiddleware, Func<TNext, TNext, TNext> reducer, Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder<TElement, TNext>> builder );
-}
+    public static ReduceBlockBuilderWrapper<TInput, TOutput> Reduce<TInput, TOutput>( this IPipelineBuilder<TInput, TOutput> parent )
+    {
+        return new ReduceBlockBuilderWrapper<TInput, TOutput>( parent );
+    }
 
-public partial class PipelineBuilder<TInput, TOutput>
-{
-    public IPipelineBuilder<TInput, TNext> Reduce<TElement, TNext>( Func<TNext, TNext, TNext> reducer, Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder<TElement, TNext>> builder )
+    public class ReduceBlockBuilderWrapper<TInput, TOutput>( IPipelineBuilder<TInput, TOutput> parent )
     {
-        return ReduceAsync( true, reducer, builder );
+        public IPipelineBuilder<TInput, TNext> Type<TElement, TNext>(
+            Func<TNext, TNext, TNext> reducer,
+            Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder<TElement, TNext>> builder
+        )
+        {
+            return ReduceBlockBuilder<TInput, TOutput, TElement, TNext>.ReduceAsync( parent, true, reducer, builder );
+        }
+
+        public IPipelineBuilder<TInput, TNext> Type<TElement, TNext>(
+            bool inheritMiddleware,
+            Func<TNext, TNext, TNext> reducer,
+            Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder<TElement, TNext>> builder
+        )
+        {
+            return ReduceBlockBuilder<TInput, TOutput, TElement, TNext>.ReduceAsync( parent, inheritMiddleware, reducer, builder );
+        }
     }
+}
 
-    public IPipelineBuilder<TInput, TNext> ReduceAsync<TElement, TNext>( bool inheritMiddleware, Func<TNext, TNext, TNext> reducer, Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder<TElement, TNext>> builder )
+internal static class ReduceBlockBuilder<TInput, TOutput, TElement, TNext>
+{
+    public static IPipelineBuilder<TInput, TNext> ReduceAsync(
+        IPipelineBuilder<TInput, TOutput> parent,
+        bool inheritMiddleware,
+        Func<TNext, TNext, TNext> reducer,
+        Func<IPipelineStartBuilder<TElement, TElement>, IPipelineBuilder<TElement, TNext>> builder )
     {
         ArgumentNullException.ThrowIfNull( builder );
-        ArgumentNullException.ThrowIfNull( reducer );
 
-        var block = PipelineFactory.Start<TElement>( inheritMiddleware ? Middleware : null );
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
+        var block = PipelineFactory.Start<TElement>( inheritMiddleware ? parentMiddleware : null );
         var function = ((PipelineBuilder<TElement, TNext>) builder( block )).Function;
 
         return new PipelineBuilder<TInput, TNext>
         {
-            Function = new ReduceBlockBinder<TInput, TOutput, TElement, TNext>( reducer, Function ).Bind( function ),
-            Middleware = Middleware
+            Function = new ReduceBlockBinder<TInput, TOutput, TElement, TNext>( reducer, parentFunction ).Bind( function ),
+            Middleware = parentMiddleware
         };
     }
 }
diff --git a/src/Hyperbee.Pipeline/Builders/WaitAllBlockBuilder.cs b/src/Hyperbee.Pipeline/Builders/WaitAllBlockBuilder.cs
index 3e8cb82..3e1327a 100644
--- a/src/Hyperbee.Pipeline/Builders/WaitAllBlockBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/WaitAllBlockBuilder.cs
@@ -1,54 +1,85 @@
 using Hyperbee.Pipeline.Binders;
 using Hyperbee.Pipeline.Context;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
 public delegate TOutput WaitAllReducer<in TInput, out TOutput>( IPipelineContext context, TInput input, WaitAllResult[] results );
 
-public partial interface IPipelineBuilder<TInput, TOutput>
+public static class WaitAllBlockBuilder
 {
-    IPipelineBuilder<TInput, TNext> WaitAll<TNext>( Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders, WaitAllReducer<TOutput, TNext> reducer, Action<IPipelineContext> config = null );
-    IPipelineBuilder<TInput, TNext> WaitAll<TNext>( bool inheritMiddleware, Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders, WaitAllReducer<TOutput, TNext> reducer, Action<IPipelineContext> config = null );
-    IPipelineBuilder<TInput, TOutput> WaitAll( Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders, Action<IPipelineContext> config = null );
-    IPipelineBuilder<TInput, TOutput> WaitAll( bool inheritMiddleware, Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders, Action<IPipelineContext> config = null );
+    public static IPipelineBuilder<TInput, TNext> WaitAll<TInput, TOutput, TNext>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
+        WaitAllReducer<TOutput, TNext> reducer,
+        Action<IPipelineContext> config = null )
+    {
+        return WaitAllBlockBuilder<TInput, TOutput>.WaitAll( parent, true, builders, reducer, config );
+    }
+
+    public static IPipelineBuilder<TInput, TNext> WaitAll<TInput, TOutput, TNext>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        bool inheritMiddleware,
+        Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
+        WaitAllReducer<TOutput, TNext> reducer,
+        Action<IPipelineContext> config = null )
+    {
+        return WaitAllBlockBuilder<TInput, TOutput>.WaitAll( parent, inheritMiddleware, builders, reducer, config );
+    }
+
+    public static IPipelineBuilder<TInput, TOutput> WaitAll<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
+        Action<IPipelineContext> config = null )
+    {
+        return WaitAllBlockBuilder<TInput, TOutput>.WaitAll( parent, true, builders, config );
+    }
+
+    public static IPipelineBuilder<TInput, TOutput> WaitAll<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        bool inheritMiddleware,
+        Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
+        Action<IPipelineContext> config = null )
+    {
+        return WaitAllBlockBuilder<TInput, TOutput>.WaitAll( parent, inheritMiddleware, builders, config );
+    }
 }
 
-public partial class PipelineBuilder<TInput, TOutput>
+internal static class WaitAllBlockBuilder<TInput, TOutput>
 {
-    public IPipelineBuilder<TInput, TNext> WaitAll<TNext>(
-        Func<Builders<TOutput, TOutput>,
-            Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
+    public static IPipelineBuilder<TInput, TNext> WaitAll<TNext>(
+        IPipelineBuilder<TInput, TOutput> parent,
+        Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
         WaitAllReducer<TOutput, TNext> reducer,
         Action<IPipelineContext> config = null )
     {
-        return WaitAll( true, builders, reducer, config );
+        return WaitAll( parent, true, builders, reducer, config );
     }
 
-    public IPipelineBuilder<TInput, TOutput> WaitAll(
-        Func<Builders<TOutput, TOutput>,
-            Func<IPipelineStartBuilder<TOutput, TOutput>,
-                IPipelineBuilder>[]> builders,
+    public static IPipelineBuilder<TInput, TOutput> WaitAll(
+        IPipelineBuilder<TInput, TOutput> parent,
+        Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
         Action<IPipelineContext> config = null )
     {
-        return WaitAll( true, builders, config );
+        return WaitAll( parent, true, builders, config );
     }
 
-    public IPipelineBuilder<TInput, TOutput> WaitAll(
+    public static IPipelineBuilder<TInput, TOutput> WaitAll(
+        IPipelineBuilder<TInput, TOutput> parent,
         bool inheritMiddleware,
-        Func<Builders<TOutput, TOutput>,
-            Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
+        Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
         Action<IPipelineContext> config = null )
     {
-        return WaitAll( true, builders, DefaultReducer, config );
+        return WaitAll( parent, inheritMiddleware, builders, DefaultReducer, config );
 
         // create a default reducer that returns the arg from the previous step
         static TOutput DefaultReducer( IPipelineContext ctx, TOutput arg, WaitAllResult[] results ) => arg;
     }
 
-    public IPipelineBuilder<TInput, TNext> WaitAll<TNext>(
+    public static IPipelineBuilder<TInput, TNext> WaitAll<TNext>(
+        IPipelineBuilder<TInput, TOutput> parent,
         bool inheritMiddleware,
-        Func<Builders<TOutput, TOutput>,
-            Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
+        Func<Builders<TOutput, TOutput>, Func<IPipelineStartBuilder<TOutput, TOutput>, IPipelineBuilder>[]> builders,
         WaitAllReducer<TOutput, TNext> reducer,
         Action<IPipelineContext> config = null )
     {
@@ -59,15 +90,17 @@ public IPipelineBuilder<TInput, TNext> WaitAll<TNext>(
         if ( builderInstances.Length == 0 )
             throw new ArgumentOutOfRangeException( nameof( builders ) );
 
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
+
         var functions = builderInstances
-            .Select( builder => new { builder, block = PipelineFactory.Start<TOutput>( inheritMiddleware ? Middleware : null ) } )
+            .Select( builder => new { builder, block = PipelineFactory.Start<TOutput>( inheritMiddleware ? parentMiddleware : null ) } )
             .Select( x => x.builder( x.block ).CastFunction<TOutput, object>() )
             .ToArray();
 
         return new PipelineBuilder<TInput, TNext>
         {
-            Function = new WaitAllBlockBinder<TInput, TOutput>( Function, Middleware, config ).Bind( functions, reducer ),
-            Middleware = Middleware
+            Function = new WaitAllBlockBinder<TInput, TOutput>( parentFunction, parentMiddleware, config ).Bind( functions, reducer ),
+            Middleware = parentMiddleware
         };
     }
 }
diff --git a/src/Hyperbee.Pipeline/Builders/WrapBuilder.cs b/src/Hyperbee.Pipeline/Builders/WrapBuilder.cs
index 8e292e4..d3b91fe 100644
--- a/src/Hyperbee.Pipeline/Builders/WrapBuilder.cs
+++ b/src/Hyperbee.Pipeline/Builders/WrapBuilder.cs
@@ -1,41 +1,73 @@
 using Hyperbee.Pipeline.Binders;
 using Hyperbee.Pipeline.Context;
+using Hyperbee.Pipeline.Extensions.Implementation;
 
 namespace Hyperbee.Pipeline;
 
-public partial interface IPipelineBuilder<TInput, TOutput>
+public static class WrapBuilder
 {
-    IPipelineBuilder<TInput, TOutput> WrapAsync( MiddlewareAsync<TInput, TOutput> pipelineMiddleware, string name );
-    IPipelineBuilder<TInput, TOutput> WrapAsync( MiddlewareAsync<TInput, TOutput> pipelineMiddleware, Action<IPipelineContext> config = null );
-    IPipelineBuilder<TInput, TOutput> WrapAsync( IEnumerable<MiddlewareAsync<TInput, TOutput>> pipelineMiddleware, Action<IPipelineContext> config = null );
+    public static IPipelineBuilder<TInput, TOutput> WrapAsync<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        MiddlewareAsync<TInput, TOutput> pipelineMiddleware,
+        string name
+    )
+    {
+        return WrapBuilder<TInput, TOutput>.WrapAsync( parent, pipelineMiddleware, config => config.Name = name );
+    }
+
+    public static IPipelineBuilder<TInput, TOutput> WrapAsync<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        MiddlewareAsync<TInput, TOutput> pipelineMiddleware,
+        Action<IPipelineContext> config = null
+    )
+    {
+        return WrapBuilder<TInput, TOutput>.WrapAsync( parent, pipelineMiddleware, config );
+    }
+
+    public static IPipelineBuilder<TInput, TOutput> WrapAsync<TInput, TOutput>(
+        this IPipelineBuilder<TInput, TOutput> parent,
+        IEnumerable<MiddlewareAsync<TInput, TOutput>> pipelineMiddleware,
+        Action<IPipelineContext> config = null
+    )
+    {
+        return WrapBuilder<TInput, TOutput>.WrapAsync( parent, pipelineMiddleware, config );
+    }
 }
 
-public partial class PipelineBuilder<TInput, TOutput>
+internal static class WrapBuilder<TInput, TOutput>
 {
-    public IPipelineBuilder<TInput, TOutput> WrapAsync( MiddlewareAsync<TInput, TOutput> pipelineMiddleware, string name ) => WrapAsync( pipelineMiddleware, config => config.Name = name );
-
-    public IPipelineBuilder<TInput, TOutput> WrapAsync( MiddlewareAsync<TInput, TOutput> pipelineMiddleware, Action<IPipelineContext> config = null )
+    public static IPipelineBuilder<TInput, TOutput> WrapAsync(
+        IPipelineBuilder<TInput, TOutput> parent,
+        MiddlewareAsync<TInput, TOutput> pipelineMiddleware,
+        Action<IPipelineContext> config = null
+    )
     {
         if ( pipelineMiddleware == null )
-            return this;
+            return parent;
+
+        var (parentFunction, parentMiddleware) = parent.GetPipelineFunction();
 
         return new PipelineBuilder<TInput, TOutput>
         {
-            Function = new WrapBinder<TInput, TOutput>( pipelineMiddleware, config ).Bind( Function ),
-            Middleware = Middleware
+            Function = new WrapBinder<TInput, TOutput>( pipelineMiddleware, config ).Bind( parentFunction ),
+            Middleware = parentMiddleware
         };
     }
 
-    public IPipelineBuilder<TInput, TOutput> WrapAsync( IEnumerable<MiddlewareAsync<TInput, TOutput>> pipelineMiddleware, Action<IPipelineContext> config = null )
+    public static IPipelineBuilder<TInput, TOutput> WrapAsync(
+        IPipelineBuilder<TInput, TOutput> parent,
+        IEnumerable<MiddlewareAsync<TInput, TOutput>> pipelineMiddleware,
+        Action<IPipelineContext> config = null
+    )
     {
         if ( pipelineMiddleware == null )
-            return this;
+            return parent;
 
-        var builder = this as IPipelineBuilder<TInput, TOutput>;
+        var builder = parent;
 
         foreach ( var middleware in pipelineMiddleware )
         {
-            builder = WrapAsync( middleware, config );
+            builder = WrapAsync( parent, middleware, config );
         }
 
         return builder;
diff --git a/src/Hyperbee.Pipeline/IPipelineBuilder.cs b/src/Hyperbee.Pipeline/IPipelineBuilder.cs
index eb7120f..86b2c1c 100644
--- a/src/Hyperbee.Pipeline/IPipelineBuilder.cs
+++ b/src/Hyperbee.Pipeline/IPipelineBuilder.cs
@@ -33,12 +33,12 @@ public struct Empty;
 // 
 // we solve for this using interfaces.
 
-public partial interface IPipelineStartBuilder<TInput, TOutput> : IPipelineBuilder<TInput, TOutput>
+public interface IPipelineStartBuilder<in TInput, TOutput> : IPipelineBuilder<TInput, TOutput>
 {
     // head actions: (e.g. Hook) that are only valid at the start of the pipeline 
 }
 
-public partial interface IPipelineBuilder<TInput, TOutput> : IPipelineFinalBuilder<TInput, TOutput>
+public interface IPipelineBuilder<in TInput, TOutput> : IPipelineFinalBuilder<TInput, TOutput>
 {
     // normal actions
 }
diff --git a/src/Hyperbee.Pipeline/IPipelineFunction.cs b/src/Hyperbee.Pipeline/IPipelineFunction.cs
index be6f538..e4b6b04 100644
--- a/src/Hyperbee.Pipeline/IPipelineFunction.cs
+++ b/src/Hyperbee.Pipeline/IPipelineFunction.cs
@@ -1,14 +1,20 @@
 namespace Hyperbee.Pipeline;
 
-public interface IPipelineFunctionProvider<in TInput, TOutput>
+public interface IPipelineFunctionProvider<TInput, TOutput>
 {
     // Provide access to the Function and the Middleware
     // so people can implement their own custom binders.
     IPipelineFunction<TInput, TOutput> GetPipelineFunction();
 }
 
-public interface IPipelineFunction<in TInput, TOutput>
+public interface IPipelineFunction<TInput, TOutput>
 {
     FunctionAsync<TInput, TOutput> Function { get; }
     MiddlewareAsync<object, object> Middleware { get; }
+
+    void Deconstruct( out FunctionAsync<TInput, TOutput> function, out MiddlewareAsync<object, object> middleware )
+    {
+        function = Function;
+        middleware = Middleware;
+    }
 }
diff --git a/src/Hyperbee.Pipeline/PipelineBuilder.cs b/src/Hyperbee.Pipeline/PipelineBuilder.cs
index 1323464..2dfe12d 100644
--- a/src/Hyperbee.Pipeline/PipelineBuilder.cs
+++ b/src/Hyperbee.Pipeline/PipelineBuilder.cs
@@ -2,7 +2,7 @@
 
 namespace Hyperbee.Pipeline;
 
-public partial class PipelineBuilder<TInput, TOutput> : PipelineFactory, IPipelineStartBuilder<TInput, TOutput>, IPipelineFunctionProvider<TInput, TOutput>
+public class PipelineBuilder<TInput, TOutput> : PipelineFactory, IPipelineStartBuilder<TInput, TOutput>, IPipelineFunctionProvider<TInput, TOutput>
 {
     internal FunctionAsync<TInput, TOutput> Function { get; init; }
     internal MiddlewareAsync<object, object> Middleware { get; init; }
@@ -67,7 +67,7 @@ FunctionAsync<TIn, TOut> IPipelineBuilder.CastFunction<TIn, TOut>()
         static TType Cast<TType>( object value ) => (TType) value;
     }
 
-    // custom builder and binders need access to Function and Middleware
+    // custom builders and binders need access to Function and Middleware
     IPipelineFunction<TInput, TOutput> IPipelineFunctionProvider<TInput, TOutput>.GetPipelineFunction()
     {
         return new PipelineFunction
@@ -81,11 +81,5 @@ public record PipelineFunction : IPipelineFunction<TInput, TOutput>
     {
         public FunctionAsync<TInput, TOutput> Function { get; init; }
         public MiddlewareAsync<object, object> Middleware { get; init; }
-
-        public void Deconstruct( out FunctionAsync<TInput, TOutput> function, out MiddlewareAsync<object, object> middleware )
-        {
-            function = Function;
-            middleware = Middleware;
-        }
     }
 }
diff --git a/test/Hyperbee.Pipeline.Tests/PipelineEnumerationTests.cs b/test/Hyperbee.Pipeline.Tests/PipelineEnumerationTests.cs
index d76adef..6eb7a07 100644
--- a/test/Hyperbee.Pipeline.Tests/PipelineEnumerationTests.cs
+++ b/test/Hyperbee.Pipeline.Tests/PipelineEnumerationTests.cs
@@ -44,7 +44,7 @@ public async Task Pipeline_should_enumerate()
         var command = PipelineFactory
             .Start<string>()
             .Pipe( ( ctx, arg ) => arg.Split( ' ' ) )
-            .ForEach<string>( builder => builder
+            .ForEach().Type<string>( builder => builder
                 .Pipe( ( ctx, arg ) => arg + "!" )
                 .Pipe( ( ctx, arg ) => count += 10 )
             )
@@ -62,7 +62,7 @@ public async Task Pipeline_should_reduce()
         var command = PipelineFactory
             .Start<string>()
             .Pipe( ( ctx, arg ) => arg.Split( ' ' ) )
-            .Reduce<string, int>( ( a, v ) => a + v, builder => builder
+            .Reduce().Type<string, int>( ( a, v ) => a + v, builder => builder
                 .Pipe( ( ctx, arg ) => int.Parse( arg ) + 10 )
             )
             .Pipe( ( ctx, arg ) => arg + 5 )