From 58e8e29f16d7b3240f04dfa8c32df0c803cba3b1 Mon Sep 17 00:00:00 2001
From: doomchild <lee.crabtree@gmail.com>
Date: Sun, 14 May 2023 12:53:49 -0500
Subject: [PATCH 1/2] Changed IfFulfilled/IfFaulted to chain instead of
 awaiting

---
 src/TaskExtensions.cs | 60 +++++++++++++++++++++++--------------------
 1 file changed, 32 insertions(+), 28 deletions(-)

diff --git a/src/TaskExtensions.cs b/src/TaskExtensions.cs
index 460ad28..d19d106 100644
--- a/src/TaskExtensions.cs
+++ b/src/TaskExtensions.cs
@@ -122,11 +122,6 @@ public static Task<T> ExceptionMap<T>(this Task<T> task, Func<Exception, Task<Ex
       ? Task.FromException<T>(await onFaulted(PotentiallyUnwindException(continuationTask.Exception)))
       : continuationTask
     ).Unwrap().Unwrap();
-    // => task.BiBind<T, T>(
-    //   //Pipe2<Exception, Task<Exception>, Task<T>>(onFaulted, Task.FromException<T>),
-    //   async ex => Task.FromException<T>(await onFaulted(ex)),
-    //   Pipe2(Identity, Task.FromResult)
-    // );
 
   /// <summary>
   /// Allows a fulfilled <see name="Task{T}"/> to be transitioned to a faulted one if the <paramref name="predicate"/>
@@ -369,16 +364,19 @@ public static Task<T> IfFulfilled<T>(this Task<T> task, Action<T> consumer)
   /// <param name="func">The function to execute if the task is fulfilled.</param>
   /// <returns>The task.</returns>
   public static Task<T> IfFulfilled<T, R>(this Task<T> task, Func<T, Task<R>> func)
-    => task.ResultMap(async value =>
+    => task.ContinueWith(async continuationTask =>
     {
-      try
+      if (continuationTask.IsFaulted)
       {
-        await func(value);
+        return continuationTask;
       }
-      catch { }
+      else
+      {
+        T value = await continuationTask;
 
-      return value;
-    }).Unwrap();
+        return Task.FromResult(value).Then(func).Then(_ => value, _ => value);
+      }
+    }).Unwrap().Unwrap();
 
   /// <summary>
   /// Executes a function and throws away the result if the <see name="Task{T}"/> is in a fulfilled state.
@@ -389,7 +387,7 @@ public static Task<T> IfFulfilled<T, R>(this Task<T> task, Func<T, Task<R>> func
   /// <param name="func">The function to execute if the task is fulfilled.</param>
   /// <returns>The task.</returns>
   public static Task<T> IfFulfilled<T>(this Task<T> task, Func<T, Task> func)
-    => task.ResultMap(TaskStatics.Tap(func)).Unwrap();
+    => task.IfFulfilled<T, T>(value => Task.FromResult(value).Then(func).Then(_ => value, _ => value));
 
   /// <summary>
   /// Performs an action if the <see name="Task{T}"/> is in a faulted state.
@@ -404,31 +402,37 @@ public static Task<T> IfFaulted<T>(this Task<T> task, Action<Exception> onFaulte
   /// Executes a function and throws away the result if the <see name="Task{T}"/> is in a faulted state.
   /// </summary>
   /// <typeparam name="T">The task's underlying type.</typeparam>
+  /// <typeparam name="R">The output task's underlying type.</typeparam>
   /// <param name="onFaulted">The function to execute if the task is faulted.</param>
   /// <returns>The task.</returns>
   public static Task<T> IfFaulted<T, R>(this Task<T> task, Func<Exception, Task<R>> onFaulted)
-    => task.ExceptionMap(async exception =>
+    => task.ContinueWith(continuationTask =>
     {
-      try
+      if (continuationTask.IsFaulted)
       {
-        await onFaulted(exception);
+        Exception taskException = PotentiallyUnwindException(continuationTask.Exception!);
+
+        return Task.FromException<R>(PotentiallyUnwindException(continuationTask.Exception!))
+          .Catch<R>(ex => onFaulted(ex))
+          .Then(
+            _ => Task.FromException<T>(taskException),
+            _ => Task.FromException<T>(taskException)
+          );
       }
-      catch { }
-
-      return exception;
-    });
-
-  public static Task<T> IfFaulted<T>(this Task<T> task, Func<Exception, Task> onFaulted)
-    => task.ExceptionMap(async exception =>
-    {
-      try
+      else
       {
-        await onFaulted(exception);
+        return continuationTask;
       }
-      catch { }
+    }).Unwrap();
 
-      return exception;
-    });
+  /// <summary>
+  /// Executes a function and throws away the result if the <see name="Task{T}"/> is in a faulted state.
+  /// </summary>
+  /// <typeparam name="T">The task's underlying type.</typeparam>
+  /// <param name="onFaulted">The function to execute if the task is faulted.</param>
+  /// <returns>The task.</returns>
+  public static Task<T> IfFaulted<T>(this Task<T> task, Func<Exception, Task> onFaulted)
+    => task.IfFaulted<T, T>(exception => onFaulted(exception).ContinueWith(continuationTask => Task.FromException<T>(exception)).Unwrap());
 
   public static Task<TNext> Retry<T, TNext>(
     this Task<T> task,

From 88bc8ae047b65148b931d63ef1efad387e653413 Mon Sep 17 00:00:00 2001
From: doomchild <lee.crabtree@gmail.com>
Date: Sun, 14 May 2023 13:20:38 -0500
Subject: [PATCH 2/2] Updated package version to 2.14.0

---
 project-metadata.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project-metadata.json b/project-metadata.json
index 31b6e86..de929d6 100644
--- a/project-metadata.json
+++ b/project-metadata.json
@@ -2,7 +2,7 @@
   "name": "task-chaining",
   "description": "Extension methods to System.Threading.Task to allow Promise-like chaining",
   "title": "TaskChaining",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "ciEnvironment": {
     "variables": [
       {