CSharpFunctionalExtensions by Vladimir Khorikov

<PackageReference Include="CSharpFunctionalExtensions" Version="1.7.1" />

---

API Diff between 1.7.1 and 2.40.2

36 Additions 1056 Removals

CSharpFunctionalExtensions

• public static class AsyncMaybeExtensions
  • public static Task<Result<T>> ToResult<T>(this Task<Maybe<T>> maybeTask, string errorMessage)
• public static class AsyncResultExtensionsBothOperands
  • public static Task<Result<K, E>> Bind<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<K>> Bind<T, K>(this Task<Result<T>> resultTask, Func<T, Task<Result<K>>> func)
  • public static Task<Result<K>> Bind<K>(this Task<Result> resultTask, Func<Task<Result<K>>> func)
  • public static Task<Result> Bind<T>(this Task<Result<T>> resultTask, Func<T, Task<Result>> func)
  • public static Task<Result> Bind(this Task<Result> resultTask, Func<Task<Result>> func)
  • public static Task<UnitResult<E>> Bind<E>(this Task<UnitResult<E>> resultTask, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T, E>> Bind<T, E>(this Task<UnitResult<E>> resultTask, Func<Task<Result<T, E>>> func)
  • public static Task<UnitResult<E>> Bind<T, E>(this Task<Result<T, E>> resultTask, Func<T, Task<UnitResult<E>>> func)
  • public static Task<Result> BindTry(this Task<Result> resultTask, Func<Task<Result>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> BindTry<K>(this Task<Result> resultTask, Func<Task<Result<K>>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result> BindTry<T>(this Task<Result<T>> resultTask, Func<T, Task<Result>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> BindTry<T, K>(this Task<Result<T>> resultTask, Func<T, Task<Result<K>>> func, Func<Exception, string> errorHandler = null)
  • public static Task<UnitResult<E>> BindTry<T, E>(this Task<Result<T, E>> resultTask, Func<T, Task<UnitResult<E>>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<K, E>> BindTry<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Task<Result<K, E>>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> BindTry<T, E>(this Task<UnitResult<E>> resultTask, Func<Task<Result<T, E>>> func, Func<Exception, E> errorHandler)
  • public static Task<UnitResult<E>> BindTry<E>(this Task<UnitResult<E>> resultTask, Func<Task<UnitResult<E>>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T>> Check<T>(this Task<Result<T>> resultTask, Func<T, Task<Result>> func)
  • public static Task<Result<T>> Check<T, K>(this Task<Result<T>> resultTask, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> Check<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<T, E>> Check<T, E>(this Task<Result<T, E>> resultTask, Func<T, Task<UnitResult<E>>> func)
  • public static Task<UnitResult<E>> Check<E>(this Task<UnitResult<E>> resultTask, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T>> CheckIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Task<Result>> func)
  • public static Task<Result<T>> CheckIf<T, K>(this Task<Result<T>> resultTask, bool condition, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> CheckIf<T, K, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<T, E>> CheckIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Task<UnitResult<E>>> func)
  • public static Task<UnitResult<E>> CheckIf<E>(this Task<UnitResult<E>> resultTask, bool condition, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T>> CheckIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task<Result>> func)
  • public static Task<Result<T>> CheckIf<T, K>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> CheckIf<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<T, E>> CheckIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Task<UnitResult<E>>> func)
  • public static Task<UnitResult<E>> CheckIf<E>(this Task<UnitResult<E>> resultTask, Func<bool> predicate, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T, E>> Ensure<T, E>(this Task<Result<T, E>> resultTask, Func<T, Task<bool>> predicate, E error)
  • public static Task<Result<T, E>> Ensure<T, E>(this Task<Result<T, E>> resultTask, Func<T, Task<bool>> predicate, Func<T, E> errorPredicate)
  • public static Task<Result<T, E>> Ensure<T, E>(this Task<Result<T, E>> resultTask, Func<T, Task<bool>> predicate, Func<T, Task<E>> errorPredicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<T, Task<bool>> predicate, Func<T, string> errorPredicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<T, Task<bool>> predicate, Func<T, Task<string>> errorPredicate)
  • public static Task<Result> Ensure(this Task<Result> resultTask, Func<Task<Result>> predicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<Task<Result>> predicate)
  • public static Task<Result> Ensure<T>(this Task<Result> resultTask, Func<Task<Result<T>>> predicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<Task<Result<T>>> predicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<T, Task<Result>> predicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<T, Task<Result<T>>> predicate)
  • public static Task<T> Finally<T>(this Task<Result> resultTask, Func<Result, Task<T>> func)
  • public static Task<K> Finally<T, K>(this Task<Result<T>> resultTask, Func<Result<T>, Task<K>> func)
  • public static Task<K> Finally<K, E>(this Task<UnitResult<E>> resultTask, Func<UnitResult<E>, Task<K>> func)
  • public static Task<K> Finally<T, K, E>(this Task<Result<T, E>> resultTask, Func<Result<T, E>, Task<K>> func)
  • public static Task<Result<K, E>> Map<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Task<K>> func)
  • public static Task<Result<K, E>> Map<K, E>(this Task<UnitResult<E>> resultTask, Func<Task<K>> func)
  • public static Task<Result<K>> Map<K>(this Task<Result> resultTask, Func<Task<K>> func)
  • public static Task<Result<K, E>> MapTry<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Task<K>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<K, E>> MapTry<K, E>(this Task<UnitResult<E>> resultTask, Func<Task<K>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<K>> MapTry<T, K>(this Task<Result<T>> resultTask, Func<T, Task<K>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> MapTry<K>(this Task<Result> resultTask, Func<Task<K>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> Map<T>(this Task<Result> resultTask, Func<Task<T>> func)
  • public static Task<K> OnBoth<T, K, E>(this Task<Result<T, E>> resultTask, Func<Result<T, E>, Task<K>> func)
  • public static Task<Result<T, E>> OnFailureCompensate<T, E>(this Task<Result<T, E>> resultTask, Func<Task<Result<T, E>>> func)
  • public static Task<Result<T>> OnFailureCompensate<T>(this Task<Result<T>> resultTask, Func<Task<Result<T>>> func)
  • public static Task<Result> OnFailureCompensate(this Task<Result> resultTask, Func<Task<Result>> func)
  • public static Task<Result<T>> OnFailureCompensate<T>(this Task<Result<T>> resultTask, Func<string, Task<Result<T>>> func)
  • public static Task<Result<T, E>> OnFailureCompensate<T, E>(this Task<Result<T, E>> resultTask, Func<E, Task<Result<T, E>>> func)
  • public static Task<Result> OnFailureCompensate(this Task<Result> resultTask, Func<string, Task<Result>> func)
  • public static Task<Result<K, E>> OnSuccess<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Task<K>> func)
  • public static Task<Result<T>> OnFailure<T>(this Task<Result<T>> resultTask, Func<Task> func)
  • public static Task<Result> OnFailure(this Task<Result> resultTask, Func<Task> func)
  • public static Task<Result<T>> OnFailure<T>(this Task<Result<T>> resultTask, Func<string, Task> func)
  • public static Task<Result<K>> OnSuccess<K>(this Task<Result> resultTask, Func<Task<K>> func)
  • public static Task<Result<K, E>> OnSuccess<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<T>> OnSuccess<T>(this Task<Result> resultTask, Func<Task<T>> func)
  • public static Task<Result<K>> OnSuccess<K>(this Task<Result> resultTask, Func<Task<Result<K>>> func)
  • public static Task<Result<T>> OnSuccess<T>(this Task<Result> resultTask, Func<Task<Result<T>>> func)
  • public static Task<Result<K>> OnSuccess<T, K>(this Task<Result<T>> resultTask, Func<Task<Result<K>>> func)
  • public static Task<Result<T, E>> OnSuccess<T, E>(this Task<Result<T, E>> resultTask, Func<T, Task> action)
  • public static Task<Result> Tap(this Task<Result> resultTask, Func<Task> func)
  • public static Task<Result<T>> Tap<T>(this Task<Result<T>> resultTask, Func<Task> func)
  • public static Task<Result<T>> Tap<T>(this Task<Result<T>> resultTask, Func<T, Task> func)
  • public static Task<UnitResult<E>> Tap<E>(this Task<UnitResult<E>> resultTask, Func<Task> func)
  • public static Task<Result<T, E>> Tap<T, E>(this Task<Result<T, E>> resultTask, Func<Task> func)
  • public static Task<Result<T, E>> Tap<T, E>(this Task<Result<T, E>> resultTask, Func<T, Task> func)
  • public static Task<Result<T>> Tap<T>(this Task<Result<T>> resultTask, Func<T, Task<Result>> func)
  • public static Task<Result<T>> Tap<T, K>(this Task<Result<T>> resultTask, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> Tap<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result> TapIf(this Task<Result> resultTask, bool condition, Func<Task> func)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, bool condition, Func<Task> func)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Task> func)
  • public static Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<Task> func)
  • public static Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Task> func)
  • public static Task<UnitResult<E>> TapIf<E>(this Task<UnitResult<E>> resultTask, bool condition, Func<Task> func)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<Task> func)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task> func)
  • public static Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<Task> func)
  • public static Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Task> func)
  • public static Task<UnitResult<E>> TapIf<E>(this Task<UnitResult<E>> resultTask, Func<bool> predicate, Func<Task> func)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Task<Result>> func)
  • public static Task<Result<T>> TapIf<T, K>(this Task<Result<T>> resultTask, bool condition, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> TapIf<T, K, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task<Result>> func)
  • public static Task<Result<T>> TapIf<T, K>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> TapIf<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result> TapIfTry(this Task<Result> resultTask, bool condition, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> TapIfTry<T>(this Task<Result<T>> resultTask, bool condition, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> TapIfTry<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<UnitResult<E>> TapIfTry<E>(this Task<UnitResult<E>> resultTask, bool condition, Func<Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T>> TapIfTry<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> TapIfTry<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result> TapTry(this Task<Result> resultTask, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> TapTry<T>(this Task<Result<T>> resultTask, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> TapTry<T>(this Task<Result<T>> resultTask, Func<T, Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<UnitResult<E>> TapTry<E>(this Task<UnitResult<E>> resultTask, Func<Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapTry<T, E>(this Task<Result<T, E>> resultTask, Func<Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapTry<T, E>(this Task<Result<T, E>> resultTask, Func<T, Task> func, Func<Exception, E> errorHandler)
• public static class AsyncResultExtensionsLeftOperand
  • public static Task<Result<K, E>> Bind<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Result<K, E>> func)
  • public static Task<Result<K>> Bind<T, K>(this Task<Result<T>> resultTask, Func<T, Result<K>> func)
  • public static Task<Result<K>> Bind<K>(this Task<Result> resultTask, Func<Result<K>> func)
  • public static Task<Result> Bind<T>(this Task<Result<T>> resultTask, Func<T, Result> func)
  • public static Task<Result> Bind(this Task<Result> resultTask, Func<Result> func)
  • public static Task<UnitResult<E>> Bind<E>(this Task<UnitResult<E>> resultTask, Func<UnitResult<E>> func)
  • public static Task<Result<T, E>> Bind<T, E>(this Task<UnitResult<E>> resultTask, Func<Result<T, E>> func)
  • public static Task<UnitResult<E>> Bind<T, E>(this Task<Result<T, E>> resultTask, Func<T, UnitResult<E>> func)
  • public static Task<Result> BindTry(this Task<Result> resultTask, Func<Result> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> BindTry<K>(this Task<Result> resultTask, Func<Result<K>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result> BindTry<T>(this Task<Result<T>> resultTask, Func<T, Result> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> BindTry<T, K>(this Task<Result<T>> resultTask, Func<T, Result<K>> func, Func<Exception, string> errorHandler = null)
  • public static Task<UnitResult<E>> BindTry<T, E>(this Task<Result<T, E>> resultTask, Func<T, UnitResult<E>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<K, E>> BindTry<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Result<K, E>> func, Func<Exception, E> errorHandler)
  • public static Task<UnitResult<E>> BindTry<E>(this Task<UnitResult<E>> resultTask, Func<UnitResult<E>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> BindTry<T, E>(this Task<UnitResult<E>> resultTask, Func<Result<T, E>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T>> Check<T>(this Task<Result<T>> resultTask, Func<T, Result> func)
  • public static Task<Result<T>> Check<T, K>(this Task<Result<T>> resultTask, Func<T, Result<K>> func)
  • public static Task<Result<T, E>> Check<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Result<K, E>> func)
  • public static Task<Result<T, E>> Check<T, E>(this Task<Result<T, E>> resultTask, Func<T, UnitResult<E>> func)
  • public static Task<UnitResult<E>> Check<E>(this Task<UnitResult<E>> resultTask, Func<UnitResult<E>> func)
  • public static Task<Result<T>> CheckIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Result> func)
  • public static Task<Result<T>> CheckIf<T, K>(this Task<Result<T>> resultTask, bool condition, Func<T, Result<K>> func)
  • public static Task<Result<T, E>> CheckIf<T, K, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Result<K, E>> func)
  • public static Task<Result<T, E>> CheckIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, UnitResult<E>> func)
  • public static Task<UnitResult<E>> CheckIf<E>(this Task<UnitResult<E>> resultTask, bool condition, Func<UnitResult<E>> func)
  • public static Task<Result<T>> CheckIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Result> func)
  • public static Task<Result<T>> CheckIf<T, K>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Result<K>> func)
  • public static Task<Result<T, E>> CheckIf<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Result<K, E>> func)
  • public static Task<Result<T, E>> CheckIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, UnitResult<E>> func)
  • public static Task<UnitResult<E>> CheckIf<E>(this Task<UnitResult<E>> resultTask, Func<bool> predicate, Func<UnitResult<E>> func)
  • public static Task<Result> Combine(this IEnumerable<Task<Result>> tasks, string errorMessageSeparator = null)
  • public static Task<Result<IEnumerable<T>, E>> Combine<T, E>(this IEnumerable<Task<Result<T, E>>> tasks, Func<IEnumerable<E>, E> composerError)
  • public static Task<Result<IEnumerable<T>, E>> Combine<T, E>(this IEnumerable<Task<Result<T, E>>> tasks) where E : ICombine
  • public static Task<Result<IEnumerable<T>>> Combine<T>(this IEnumerable<Task<Result<T>>> tasks, string errorMessageSeparator = null)
  • public static Task<Result> Combine(this Task<IEnumerable<Result>> task, string errorMessageSeparator = null)
  • public static Task<Result<IEnumerable<T>, E>> Combine<T, E>(this Task<IEnumerable<Result<T, E>>> task, Func<IEnumerable<E>, E> composerError)
  • public static Task<Result<IEnumerable<T>, E>> Combine<T, E>(this Task<IEnumerable<Result<T, E>>> task) where E : ICombine
  • public static Task<Result<IEnumerable<T>>> Combine<T>(this Task<IEnumerable<Result<T>>> task, string errorMessageSeparator = null)
  • public static Task<Result> Combine(this Task<IEnumerable<Task<Result>>> task, string errorMessageSeparator = null)
  • public static Task<Result<IEnumerable<T>, E>> Combine<T, E>(this Task<IEnumerable<Task<Result<T, E>>>> task, Func<IEnumerable<E>, E> composerError)
  • public static Task<Result<IEnumerable<T>, E>> Combine<T, E>(this Task<IEnumerable<Task<Result<T, E>>>> task) where E : ICombine
  • public static Task<Result<IEnumerable<T>>> Combine<T>(this Task<IEnumerable<Task<Result<T>>>> task, string errorMessageSeparator = null)
  • public static Task<Result<K, E>> Combine<T, K, E>(this IEnumerable<Task<Result<T, E>>> tasks, Func<IEnumerable<T>, K> composer, Func<IEnumerable<E>, E> composerError)
  • public static Task<Result<K, E>> Combine<T, K, E>(this IEnumerable<Task<Result<T, E>>> tasks, Func<IEnumerable<T>, K> composer) where E : ICombine
  • public static Task<Result<K>> Combine<T, K>(this IEnumerable<Task<Result<T>>> tasks, Func<IEnumerable<T>, K> composer, string errorMessageSeparator = null)
  • public static Task<Result<K, E>> Combine<T, K, E>(this Task<IEnumerable<Task<Result<T, E>>>> task, Func<IEnumerable<T>, K> composer, Func<IEnumerable<E>, E> composerError)
  • public static Task<Result<K, E>> Combine<T, K, E>(this Task<IEnumerable<Task<Result<T, E>>>> task, Func<IEnumerable<T>, K> composer) where E : ICombine
  • public static Task<Result<K>> Combine<T, K>(this Task<IEnumerable<Task<Result<T>>>> task, Func<IEnumerable<T>, K> composer, string errorMessageSeparator = null)
  • public static Task<Result> CombineInOrder(this IEnumerable<Task<Result>> tasks, string errorMessageSeparator = null)
  • public static Task<Result<IEnumerable<T>, E>> CombineInOrder<T, E>(this IEnumerable<Task<Result<T, E>>> tasks, Func<IEnumerable<E>, E> composerError)
  • public static Task<Result<IEnumerable<T>, E>> CombineInOrder<T, E>(this IEnumerable<Task<Result<T, E>>> tasks) where E : ICombine
  • public static Task<Result<IEnumerable<T>>> CombineInOrder<T>(this IEnumerable<Task<Result<T>>> tasks, string errorMessageSeparator = null)
  • public static Task<Result> CombineInOrder(this Task<IEnumerable<Task<Result>>> task, string errorMessageSeparator = null)
  • public static Task<Result<IEnumerable<T>, E>> CombineInOrder<T, E>(this Task<IEnumerable<Task<Result<T, E>>>> task, Func<IEnumerable<E>, E> composerError)
  • public static Task<Result<IEnumerable<T>, E>> CombineInOrder<T, E>(this Task<IEnumerable<Task<Result<T, E>>>> task) where E : ICombine
  • public static Task<Result<IEnumerable<T>>> CombineInOrder<T>(this Task<IEnumerable<Task<Result<T>>>> task, string errorMessageSeparator = null)
  • public static Task<Result<K, E>> CombineInOrder<T, K, E>(this IEnumerable<Task<Result<T, E>>> tasks, Func<IEnumerable<T>, K> composer, Func<IEnumerable<E>, E> composerError)
  • public static Task<Result<K, E>> CombineInOrder<T, K, E>(this IEnumerable<Task<Result<T, E>>> tasks, Func<IEnumerable<T>, K> composer) where E : ICombine
  • public static Task<Result<K>> CombineInOrder<T, K>(this IEnumerable<Task<Result<T>>> tasks, Func<IEnumerable<T>, K> composer, string errorMessageSeparator = null)
  • public static Task<Result<K, E>> CombineInOrder<T, K, E>(this Task<IEnumerable<Task<Result<T, E>>>> task, Func<IEnumerable<T>, K> composer, Func<IEnumerable<E>, E> composerError)
  • public static Task<Result<K, E>> CombineInOrder<T, K, E>(this Task<IEnumerable<Task<Result<T, E>>>> task, Func<IEnumerable<T>, K> composer) where E : ICombine
  • public static Task<Result<K>> CombineInOrder<T, K>(this Task<IEnumerable<Task<Result<T>>>> task, Func<IEnumerable<T>, K> composer, string errorMessageSeparator = null)
  • public static Task<T[]> CompleteInOrder<T>(IEnumerable<Task<T>> tasks)
  • public static Task<Result<T, E>> Ensure<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, E error)
  • public static Task<Result<T, E>> Ensure<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, E> errorPredicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, string> errorPredicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task<string>> errorPredicate)
  • public static Task<Result> Ensure(this Task<Result> resultTask, Func<Result> predicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<Result> predicate)
  • public static Task<Result> Ensure<T>(this Task<Result> resultTask, Func<Result<T>> predicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<Result<T>> predicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<T, Result> predicate)
  • public static Task<Result<T>> Ensure<T>(this Task<Result<T>> resultTask, Func<T, Result<T>> predicate)
  • public static Task<T> Finally<T>(this Task<Result> resultTask, Func<Result, T> func)
  • public static Task<K> Finally<T, K>(this Task<Result<T>> resultTask, Func<Result<T>, K> func)
  • public static Task<K> Finally<K, E>(this Task<UnitResult<E>> resultTask, Func<UnitResult<E>, K> func)
  • public static Task<K> Finally<T, K, E>(this Task<Result<T, E>> resultTask, Func<Result<T, E>, K> func)
  • public static Task<Result<K, E>> Map<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, K> func)
  • public static Task<Result<K, E>> Map<K, E>(this Task<UnitResult<E>> resultTask, Func<K> func)
  • public static Task<Result<K>> Map<K>(this Task<Result> resultTask, Func<K> func)
  • public static Task<Result<K, E>> MapTry<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, K> func, Func<Exception, E> errorHandler)
  • public static Task<Result<K, E>> MapTry<K, E>(this Task<UnitResult<E>> resultTask, Func<K> func, Func<Exception, E> errorHandler)
  • public static Task<Result<K>> MapTry<T, K>(this Task<Result<T>> resultTask, Func<T, K> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> MapTry<K>(this Task<Result> resultTask, Func<K> func, Func<Exception, string> errorHandler = null)
  • public static Task<K> Match<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Task<K>> onSuccess, Func<E, Task<K>> onFailure)
  • public static Task<K> Match<K, T>(this Task<Result<T>> resultTask, Func<T, Task<K>> onSuccess, Func<string, Task<K>> onFailure)
  • public static Task<T> Match<T>(this Task<Result> resultTask, Func<Task<T>> onSuccess, Func<string, Task<T>> onFailure)
  • public static Task<K> Match<K, E>(this Task<UnitResult<E>> resultTask, Func<Task<K>> onSuccess, Func<E, Task<K>> onFailure)
  • public static Task Match<T, E>(this Task<Result<T, E>> resultTask, Func<T, Task> onSuccess, Func<E, Task> onFailure)
  • public static Task Match<E>(this Task<UnitResult<E>> resultTask, Func<Task> onSuccess, Func<E, Task> onFailure)
  • public static Task Match<T>(this Task<Result<T>> resultTask, Func<T, Task> onSuccess, Func<string, Task> onFailure)
  • public static Task Match(this Task<Result> resultTask, Func<Task> onSuccess, Func<string, Task> onFailure)
  • public static Task<K> Match<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, K> onSuccess, Func<E, K> onFailure)
  • public static Task<K> Match<K, T>(this Task<Result<T>> resultTask, Func<T, K> onSuccess, Func<string, K> onFailure)
  • public static Task<T> Match<T>(this Task<Result> resultTask, Func<T> onSuccess, Func<string, T> onFailure)
  • public static Task<K> Match<K, E>(this Task<UnitResult<E>> resultTask, Func<K> onSuccess, Func<E, K> onFailure)
  • public static Task Match<T, E>(this Task<Result<T, E>> resultTask, Action<T> onSuccess, Action<E> onFailure)
  • public static Task Match<E>(this Task<UnitResult<E>> resultTask, Action onSuccess, Action<E> onFailure)
  • public static Task Match<T>(this Task<Result<T>> resultTask, Action<T> onSuccess, Action<string> onFailure)
  • public static Task Match(this Task<Result> resultTask, Action onSuccess, Action<string> onFailure)
  • public static Task<K> Match<T, K, E>(this Result<T, E> result, Func<T, Task<K>> onSuccess, Func<E, Task<K>> onFailure)
  • public static Task<K> Match<K, T>(this Result<T> result, Func<T, Task<K>> onSuccess, Func<string, Task<K>> onFailure)
  • public static Task<T> Match<T>(this Result result, Func<Task<T>> onSuccess, Func<string, Task<T>> onFailure)
  • public static Task<K> Match<K, E>(this UnitResult<E> result, Func<Task<K>> onSuccess, Func<E, Task<K>> onFailure)
  • public static Task Match<T, E>(this Result<T, E> result, Func<T, Task> onSuccess, Func<E, Task> onFailure)
  • public static Task Match<E>(this UnitResult<E> result, Func<Task> onSuccess, Func<E, Task> onFailure)
  • public static Task Match<T>(this Result<T> result, Func<T, Task> onSuccess, Func<string, Task> onFailure)
  • public static Task Match(this Result result, Func<Task> onSuccess, Func<string, Task> onFailure)
  • public static Task<Result<T>> Map<T>(this Task<Result> resultTask, Func<T> func)
  • public static Task<K> OnBoth<T, K, E>(this Task<Result<T, E>> resultTask, Func<Result<T, E>, K> func)
  • public static Task<Result<T, E>> OnFailureCompensate<T, E>(this Task<Result<T, E>> resultTask, Func<Result<T, E>> func)
  • public static Task<Result<T>> OnFailureCompensate<T>(this Task<Result<T>> resultTask, Func<Result<T>> func)
  • public static Task<Result> OnFailureCompensate(this Task<Result> resultTask, Func<Result> func)
  • public static Task<Result<T>> OnFailureCompensate<T>(this Task<Result<T>> resultTask, Func<string, Result<T>> func)
  • public static Task<Result<T, E>> OnFailureCompensate<T, E>(this Task<Result<T, E>> resultTask, Func<E, Result<T, E>> func)
  • public static Task<Result> OnFailureCompensate(this Task<Result> resultTask, Func<string, Result> func)
  • public static Task<Result<K, E>> OnSuccess<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, K> func)
  • public static Task<Result<T>> OnFailure<T>(this Task<Result<T>> resultTask, Action action)
  • public static Task<Result> OnFailure(this Task<Result> resultTask, Action action)
  • public static Task<Result<T>> OnFailure<T>(this Task<Result<T>> resultTask, Action<string> action)
  • public static Task<Result> OnFailure(this Task<Result> resultTask, Action<string> action)
  • public static Task<Result<K>> OnSuccess<K>(this Task<Result> resultTask, Func<K> func)
  • public static Task<Result<K, E>> OnSuccess<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Result<K, E>> func)
  • public static Task<Result<T>> OnSuccess<T>(this Task<Result> resultTask, Func<T> func)
  • public static Task<Result<K>> OnSuccess<K>(this Task<Result> resultTask, Func<Result<K>> func)
  • public static Task<Result<T>> OnSuccess<T>(this Task<Result> resultTask, Func<Result<T>> func)
  • public static Task<Result<K>> OnSuccess<T, K>(this Task<Result<T>> resultTask, Func<Result<K>> func)
  • public static Task<Result> Tap(this Task<Result> resultTask, Action action)
  • public static Task<Result<T>> Tap<T>(this Task<Result<T>> resultTask, Action action)
  • public static Task<Result<T>> Tap<T>(this Task<Result<T>> resultTask, Action<T> action)
  • public static Task<UnitResult<E>> Tap<E>(this Task<UnitResult<E>> resultTask, Action action)
  • public static Task<Result<T, E>> Tap<T, E>(this Task<Result<T, E>> resultTask, Action action)
  • public static Task<Result<T, E>> Tap<T, E>(this Task<Result<T, E>> resultTask, Action<T> action)
  • public static Task<Result<T>> Tap<T>(this Task<Result<T>> resultTask, Func<T, Result> func)
  • public static Task<Result<T>> Tap<T, K>(this Task<Result<T>> resultTask, Func<T, Result<K>> func)
  • public static Task<Result<T, E>> Tap<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Result<K, E>> func)
  • public static Task<Result> TapIf(this Task<Result> resultTask, bool condition, Action action)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, bool condition, Action action)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, bool condition, Action<T> action)
  • public static Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Action action)
  • public static Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Action<T> action)
  • public static Task<UnitResult<E>> TapIf<E>(this Task<UnitResult<E>> resultTask, bool condition, Action action)
  • public static Task<Result> TapIf(this Task<Result> resultTask, Func<bool> predicate, Action action)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Action action)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Action<T> action)
  • public static Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Action action)
  • public static Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Action<T> action)
  • public static Task<UnitResult<E>> TapIf<E>(this Task<UnitResult<E>> resultTask, Func<bool> predicate, Action action)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Result> func)
  • public static Task<Result<T>> TapIf<T, K>(this Task<Result<T>> resultTask, bool condition, Func<T, Result<K>> func)
  • public static Task<Result<T, E>> TapIf<T, K, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Result<K, E>> func)
  • public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Result> func)
  • public static Task<Result<T>> TapIf<T, K>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Result<K>> func)
  • public static Task<Result<T, E>> TapIf<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Result<K, E>> func)
  • public static Task<Result> TapIfTry(this Task<Result> resultTask, bool condition, Action action)
  • public static Task<Result<T>> TapIfTry<T>(this Task<Result<T>> resultTask, bool condition, Action action)
  • public static Task<Result<T>> TapIfTry<T>(this Task<Result<T>> resultTask, bool condition, Action<T> action)
  • public static Task<UnitResult<E>> TapIfTry<E>(this Task<UnitResult<E>> resultTask, bool condition, Action action, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Task<Result<T, E>> resultTask, bool condition, Action action, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Task<Result<T, E>> resultTask, bool condition, Action<T> action, Func<Exception, E> errorHandler)
  • public static Task<Result<T>> TapIfTry<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Action action)
  • public static Task<Result<T>> TapIfTry<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Action<T> action)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Action action, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Action<T> action, Func<Exception, E> errorHandler)
  • public static Task<Result> TapTry(this Task<Result> resultTask, Action action)
  • public static Task<Result<T>> TapTry<T>(this Task<Result<T>> resultTask, Action action)
  • public static Task<Result<T>> TapTry<T>(this Task<Result<T>> resultTask, Action<T> action)
  • public static Task<UnitResult<E>> TapTry<E>(this Task<UnitResult<E>> resultTask, Action action, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapTry<T, E>(this Task<Result<T, E>> resultTask, Action action, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapTry<T, E>(this Task<Result<T, E>> resultTask, Action<T> action, Func<Exception, E> errorHandler)
• public static class AsyncResultExtensionsRightOperand
  • public static Task<Result<K, E>> Bind<T, K, E>(this Result<T, E> result, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<K>> Bind<T, K>(this Result<T> result, Func<T, Task<Result<K>>> func)
  • public static Task<Result<K>> Bind<K>(this Result result, Func<Task<Result<K>>> func)
  • public static Task<Result> Bind<T>(this Result<T> result, Func<T, Task<Result>> func)
  • public static Task<Result> Bind(this Result result, Func<Task<Result>> func)
  • public static Task<UnitResult<E>> Bind<E>(this UnitResult<E> result, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T, E>> Bind<T, E>(this UnitResult<E> result, Func<Task<Result<T, E>>> func)
  • public static Task<UnitResult<E>> Bind<T, E>(this Result<T, E> result, Func<T, Task<UnitResult<E>>> func)
  • public static Task<Result<K, E>> BindTry<T, K, E>(this Result<T, E> result, Func<T, Task<Result<K, E>>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<K>> BindTry<T, K>(this Result<T> result, Func<T, Task<Result<K>>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> BindTry<K>(this Result result, Func<Task<Result<K>>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result> BindTry<T>(this Result<T> result, Func<T, Task<Result>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result> BindTry(this Result result, Func<Task<Result>> func, Func<Exception, string> errorHandler = null)
  • public static Task<UnitResult<E>> BindTry<E>(this UnitResult<E> result, Func<Task<UnitResult<E>>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> BindTry<T, E>(this UnitResult<E> result, Func<Task<Result<T, E>>> func, Func<Exception, E> errorHandler)
  • public static Task<UnitResult<E>> BindTry<T, E>(this Result<T, E> result, Func<T, Task<UnitResult<E>>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T>> Check<T>(this Result<T> result, Func<T, Task<Result>> func)
  • public static Task<Result<T>> Check<T, K>(this Result<T> result, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> Check<T, K, E>(this Result<T, E> result, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<T, E>> Check<T, E>(this Result<T, E> result, Func<T, Task<UnitResult<E>>> func)
  • public static Task<UnitResult<E>> Check<E>(this UnitResult<E> result, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T>> CheckIf<T>(this Result<T> result, bool condition, Func<T, Task<Result>> func)
  • public static Task<Result<T>> CheckIf<T, K>(this Result<T> result, bool condition, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> CheckIf<T, K, E>(this Result<T, E> result, bool condition, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<T, E>> CheckIf<T, E>(this Result<T, E> result, bool condition, Func<T, Task<UnitResult<E>>> func)
  • public static Task<UnitResult<E>> CheckIf<E>(this UnitResult<E> result, bool condition, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T>> CheckIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Task<Result>> func)
  • public static Task<Result<T>> CheckIf<T, K>(this Result<T> result, Func<T, bool> predicate, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> CheckIf<T, K, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<T, E>> CheckIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Task<UnitResult<E>>> func)
  • public static Task<UnitResult<E>> CheckIf<E>(this UnitResult<E> result, Func<bool> predicate, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T, E>> Ensure<T, E>(this Result<T, E> result, Func<T, Task<bool>> predicate, E error)
  • public static Task<Result<T, E>> Ensure<T, E>(this Result<T, E> result, Func<T, Task<bool>> predicate, Func<T, E> errorPredicate)
  • public static Task<Result<T, E>> Ensure<T, E>(this Result<T, E> result, Func<T, Task<bool>> predicate, Func<T, Task<E>> errorPredicate)
  • public static Task<Result<T>> Ensure<T>(this Result<T> result, Func<T, Task<bool>> predicate, Func<T, string> errorPredicate)
  • public static Task<Result<T>> Ensure<T>(this Result<T> result, Func<T, Task<bool>> predicate, Func<T, Task<string>> errorPredicate)
  • public static Task<Result> Ensure(this Result result, Func<Task<Result>> predicate)
  • public static Task<Result<T>> Ensure<T>(this Result<T> result, Func<Task<Result>> predicate)
  • public static Task<Result> Ensure<T>(this Result result, Func<Task<Result<T>>> predicate)
  • public static Task<Result<T>> Ensure<T>(this Result<T> result, Func<Task<Result<T>>> predicate)
  • public static Task<Result<T>> Ensure<T>(this Result<T> result, Func<T, Task<Result>> predicate)
  • public static Task<Result<T>> Ensure<T>(this Result<T> result, Func<T, Task<Result<T>>> predicate)
  • public static Task<T> Finally<T>(this Result result, Func<Result, Task<T>> func)
  • public static Task<K> Finally<T, K>(this Result<T> result, Func<Result<T>, Task<K>> func)
  • public static Task<K> Finally<K, E>(this UnitResult<E> result, Func<UnitResult<E>, Task<K>> func)
  • public static Task<K> Finally<T, K, E>(this Result<T, E> result, Func<Result<T, E>, Task<K>> func)
  • public static Task<Result<K, E>> Map<T, K, E>(this Result<T, E> result, Func<T, Task<K>> func)
  • public static Task<Result<K, E>> Map<K, E>(this UnitResult<E> result, Func<Task<K>> func)
  • public static Task<Result<K>> Map<T, K>(this Result<T> result, Func<T, Task<Result<K>>> func)
  • public static Task<Result<K>> Map<K>(this Result result, Func<Task<K>> func)
  • public static Task<Result<K, E>> MapTry<T, K, E>(this Result<T, E> result, Func<T, Task<K>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<K, E>> MapTry<K, E>(this UnitResult<E> result, Func<Task<K>> func, Func<Exception, E> errorHandler)
  • public static Task<Result<K>> MapTry<T, K>(this Result<T> result, Func<T, Task<K>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> MapTry<K>(this Result result, Func<Task<K>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> Map<T>(this Result result, Func<Task<T>> func)
  • public static Task<K> OnBoth<T, K, E>(this Result<T, E> result, Func<Result<T, E>, Task<K>> func)
  • public static Task<Result<T>> OnFailureCompensate<T>(this Result<T> result, Func<Task<Result<T>>> func)
  • public static Task<Result<T, E>> OnFailureCompensate<T, E>(this Result<T, E> result, Func<Task<Result<T, E>>> func)
  • public static Task<Result> OnFailureCompensate(this Result result, Func<Task<Result>> func)
  • public static Task<Result<T>> OnFailureCompensate<T>(this Result<T> result, Func<string, Task<Result<T>>> func)
  • public static Task<Result<T, E>> OnFailureCompensate<T, E>(this Result<T, E> result, Func<E, Task<Result<T, E>>> func)
  • public static Task<Result> OnFailureCompensate(this Result result, Func<string, Task<Result>> func)
  • public static Task<Result<K, E>> OnSuccess<T, K, E>(this Result<T, E> result, Func<T, Task<K>> func)
  • public static Task<Result<T>> OnFailure<T>(this Result<T> result, Func<Task> func)
  • public static Task<Result> OnFailure(this Result result, Func<Task> func)
  • public static Task<Result<T>> OnFailure<T>(this Result<T> result, Func<string, Task> func)
  • public static Task<Result<K>> OnSuccess<K>(this Result result, Func<Task<K>> func)
  • public static Task<Result<K, E>> OnSuccess<T, K, E>(this Result<T, E> result, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<T>> OnSuccess<T>(this Result result, Func<Task<T>> func)
  • public static Task<Result<K>> OnSuccess<K>(this Result result, Func<Task<Result<K>>> func)
  • public static Task<Result<T>> OnSuccess<T>(this Result result, Func<Task<Result<T>>> func)
  • public static Task<Result<K>> OnSuccess<T, K>(this Result<T> result, Func<Task<Result<K>>> func)
  • public static Task<Result<T, E>> OnSuccess<T, E>(this Result<T, E> result, Func<T, Task> action)
  • public static Task<Result> Tap(this Result result, Func<Task> func)
  • public static Task<Result<T>> Tap<T>(this Result<T> result, Func<Task> func)
  • public static Task<Result<T>> Tap<T>(this Result<T> result, Func<T, Task> func)
  • public static Task<UnitResult<E>> Tap<E>(this UnitResult<E> result, Func<Task> func)
  • public static Task<Result<T, E>> Tap<T, E>(this Result<T, E> result, Func<Task> func)
  • public static Task<Result<T, E>> Tap<T, E>(this Result<T, E> result, Func<T, Task> func)
  • public static Task<Result<T>> Tap<T>(this Result<T> result, Func<T, Task<Result>> func)
  • public static Task<Result<T>> Tap<T, K>(this Result<T> result, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> Tap<T, K, E>(this Result<T, E> result, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result> TapIf(this Result result, bool condition, Func<Task> func)
  • public static Task<Result<T>> TapIf<T>(this Result<T> result, bool condition, Func<Task> func)
  • public static Task<Result<T>> TapIf<T>(this Result<T> result, bool condition, Func<T, Task> func)
  • public static Task<Result<T, E>> TapIf<T, E>(this Result<T, E> result, bool condition, Func<Task> func)
  • public static Task<Result<T, E>> TapIf<T, E>(this Result<T, E> result, bool condition, Func<T, Task> func)
  • public static Task<UnitResult<E>> TapIf<E>(this UnitResult<E> result, bool condition, Func<Task> func)
  • public static Task<Result<T>> TapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<Task> func)
  • public static Task<Result<T>> TapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Task> func)
  • public static Task<Result<T, E>> TapIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<Task> func)
  • public static Task<Result<T, E>> TapIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Task> func)
  • public static Task<UnitResult<E>> TapIf<E>(this UnitResult<E> result, Func<bool> predicate, Func<Task> func)
  • public static Task<Result<T>> TapIf<T>(this Result<T> result, bool condition, Func<T, Task<Result>> func)
  • public static Task<Result<T>> TapIf<T, K>(this Result<T> result, bool condition, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> TapIf<T, K, E>(this Result<T, E> result, bool condition, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result<T>> TapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Task<Result>> func)
  • public static Task<Result<T>> TapIf<T, K>(this Result<T> result, Func<T, bool> predicate, Func<T, Task<Result<K>>> func)
  • public static Task<Result<T, E>> TapIf<T, K, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Task<Result<K, E>>> func)
  • public static Task<Result> TapIfTry(this Result result, bool condition, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> TapIfTry<T>(this Result<T> result, bool condition, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> TapIfTry<T>(this Result<T> result, bool condition, Func<T, Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<UnitResult<E>> TapIfTry<E>(this UnitResult<E> result, bool condition, Func<Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Result<T, E> result, bool condition, Func<Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Result<T, E> result, bool condition, Func<T, Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T>> TapIfTry<T>(this Result<T> result, Func<T, bool> predicate, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> TapIfTry<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapIfTry<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result> TapTry(this Result result, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> TapTry<T>(this Result<T> result, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> TapTry<T>(this Result<T> result, Func<T, Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<UnitResult<E>> TapTry<E>(this UnitResult<E> result, Func<Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapTry<T, E>(this Result<T, E> result, Func<Task> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T, E>> TapTry<T, E>(this Result<T, E> result, Func<T, Task> func, Func<Exception, E> errorHandler)
• public abstract class Entity : Entity<long>
• public abstract class Entity<TId> : IComparable, IComparable<Entity<TId>> where TId : IComparable<TId>
• public abstract class EnumValueObject<TEnumeration> : ValueObject where TEnumeration : EnumValueObject<TEnumeration>
• public abstract class EnumValueObject<TEnumeration, TId> : ValueObject where TEnumeration : EnumValueObject<TEnumeration, TId> where TId : struct, IComparable
• public interface ICombine
• public interface IError<E>
• public interface IMaybe<T>
• public interface IResult
• public interface IResult<T> : IResult<T, string>, IValue<T>, IUnitResult<string>, IResult, IError<string>
• public interface IResult<T, E> : IValue<T>, IUnitResult<E>, IResult, IError<E>
• public interface IUnitResult<E> : IResult, IError<E>
• public interface IValue<T>
• public struct Maybe
• public struct Maybe<T> : IEquatable<Maybe<T>>
  • public static Maybe<T> None { get; }
  • public static bool op_Equality(Maybe<T> maybe, object other)
  • public static Maybe<T> op_Implicit(Maybe value)
  • public static bool op_Inequality(Maybe<T> maybe, object other)
  • public T GetValueOrDefault(T defaultValue = null)
  • public T GetValueOrThrow(string errorMessage = null)
  • public T GetValueOrThrow(Exception exception)
  • public bool TryGetValue(out T value)
• public class MaybeEqualityComparer<T> : IEqualityComparer<Maybe<T>>
• public static class MaybeExtensions
  • public static Maybe<T> AsMaybe<T>(this ref Nullable value) where T : struct
  • public static Maybe<T> AsMaybe<T>(this T value)
  • public static T? AsNullable<T>(this ref Maybe value) where T : struct
  • public static Maybe<K> Bind<T, K>(this ref Maybe maybe, Func<T, Maybe<K>> selector)
  • public static Task<Maybe<K>> Bind<T, K>(this Task<Maybe<T>> maybeTask, Func<T, Task<Maybe<K>>> selector)
  • public static Task<Maybe<K>> Bind<T, K>(this Task<Maybe<T>> maybeTask, Func<T, Maybe<K>> selector)
  • public static Task<Maybe<K>> Bind<T, K>(this Maybe<T> maybe, Func<T, Task<Maybe<K>>> selector)
  • public static IEnumerable<U> Choose<T, U>(this IEnumerable<Maybe<T>> source, Func<T, U> selector)
  • public static IEnumerable<T> Choose<T>(this IEnumerable<Maybe<T>> source)
  • public static void Deconstruct<T>(this ref Maybe result, out bool hasValue, out T value)
  • public static void Execute<T>(this ref Maybe maybe, Action<T> action)
  • public static Task Execute<T>(this Task<Maybe<T>> maybeTask, Func<T, Task> asyncAction)
  • public static Task Execute<T>(this Task<Maybe<T>> maybeTask, Action<T> action)
  • public static Task Execute<T>(this Maybe<T> maybe, Func<T, Task> action)
  • public static void ExecuteNoValue<T>(this ref Maybe maybe, Action action)
  • public static Task ExecuteNoValue<T>(this Task<Maybe<T>> maybeTask, Func<Task> asyncAction)
  • public static Task ExecuteNoValue<T>(this Task<Maybe<T>> maybeTask, Action action)
  • public static Task ExecuteNoValue<T>(this Maybe<T> maybe, Func<Task> action)
  • public static Maybe<T> Flatten<T>(this ref Maybe maybe)
  • public static T GetValueOrDefault<T>(this ref Maybe maybe, Func<T> defaultValue)
  • public static K GetValueOrDefault<T, K>(this ref Maybe maybe, Func<T, K> selector, K defaultValue = null)
  • public static K GetValueOrDefault<T, K>(this ref Maybe maybe, Func<T, K> selector, Func<K> defaultValue)
  • public static Task<T> GetValueOrDefault<T>(this Task<Maybe<T>> maybeTask, Func<Task<T>> defaultValue)
  • public static Task<K> GetValueOrDefault<T, K>(this Task<Maybe<T>> maybeTask, Func<T, Task<K>> selector, K defaultValue = null)
  • public static Task<K> GetValueOrDefault<T, K>(this Task<Maybe<T>> maybeTask, Func<T, Task<K>> selector, Func<Task<K>> defaultValue)
  • public static Task<T> GetValueOrDefault<T>(this Task<Maybe<T>> maybeTask, Func<T> defaultValue)
  • public static Task<K> GetValueOrDefault<T, K>(this Task<Maybe<T>> maybeTask, Func<T, K> selector, K defaultValue = null)
  • public static Task<K> GetValueOrDefault<T, K>(this Task<Maybe<T>> maybeTask, Func<T, K> selector, Func<K> defaultValue)
  • public static Task<T> GetValueOrDefault<T>(this Maybe<T> maybe, Func<Task<T>> defaultValue)
  • public static Task<K> GetValueOrDefault<T, K>(this Maybe<T> maybe, Func<T, K> selector, Func<Task<K>> defaultValue)
  • public static Task<K> GetValueOrDefault<T, K>(this Maybe<T> maybe, Func<T, Task<K>> selector, K defaultValue = null)
  • public static Task<K> GetValueOrDefault<T, K>(this Maybe<T> maybe, Func<T, Task<K>> selector, Func<Task<K>> defaultValue)
  • public static Task<T> GetValueOrThrow<T>(this Task<Maybe<T>> maybeTask)
  • public static Task<T> GetValueOrThrow<T>(this Task<Maybe<T>> maybeTask, string errorMessage)
  • public static Maybe<K> Map<T, K>(this ref Maybe maybe, Func<T, K> selector)
  • public static Task<Maybe<K>> Map<T, K>(this Task<Maybe<T>> maybeTask, Func<T, Task<K>> selector)
  • public static Task<Maybe<K>> Map<T, K>(this Task<Maybe<T>> maybeTask, Func<T, K> selector)
  • public static Task<Maybe<K>> Map<T, K>(this Maybe<T> maybe, Func<T, Task<K>> selector)
  • public static TE Match<TE, T>(this ref Maybe maybe, Func<T, TE> Some, Func<TE> None)
  • public static void Match<T>(this ref Maybe maybe, Action<T> Some, Action None)
  • public static TE Match<TE, TKey, TValue>(this ref Maybe maybe, Func<TKey, TValue, TE> Some, Func<TE> None)
  • public static void Match<TKey, TValue>(this ref Maybe maybe, Action<TKey, TValue> Some, Action None)
  • public static Maybe<T> Or<T>(this ref Maybe maybe, Func<T> fallbackOperation)
  • public static Maybe<T> Or<T>(this ref Maybe maybe, Maybe<T> fallback)
  • public static Maybe<T> Or<T>(this ref Maybe maybe, Func<Maybe<T>> fallbackOperation)
  • public static Task<Maybe<T>> Or<T>(this Task<Maybe<T>> maybeTask, Task<T> fallback)
  • public static Task<Maybe<T>> Or<T>(this Task<Maybe<T>> maybeTask, Func<Task<T>> fallbackOperation)
  • public static Task<Maybe<T>> Or<T>(this Task<Maybe<T>> maybeTask, Func<Maybe<T>> fallbackOperation)
  • public static Task<Maybe<T>> Or<T>(this Task<Maybe<T>> maybeTask, Func<Task<Maybe<T>>> fallbackOperation)
  • public static Task<Maybe<T>> Or<T>(this Task<Maybe<T>> maybeTask, T fallback)
  • public static Task<Maybe<T>> Or<T>(this Task<Maybe<T>> maybeTask, Func<T> fallbackOperation)
  • public static Task<Maybe<T>> Or<T>(this Task<Maybe<T>> maybeTask, Maybe<T> fallback)
  • public static Task<Maybe<T>> Or<T>(this Maybe<T> maybe, Func<Task<T>> fallbackOperation)
  • public static Task<Maybe<T>> Or<T>(this Maybe<T> maybe, Task<Maybe<T>> fallback)
  • public static Task<Maybe<T>> Or<T>(this Maybe<T> maybe, Func<Task<Maybe<T>>> fallbackOperation)
  • public static Maybe<K> Select<T, K>(this ref Maybe maybe, Func<T, K> selector)
  • public static Maybe<K> Select<T, K>(this ref Maybe maybe, Func<T, Maybe<K>> selector)
  • public static Maybe<K> SelectMany<T, K>(this ref Maybe maybe, Func<T, Maybe<K>> selector)
  • public static Maybe<V> SelectMany<T, U, V>(this ref Maybe maybe, Func<T, Maybe<U>> selector, Func<T, U, V> project)
  • public static List<T> ToList<T>(this ref Maybe maybe)
  • public static Result<T> ToResult<T>(this ref Maybe maybe, string errorMessage)
  • public static Result<T, E> ToResult<T, E>(this ref Maybe maybe, E error)
  • public static Task<Result<T>> ToResult<T>(this Task<Maybe<T>> maybeTask, string errorMessage)
  • public static Task<Result<T, E>> ToResult<T, E>(this Task<Maybe<T>> maybeTask, E error)
  • public static Maybe<V> TryFind<K, V>(this IReadOnlyDictionary<K, V> dict, K key)
  • public static Maybe<T> TryFirst<T>(this IEnumerable<T> source)
  • public static Maybe<T> TryFirst<T>(this IEnumerable<T> source, Func<T, bool> predicate)
  • public static Maybe<T> TryLast<T>(this IEnumerable<T> source)
  • public static Maybe<T> TryLast<T>(this IEnumerable<T> source, Func<T, bool> predicate)
  • public static Maybe<T> Where<T>(this ref Maybe maybe, Func<T, bool> predicate)
  • public static Task<Maybe<T>> Where<T>(this Task<Maybe<T>> maybeTask, Func<T, Task<bool>> predicate)
  • public static Task<Maybe<T>> Where<T>(this Task<Maybe<T>> maybeTask, Func<T, bool> predicate)
  • public static Task<Maybe<T>> Where<T>(this Maybe<T> maybe, Func<T, Task<bool>> predicate)
  • public static void Execute<T>(this Maybe<T> maybe, Action<T> action)
  • public static Maybe<K> Select<T, K>(this Maybe<T> maybe, Func<T, K> selector)
  • public static Maybe<K> Select<T, K>(this Maybe<T> maybe, Func<T, Maybe<K>> selector)
  • public static Result<T> ToResult<T>(this Maybe<T> maybe, string errorMessage)
  • public static T Unwrap<T>(this Maybe<T> maybe, T defaultValue = null)
  • public static K Unwrap<T, K>(this Maybe<T> maybe, Func<T, K> selector, K defaultValue = null)
  • public static Maybe<T> Where<T>(this Maybe<T> maybe, Func<T, bool> predicate)
• public struct Result
  • public static class Configuration
  • public static Result Combine(IEnumerable<Result> results, string errorMessagesSeparator = null)
  • public static Result Combine<T>(IEnumerable<Result<T>> results, string errorMessagesSeparator = null)
  • public static UnitResult<E> Combine<E>(IEnumerable<UnitResult<E>> results, Func<IEnumerable<E>, E> composerError)
  • public static UnitResult<E> Combine<E>(Func<IEnumerable<E>, E> composerError, UnitResult<E>[] results)
  • public static UnitResult<E> Combine<E>(UnitResult<E>[] results) where E : ICombine
  • public static UnitResult<E> Combine<E>(IEnumerable<UnitResult<E>> results) where E : ICombine
  • public static Result<bool, E> Combine<T, E>(IEnumerable<Result<T, E>> results, Func<IEnumerable<E>, E> composerError)
  • public static Result<bool, E> Combine<T, E>(IEnumerable<Result<T, E>> results) where E : ICombine
  • public static Result Combine(string errorMessagesSeparator, Result[] results)
  • public static Result<bool, E> Combine<T, E>(Result<T, E>[] results) where E : ICombine
  • public static Result Combine(string errorMessagesSeparator, Result[] results)
  • public static Result<bool, E> Combine<T, E>(Func<IEnumerable<E>, E> composerError, Result<T, E>[] results)
  • public static Result Create(bool isSuccess, string error)
  • public static Result Create(Func<bool> predicate, string error)
  • public static Task<Result> Create(Func<Task<bool>> predicate, string error)
  • public static Result<T> Create<T>(bool isSuccess, T value, string error)
  • public static Result<T> Create<T>(Func<bool> predicate, T value, string error)
  • public static Task<Result<T>> Create<T>(Func<Task<bool>> predicate, T value, string error)
  • public static Result<T, E> Create<T, E>(bool isSuccess, T value, E error)
  • public static Result<T, E> Create<T, E>(Func<bool> predicate, T value, E error)
  • public static Task<Result<T, E>> Create<T, E>(Func<Task<bool>> predicate, T value, E error)
  • public static Result CreateFailure(bool isFailure, string error)
  • public static Result CreateFailure(Func<bool> failurePredicate, string error)
  • public static Task<Result> CreateFailure(Func<Task<bool>> failurePredicate, string error)
  • public static Result<T> CreateFailure<T>(bool isFailure, T value, string error)
  • public static Result<T> CreateFailure<T>(Func<bool> failurePredicate, T value, string error)
  • public static Task<Result<T>> CreateFailure<T>(Func<Task<bool>> failurePredicate, T value, string error)
  • public static Result<T, E> CreateFailure<T, E>(bool isFailure, T value, E error)
  • public static Result<T, E> CreateFailure<T, E>(Func<bool> failurePredicate, T value, E error)
  • public static Task<Result<T, E>> CreateFailure<T, E>(Func<Task<bool>> failurePredicate, T value, E error)
  • public static Result<T, E> Fail<T, E>(E error)
  • public static Result Failure(string error)
  • public static Result<T> Failure<T>(string error)
  • public static Result<T, E> Failure<T, E>(E error)
  • public static Result FailureIf(bool isFailure, string error)
  • public static Result FailureIf(Func<bool> failurePredicate, string error)
  • public static Result<T> FailureIf<T>(bool isFailure, T value, string error)
  • public static Result<T> FailureIf<T>(Func<bool> failurePredicate, ref T value, string error)
  • public static Result<T, E> FailureIf<T, E>(bool isFailure, ref T value, ref E error)
  • public static Result<T, E> FailureIf<T, E>(Func<bool> failurePredicate, ref T value, ref E error)
  • public static Task<Result> FailureIf(Func<Task<bool>> failurePredicate, string error)
  • public static Task<Result<T>> FailureIf<T>(Func<Task<bool>> failurePredicate, T value, string error)
  • public static Task<Result<T, E>> FailureIf<T, E>(Func<Task<bool>> failurePredicate, T value, E error)
  • public static Result<T, E> Ok<T, E>(T value)
  • public static UnitResult<string> op_Implicit(Result result)
  • public static Result Success()
  • public static Result<T> Success<T>(T value)
  • public static Result<T, E> Success<T, E>(T value)
  • public static UnitResult<E> Success<E>()
  • public static Result SuccessIf(bool isSuccess, string error)
  • public static Result SuccessIf(Func<bool> predicate, string error)
  • public static Result<T> SuccessIf<T>(bool isSuccess, ref T value, string error)
  • public static Result<T> SuccessIf<T>(Func<bool> predicate, ref T value, string error)
  • public static Result<T, E> SuccessIf<T, E>(bool isSuccess, ref T value, ref E error)
  • public static Result<T, E> SuccessIf<T, E>(Func<bool> predicate, ref T value, ref E error)
  • public static Task<Result> SuccessIf(Func<Task<bool>> predicate, string error)
  • public static Task<Result<T>> SuccessIf<T>(Func<Task<bool>> predicate, T value, string error)
  • public static Task<Result<T, E>> SuccessIf<T, E>(Func<Task<bool>> predicate, T value, E error)
  • public static Result Try(Action action, Func<Exception, string> errorHandler = null)
  • public static Result<T> Try<T>(Func<T> func, Func<Exception, string> errorHandler = null)
  • public static Result<T, E> Try<T, E>(Func<T> func, Func<Exception, E> errorHandler)
  • public static UnitResult<E> Try<E>(Action action, Func<Exception, E> errorHandler)
  • public static Task<UnitResult<E>> Try<E>(Func<Task> action, Func<Exception, E> errorHandler)
  • public static Task<Result> Try(Func<Task> action, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T>> Try<T>(Func<Task<T>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<T, E>> Try<T, E>(Func<Task<T>> func, Func<Exception, E> errorHandler)
  • public Result<K> ConvertFailure<K>()
  • public bool TryGetError(out string error)
• public struct Result<T>
  • public static Result<T> op_Implicit(T value)
  • public static UnitResult<string> op_Implicit(Result<T> result)
  • public Result ConvertFailure()
  • public Result<K> ConvertFailure<K>()
  • public T GetValueOrDefault(T defaultValue = null)
  • public bool TryGetError(out string error)
  • public bool TryGetError(out string error, out T value)
  • public bool TryGetValue(out T value)
  • public bool TryGetValue(out T value, out string error)
• public struct Result<T, E> : IResult<T, E>, IValue<T>, IUnitResult<E>, IResult, IError<E>, ISerializable
• public static class ResultExtensions
  • public static Result<K, E> Bind<T, K, E>(this Result<T, E> result, Func<T, Result<K, E>> func)
  • public static Result<K> Bind<T, K>(this Result<T> result, Func<T, Result<K>> func)
  • public static Result<K> Bind<K>(this Result result, Func<Result<K>> func)
  • public static Result Bind<T>(this Result<T> result, Func<T, Result> func)
  • public static Result Bind(this Result result, Func<Result> func)
  • public static UnitResult<E> Bind<E>(this UnitResult<E> result, Func<UnitResult<E>> func)
  • public static Result<T, E> Bind<T, E>(this UnitResult<E> result, Func<Result<T, E>> func)
  • public static UnitResult<E> Bind<T, E>(this Result<T, E> result, Func<T, UnitResult<E>> func)
  • public static Result BindIf(this Result result, bool condition, Func<Result> func)
  • public static Result<T> BindIf<T>(this Result<T> result, bool condition, Func<T, Result<T>> func)
  • public static UnitResult<E> BindIf<E>(this UnitResult<E> result, bool condition, Func<UnitResult<E>> func)
  • public static Result<T, E> BindIf<T, E>(this Result<T, E> result, bool condition, Func<T, Result<T, E>> func)
  • public static Result BindIf(this Result result, Func<bool> predicate, Func<Result> func)
  • public static Result<T> BindIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Result<T>> func)
  • public static UnitResult<E> BindIf<E>(this UnitResult<E> result, Func<bool> predicate, Func<UnitResult<E>> func)
  • public static Result<T, E> BindIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Result<T, E>> func)
  • public static Task<Result> BindIf(this Task<Result> resultTask, bool condition, Func<Task<Result>> func)
  • public static Task<Result<T>> BindIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Task<Result<T>>> func)
  • public static Task<UnitResult<E>> BindIf<E>(this Task<UnitResult<E>> resultTask, bool condition, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T, E>> BindIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Task<Result<T, E>>> func)
  • public static Task<Result> BindIf(this Task<Result> resultTask, Func<bool> predicate, Func<Task<Result>> func)
  • public static Task<Result<T>> BindIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task<Result<T>>> func)
  • public static Task<UnitResult<E>> BindIf<E>(this Task<UnitResult<E>> resultTask, Func<bool> predicate, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T, E>> BindIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Task<Result<T, E>>> func)
  • public static Task<Result> BindIf(this Task<Result> resultTask, bool condition, Func<Result> func)
  • public static Task<Result<T>> BindIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Result<T>> func)
  • public static Task<UnitResult<E>> BindIf<E>(this Task<UnitResult<E>> resultTask, bool condition, Func<UnitResult<E>> func)
  • public static Task<Result<T, E>> BindIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Result<T, E>> func)
  • public static Task<Result> BindIf(this Task<Result> resultTask, Func<bool> predicate, Func<Result> func)
  • public static Task<Result<T>> BindIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Result<T>> func)
  • public static Task<UnitResult<E>> BindIf<E>(this Task<UnitResult<E>> resultTask, Func<bool> predicate, Func<UnitResult<E>> func)
  • public static Task<Result<T, E>> BindIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Result<T, E>> func)
  • public static Task<Result> BindIf(this Result result, bool condition, Func<Task<Result>> func)
  • public static Task<Result<T>> BindIf<T>(this Result<T> result, bool condition, Func<T, Task<Result<T>>> func)
  • public static Task<UnitResult<E>> BindIf<E>(this UnitResult<E> result, bool condition, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T, E>> BindIf<T, E>(this Result<T, E> result, bool condition, Func<T, Task<Result<T, E>>> func)
  • public static Task<Result> BindIf(this Result result, Func<bool> predicate, Func<Task<Result>> func)
  • public static Task<Result<T>> BindIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Task<Result<T>>> func)
  • public static Task<UnitResult<E>> BindIf<E>(this UnitResult<E> result, Func<bool> predicate, Func<Task<UnitResult<E>>> func)
  • public static Task<Result<T, E>> BindIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Task<Result<T, E>>> func)
  • public static Result BindTry(this Result result, Func<Result> func, Func<Exception, string> errorHandler = null)
  • public static Result<K> BindTry<K>(this Result result, Func<Result<K>> func, Func<Exception, string> errorHandler = null)
  • public static Result BindTry<T>(this Result<T> result, Func<T, Result> func, Func<Exception, string> errorHandler = null)
  • public static Result<K> BindTry<T, K>(this Result<T> result, Func<T, Result<K>> func, Func<Exception, string> errorHandler = null)
  • public static Result<K, E> BindTry<T, K, E>(this Result<T, E> result, Func<T, Result<K, E>> func, Func<Exception, E> errorHandler)
  • public static UnitResult<E> BindTry<E>(this UnitResult<E> result, Func<UnitResult<E>> func, Func<Exception, E> errorHandler)
  • public static Result<T, E> BindTry<T, E>(this UnitResult<E> result, Func<Result<T, E>> func, Func<Exception, E> errorHandler)
  • public static UnitResult<E> BindTry<T, E>(this Result<T, E> result, Func<T, UnitResult<E>> func, Func<Exception, E> errorHandler)
  • public static Result<K> BindWithTransactionScope<T, K>(this Result<T> self, Func<T, Result<K>> f)
  • public static Result<K> BindWithTransactionScope<K>(this Result self, Func<Result<K>> f)
  • public static Result BindWithTransactionScope<T>(this Result<T> self, Func<T, Result> f)
  • public static Result BindWithTransactionScope(this Result self, Func<Result> f)
  • public static Result<K, E> BindWithTransactionScope<T, K, E>(this Result<T, E> self, Func<T, Result<K, E>> f)
  • public static Task<Result<K, E>> BindWithTransactionScope<T, K, E>(this Task<Result<T, E>> self, Func<T, Task<Result<K, E>>> f)
  • public static Task<Result<K>> BindWithTransactionScope<T, K>(this Task<Result<T>> self, Func<T, Task<Result<K>>> f)
  • public static Task<Result<K>> BindWithTransactionScope<K>(this Task<Result> self, Func<Task<Result<K>>> f)
  • public static Task<Result> BindWithTransactionScope<T>(this Task<Result<T>> self, Func<T, Task<Result>> f)
  • public static Task<Result> BindWithTransactionScope(this Task<Result> self, Func<Task<Result>> f)
  • public static Task<Result<K, E>> BindWithTransactionScope<T, K, E>(this Task<Result<T, E>> self, Func<T, Result<K, E>> f)
  • public static Task<Result<K>> BindWithTransactionScope<T, K>(this Task<Result<T>> self, Func<T, Result<K>> f)
  • public static Task<Result<K>> BindWithTransactionScope<K>(this Task<Result> self, Func<Result<K>> f)
  • public static Task<Result> BindWithTransactionScope<T>(this Task<Result<T>> self, Func<T, Result> f)
  • public static Task<Result> BindWithTransactionScope(this Task<Result> self, Func<Result> f)
  • public static Task<Result<K, E>> BindWithTransactionScope<T, K, E>(this Result<T, E> self, Func<T, Task<Result<K, E>>> f)
  • public static Task<Result<K>> BindWithTransactionScope<T, K>(this Result<T> self, Func<T, Task<Result<K>>> f)
  • public static Task<Result<K>> BindWithTransactionScope<K>(this Result self, Func<Task<Result<K>>> f)
  • public static Task<Result> BindWithTransactionScope<T>(this Result<T> self, Func<T, Task<Result>> f)
  • public static Task<Result> BindWithTransactionScope(this Result self, Func<Task<Result>> f)
  • public static Result<T> Check<T>(this Result<T> result, Func<T, Result> func)
  • public static Result<T> Check<T, K>(this Result<T> result, Func<T, Result<K>> func)
  • public static Result<T, E> Check<T, K, E>(this Result<T, E> result, Func<T, Result<K, E>> func)
  • public static Result<T, E> Check<T, E>(this Result<T, E> result, Func<T, UnitResult<E>> func)
  • public static UnitResult<E> Check<E>(this UnitResult<E> result, Func<UnitResult<E>> func)
  • public static Result<T> CheckIf<T>(this Result<T> result, bool condition, Func<T, Result> func)
  • public static Result<T> CheckIf<T, K>(this Result<T> result, bool condition, Func<T, Result<K>> func)
  • public static Result<T, E> CheckIf<T, K, E>(this Result<T, E> result, bool condition, Func<T, Result<K, E>> func)
  • public static Result<T, E> CheckIf<T, E>(this Result<T, E> result, bool condition, Func<T, UnitResult<E>> func)
  • public static UnitResult<E> CheckIf<E>(this UnitResult<E> result, bool condition, Func<UnitResult<E>> func)
  • public static Result<T> CheckIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Result> func)
  • public static Result<T> CheckIf<T, K>(this Result<T> result, Func<T, bool> predicate, Func<T, Result<K>> func)
  • public static Result<T, E> CheckIf<T, K, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Result<K, E>> func)
  • public static Result<T, E> CheckIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, UnitResult<E>> func)
  • public static UnitResult<E> CheckIf<E>(this UnitResult<E> result, Func<bool> predicate, Func<UnitResult<E>> func)
  • public static Result Combine(this IEnumerable<Result> results, string errorMessageSeparator = null)
  • public static UnitResult<E> Combine<E>(this IEnumerable<UnitResult<E>> results) where E : ICombine
  • public static Result<IEnumerable<T>, E> Combine<T, E>(this IEnumerable<Result<T, E>> results) where E : ICombine
  • public static Result<IEnumerable<T>, E> Combine<T, E>(this IEnumerable<Result<T, E>> results, Func<IEnumerable<E>, E> composerError)
  • public static Result<IEnumerable<T>> Combine<T>(this IEnumerable<Result<T>> results, string errorMessageSeparator = null)
  • public static Result<K, E> Combine<T, K, E>(this IEnumerable<Result<T, E>> results, Func<IEnumerable<T>, K> composer, Func<IEnumerable<E>, E> composerError)
  • public static Result<K, E> Combine<T, K, E>(this IEnumerable<Result<T, E>> results, Func<IEnumerable<T>, K> composer) where E : ICombine
  • public static Result<K> Combine<T, K>(this IEnumerable<Result<T>> results, Func<IEnumerable<T>, K> composer, string errorMessageSeparator = null)
  • public static Result Compensate(this Result result, Func<string, Result> func)
  • public static UnitResult<E> Compensate<E>(this Result result, Func<string, UnitResult<E>> func)
  • public static Result Compensate<T>(this Result<T> result, Func<string, Result> func)
  • public static Result<T> Compensate<T>(this Result<T> result, Func<string, Result<T>> func)
  • public static Result<T, E> Compensate<T, E>(this Result<T> result, Func<string, Result<T, E>> func)
  • public static Result Compensate<E>(this UnitResult<E> result, Func<E, Result> func)
  • public static UnitResult<E2> Compensate<E, E2>(this UnitResult<E> result, Func<E, UnitResult<E2>> func)
  • public static Result Compensate<T, E>(this Result<T, E> result, Func<E, Result> func)
  • public static UnitResult<E2> Compensate<T, E, E2>(this Result<T, E> result, Func<E, UnitResult<E2>> func)
  • public static Result<T, E2> Compensate<T, E, E2>(this Result<T, E> result, Func<E, Result<T, E2>> func)
  • public static Task<Result> Compensate(this Task<Result> resultTask, Func<string, Task<Result>> func)
  • public static Task<UnitResult<E>> Compensate<E>(this Task<Result> resultTask, Func<string, Task<UnitResult<E>>> func)
  • public static Task<Result> Compensate<T>(this Task<Result<T>> resultTask, Func<string, Task<Result>> func)
  • public static Task<Result<T>> Compensate<T>(this Task<Result<T>> resultTask, Func<string, Task<Result<T>>> func)
  • public static Task<Result<T, E>> Compensate<T, E>(this Task<Result<T>> resultTask, Func<string, Task<Result<T, E>>> func)
  • public static Task<Result> Compensate<E>(this Task<UnitResult<E>> resultTask, Func<E, Task<Result>> func)
  • public static Task<UnitResult<E2>> Compensate<E, E2>(this Task<UnitResult<E>> resultTask, Func<E, Task<UnitResult<E2>>> func)
  • public static Task<Result> Compensate<T, E>(this Task<Result<T, E>> resultTask, Func<E, Task<Result>> func)
  • public static Task<UnitResult<E2>> Compensate<T, E, E2>(this Task<Result<T, E>> resultTask, Func<E, Task<UnitResult<E2>>> func)
  • public static Task<Result<T, E2>> Compensate<T, E, E2>(this Task<Result<T, E>> resultTask, Func<E, Task<Result<T, E2>>> func)
  • public static Task<Result> Compensate(this Task<Result> resultTask, Func<string, Result> func)
  • public static Task<UnitResult<E>> Compensate<E>(this Task<Result> resultTask, Func<string, UnitResult<E>> func)
  • public static Task<Result> Compensate<T>(this Task<Result<T>> resultTask, Func<string, Result> func)
  • public static Task<Result<T>> Compensate<T>(this Task<Result<T>> resultTask, Func<string, Result<T>> func)
  • public static Task<Result<T, E>> Compensate<T, E>(this Task<Result<T>> resultTask, Func<string, Result<T, E>> func)
  • public static Task<Result> Compensate<E>(this Task<UnitResult<E>> resultTask, Func<E, Result> func)
  • public static Task<UnitResult<E2>> Compensate<E, E2>(this Task<UnitResult<E>> resultTask, Func<E, UnitResult<E2>> func)
  • public static Task<Result> Compensate<T, E>(this Task<Result<T, E>> resultTask, Func<E, Result> func)
  • public static Task<UnitResult<E2>> Compensate<T, E, E2>(this Task<Result<T, E>> resultTask, Func<E, UnitResult<E2>> func)
  • public static Task<Result<T, E2>> Compensate<T, E, E2>(this Task<Result<T, E>> resultTask, Func<E, Result<T, E2>> func)
  • public static Task<Result> Compensate(this Result result, Func<string, Task<Result>> func)
  • public static Task<UnitResult<E>> Compensate<E>(this Result result, Func<string, Task<UnitResult<E>>> func)
  • public static Task<Result> Compensate<T>(this Result<T> result, Func<string, Task<Result>> func)
  • public static Task<Result<T>> Compensate<T>(this Result<T> result, Func<string, Task<Result<T>>> func)
  • public static Task<Result<T, E>> Compensate<T, E>(this Result<T> result, Func<string, Task<Result<T, E>>> func)
  • public static Task<Result> Compensate<E>(this UnitResult<E> result, Func<E, Task<Result>> func)
  • public static Task<UnitResult<E2>> Compensate<E, E2>(this UnitResult<E> result, Func<E, Task<UnitResult<E2>>> func)
  • public static Task<Result> Compensate<T, E>(this Result<T, E> result, Func<E, Task<Result>> func)
  • public static Task<UnitResult<E2>> Compensate<T, E, E2>(this Result<T, E> result, Func<E, Task<UnitResult<E2>>> func)
  • public static Task<Result<T, E2>> Compensate<T, E, E2>(this Result<T, E> result, Func<E, Task<Result<T, E2>>> func)
  • public static void Deconstruct(this Result result, out bool isSuccess, out bool isFailure)
  • public static void Deconstruct(this Result result, out bool isSuccess, out bool isFailure, out string error)
  • public static void Deconstruct<T>(this Result<T> result, out bool isSuccess, out bool isFailure)
  • public static void Deconstruct<T>(this Result<T> result, out bool isSuccess, out bool isFailure, out T value)
  • public static void Deconstruct<T>(this Result<T> result, out bool isSuccess, out bool isFailure, out T value, out string error)
  • public static void Deconstruct<T, E>(this Result<T, E> result, out bool isSuccess, out bool isFailure)
  • public static void Deconstruct<T, E>(this Result<T, E> result, out bool isSuccess, out bool isFailure, out T value)
  • public static void Deconstruct<T, E>(this Result<T, E> result, out bool isSuccess, out bool isFailure, out T value, out E error)
  • public static Result<T, E> Ensure<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, E> errorPredicate)
  • public static Result<T, E> Ensure<T, E>(this Result<T, E> result, Func<T, bool> predicate, E error)
  • public static Result<T> Ensure<T>(this Result<T> result, Func<T, bool> predicate, Func<T, string> errorPredicate)
  • public static Result Ensure(this Result result, Func<Result> predicate)
  • public static Result<T> Ensure<T>(this Result<T> result, Func<Result> predicate)
  • public static Result Ensure<T>(this Result result, Func<Result<T>> predicate)
  • public static Result<T> Ensure<T>(this Result<T> result, Func<Result<T>> predicate)
  • public static Result<T> Ensure<T>(this Result<T> result, Func<T, Result> predicate)
  • public static Result<T> Ensure<T>(this Result<T> result, Func<T, Result<T>> predicate)
  • public static UnitResult<E> Ensure<E>(this UnitResult<E> result, Func<bool> predicate, Func<E> errorPredicate)
  • public static UnitResult<E> Ensure<E>(this UnitResult<E> result, Func<bool> predicate, E error)
  • public static UnitResult<E> Ensure<E>(this UnitResult<E> result, Func<UnitResult<E>> predicate)
  • public static Result<T> EnsureNotNull<T>(this Result<T> result, string error)
  • public static Result<T> EnsureNotNull<T>(this Result<T?> result, string error) where T : struct
  • public static Result<T> EnsureNotNull<T>(this Result<T> result, Func<string> errorFactory)
  • public static Result<T> EnsureNotNull<T>(this Result<T?> result, Func<string> errorFactory) where T : struct
  • public static Result<T, E> EnsureNotNull<T, E>(this Result<T, E> result, E error)
  • public static Result<T, E> EnsureNotNull<T, E>(this Result<T?, E> result, E error) where T : struct
  • public static Result<T, E> EnsureNotNull<T, E>(this Result<T, E> result, Func<E> errorFactory)
  • public static Result<T, E> EnsureNotNull<T, E>(this Result<T?, E> result, Func<E> errorFactory) where T : struct
  • public static Task<Result<T>> EnsureNotNull<T>(this Task<Result<T>> resultTask, string error)
  • public static Task<Result<T>> EnsureNotNull<T>(this Task<Result<T?>> resultTask, string error) where T : struct
  • public static Task<Result<T>> EnsureNotNull<T>(this Task<Result<T>> resultTask, Func<Task<string>> errorFactory)
  • public static Task<Result<T>> EnsureNotNull<T>(this Task<Result<T?>> resultTask, Func<Task<string>> errorFactory) where T : struct
  • public static Task<Result<T, E>> EnsureNotNull<T, E>(this Task<Result<T, E>> resultTask, E error)
  • public static Task<Result<T, E>> EnsureNotNull<T, E>(this Task<Result<T?, E>> resultTask, E error) where T : struct
  • public static Task<Result<T, E>> EnsureNotNull<T, E>(this Task<Result<T, E>> resultTask, Func<Task<E>> errorFactory)
  • public static Task<Result<T, E>> EnsureNotNull<T, E>(this Task<Result<T?, E>> resultTask, Func<Task<E>> errorFactory) where T : struct
  • public static Task<Result<T>> EnsureNotNull<T>(this Task<Result<T>> resultTask, Func<string> errorFactory)
  • public static Task<Result<T>> EnsureNotNull<T>(this Task<Result<T?>> resultTask, Func<string> errorFactory) where T : struct
  • public static Task<Result<T, E>> EnsureNotNull<T, E>(this Task<Result<T, E>> resultTask, Func<E> errorFactory)
  • public static Task<Result<T, E>> EnsureNotNull<T, E>(this Task<Result<T?, E>> resultTask, Func<E> errorFactory) where T : struct
  • public static Task<Result<T>> EnsureNotNull<T>(this Result<T> result, Func<Task<string>> errorFactory)
  • public static Task<Result<T>> EnsureNotNull<T>(this Result<T?> result, Func<Task<string>> errorFactory) where T : struct
  • public static Task<Result<T, E>> EnsureNotNull<T, E>(this Result<T, E> result, Func<Task<E>> errorFactory)
  • public static Task<Result<T, E>> EnsureNotNull<T, E>(this Result<T?, E> result, Func<Task<E>> errorFactory) where T : struct
  • public static T Finally<T>(this Result result, Func<Result, T> func)
  • public static K Finally<T, K>(this Result<T> result, Func<Result<T>, K> func)
  • public static K Finally<K, E>(this UnitResult<E> result, Func<UnitResult<E>, K> func)
  • public static K Finally<T, K, E>(this Result<T, E> result, Func<Result<T, E>, K> func)
  • public static T GetValueOrDefault<T>(this ref Result result, Func<T> defaultValue)
  • public static K GetValueOrDefault<T, K>(this ref Result result, Func<T, K> selector, K defaultValue = null)
  • public static K GetValueOrDefault<T, K>(this ref Result result, Func<T, K> selector, Func<K> defaultValue)
  • public static Task<T> GetValueOrDefault<T>(this Task<Result<T>> resultTask, Func<Task<T>> defaultValue)
  • public static Task<K> GetValueOrDefault<T, K>(this Task<Result<T>> resultTask, Func<T, Task<K>> selector, K defaultValue = null)
  • public static Task<K> GetValueOrDefault<T, K>(this Task<Result<T>> resultTask, Func<T, Task<K>> selector, Func<Task<K>> defaultValue)
  • public static Task<T> GetValueOrDefault<T>(this Task<Result<T>> resultTask, Func<T> defaultValue)
  • public static Task<K> GetValueOrDefault<T, K>(this Task<Result<T>> resultTask, Func<T, K> selector, K defaultValue = null)
  • public static Task<K> GetValueOrDefault<T, K>(this Task<Result<T>> resultTask, Func<T, K> selector, Func<K> defaultValue)
  • public static Task<T> GetValueOrDefault<T>(this Result<T> result, Func<Task<T>> defaultValue)
  • public static Task<K> GetValueOrDefault<T, K>(this Result<T> result, Func<T, K> selector, Func<Task<K>> defaultValue)
  • public static Task<K> GetValueOrDefault<T, K>(this Result<T> result, Func<T, Task<K>> selector, K defaultValue = null)
  • public static Task<K> GetValueOrDefault<T, K>(this Result<T> result, Func<T, Task<K>> selector, Func<Task<K>> defaultValue)
  • public static Result<K, E> Map<T, K, E>(this Result<T, E> result, Func<T, K> func)
  • public static Result<K, E> Map<K, E>(this UnitResult<E> result, Func<K> func)
  • public static Result<K> Map<K>(this Result result, Func<K> func)
  • public static Result MapError(this Result result, Func<string, string> errorFactory)
  • public static UnitResult<E> MapError<E>(this Result result, Func<string, E> errorFactory)
  • public static Result<T> MapError<T>(this Result<T> result, Func<string, string> errorFactory)
  • public static Result<T, E> MapError<T, E>(this Result<T> result, Func<string, E> errorFactory)
  • public static Result MapError<E>(this UnitResult<E> result, Func<E, string> errorFactory)
  • public static UnitResult<E2> MapError<E, E2>(this UnitResult<E> result, Func<E, E2> errorFactory)
  • public static Result<T> MapError<T, E>(this Result<T, E> result, Func<E, string> errorFactory)
  • public static Result<T, E2> MapError<T, E, E2>(this Result<T, E> result, Func<E, E2> errorFactory)
  • public static Task<Result> MapError(this Task<Result> resultTask, Func<string, Task<string>> errorFactory)
  • public static Task<UnitResult<E>> MapError<E>(this Task<Result> resultTask, Func<string, Task<E>> errorFactory)
  • public static Task<Result<T>> MapError<T>(this Task<Result<T>> resultTask, Func<string, Task<string>> errorFactory)
  • public static Task<Result<T, E>> MapError<T, E>(this Task<Result<T>> resultTask, Func<string, Task<E>> errorFactory)
  • public static Task<Result> MapError<E>(this Task<UnitResult<E>> resultTask, Func<E, Task<string>> errorFactory)
  • public static Task<UnitResult<E2>> MapError<E, E2>(this Task<UnitResult<E>> resultTask, Func<E, Task<E2>> errorFactory)
  • public static Task<Result<T>> MapError<T, E>(this Task<Result<T, E>> resultTask, Func<E, Task<string>> errorFactory)
  • public static Task<Result<T, E2>> MapError<T, E, E2>(this Task<Result<T, E>> resultTask, Func<E, Task<E2>> errorFactory)
  • public static Task<Result> MapError(this Task<Result> resultTask, Func<string, string> errorFactory)
  • public static Task<UnitResult<E>> MapError<E>(this Task<Result> resultTask, Func<string, E> errorFactory)
  • public static Task<Result<T>> MapError<T>(this Task<Result<T>> resultTask, Func<string, string> errorFactory)
  • public static Task<Result<T, E>> MapError<T, E>(this Task<Result<T>> resultTask, Func<string, E> errorFactory)
  • public static Task<Result> MapError<E>(this Task<UnitResult<E>> resultTask, Func<E, string> errorFactory)
  • public static Task<UnitResult<E2>> MapError<E, E2>(this Task<UnitResult<E>> resultTask, Func<E, E2> errorFactory)
  • public static Task<Result<T>> MapError<T, E>(this Task<Result<T, E>> resultTask, Func<E, string> errorFactory)
  • public static Task<Result<T, E2>> MapError<T, E, E2>(this Task<Result<T, E>> resultTask, Func<E, E2> errorFactory)
  • public static Task<Result> MapError(this Result result, Func<string, Task<string>> errorFactory)
  • public static Task<UnitResult<E>> MapError<E>(this Result result, Func<string, Task<E>> errorFactory)
  • public static Task<Result<T>> MapError<T>(this Result<T> result, Func<string, Task<string>> errorFactory)
  • public static Task<Result<T, E>> MapError<T, E>(this Result<T> result, Func<string, Task<E>> errorFactory)
  • public static Task<Result> MapError<E>(this UnitResult<E> result, Func<E, Task<string>> errorFactory)
  • public static Task<UnitResult<E2>> MapError<E, E2>(this UnitResult<E> result, Func<E, Task<E2>> errorFactory)
  • public static Task<Result<T>> MapError<T, E>(this Result<T, E> result, Func<E, Task<string>> errorFactory)
  • public static Task<Result<T, E2>> MapError<T, E, E2>(this Result<T, E> result, Func<E, Task<E2>> errorFactory)
  • public static Result<T> MapIf<T>(this Result<T> result, bool condition, Func<T, T> func)
  • public static Result<T, E> MapIf<T, E>(this Result<T, E> result, bool condition, Func<T, T> func)
  • public static Result<T> MapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, T> func)
  • public static Result<T, E> MapIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, T> func)
  • public static Task<Result<T>> MapIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Task<T>> func)
  • public static Task<Result<T, E>> MapIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Task<T>> func)
  • public static Task<Result<T>> MapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task<T>> func)
  • public static Task<Result<T, E>> MapIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Task<T>> func)
  • public static Task<Result<T>> MapIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, T> func)
  • public static Task<Result<T, E>> MapIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, T> func)
  • public static Task<Result<T>> MapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, T> func)
  • public static Task<Result<T, E>> MapIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, T> func)
  • public static Task<Result<T>> MapIf<T>(this Result<T> result, bool condition, Func<T, Task<T>> func)
  • public static Task<Result<T, E>> MapIf<T, E>(this Result<T, E> result, bool condition, Func<T, Task<T>> func)
  • public static Task<Result<T>> MapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Task<T>> func)
  • public static Task<Result<T, E>> MapIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Task<T>> func)
  • public static Result<K, E> MapTry<T, K, E>(this Result<T, E> result, Func<T, K> func, Func<Exception, E> errorHandler)
  • public static Result<K, E> MapTry<K, E>(this UnitResult<E> result, Func<K> func, Func<Exception, E> errorHandler)
  • public static Result<K> MapTry<T, K>(this Result<T> result, Func<T, K> func, Func<Exception, string> errorHandler = null)
  • public static Result<K> MapTry<K>(this Result result, Func<K> func, Func<Exception, string> errorHandler = null)
  • public static Result<K> MapWithTransactionScope<T, K>(this Result<T> self, Func<T, K> f)
  • public static Result<K> MapWithTransactionScope<K>(this Result self, Func<K> f)
  • public static Task<Result<K>> MapWithTransactionScope<T, K>(this Task<Result<T>> self, Func<T, Task<K>> f)
  • public static Task<Result<K>> MapWithTransactionScope<K>(this Task<Result> self, Func<Task<K>> f)
  • public static Task<Result<K>> MapWithTransactionScope<T, K>(this Task<Result<T>> self, Func<T, K> f)
  • public static Task<Result<K>> MapWithTransactionScope<K>(this Task<Result> self, Func<K> f)
  • public static Task<Result<K>> MapWithTransactionScope<T, K>(this Result<T> self, Func<T, Task<K>> f)
  • public static Task<Result<K>> MapWithTransactionScope<K>(this Result self, Func<Task<K>> f)
  • public static K Match<T, K, E>(this Result<T, E> result, Func<T, K> onSuccess, Func<E, K> onFailure)
  • public static K Match<K, T>(this Result<T> result, Func<T, K> onSuccess, Func<string, K> onFailure)
  • public static T Match<T>(this Result result, Func<T> onSuccess, Func<string, T> onFailure)
  • public static K Match<K, E>(this UnitResult<E> result, Func<K> onSuccess, Func<E, K> onFailure)
  • public static void Match<T, E>(this Result<T, E> result, Action<T> onSuccess, Action<E> onFailure)
  • public static void Match<E>(this UnitResult<E> result, Action onSuccess, Action<E> onFailure)
  • public static void Match<T>(this Result<T> result, Action<T> onSuccess, Action<string> onFailure)
  • public static void Match(this Result result, Action onSuccess, Action<string> onFailure)
  • public static Result<T> Map<T>(this Result result, Func<T> func)
  • public static K OnBoth<T, K, E>(this Result<T, E> result, Func<Result<T, E>, K> func)
  • public static Result<T, E> OnFailure<T, E>(this Result<T, E> result, Action action)
  • public static UnitResult<E> OnFailure<E>(this UnitResult<E> result, Action<E> action)
  • public static UnitResult<E> OnFailure<E>(this UnitResult<E> result, Action action)
  • public static Result<T, E> OnFailure<T, E>(this Result<T, E> result, Action<E> action)
  • public static Task<Result<T, E>> OnFailure<T, E>(this Task<Result<T, E>> resultTask, Func<Task> func)
  • public static Task<Result<T>> OnFailure<T>(this Task<Result<T>> resultTask, Func<Task> func)
  • public static Task<Result> OnFailure(this Task<Result> resultTask, Func<Task> func)
  • public static Task<Result> OnFailure(this Task<Result> resultTask, Func<string, Task> func)
  • public static Task<UnitResult<E>> OnFailure<E>(this Task<UnitResult<E>> resultTask, Func<E, Task> func)
  • public static Task<UnitResult<E>> OnFailure<E>(this Task<UnitResult<E>> resultTask, Func<Task> func)
  • public static Task<Result<T>> OnFailure<T>(this Task<Result<T>> resultTask, Func<string, Task> func)
  • public static Task<Result<T, E>> OnFailure<T, E>(this Task<Result<T, E>> resultTask, Func<E, Task> func)
  • public static Task<Result<T>> OnFailure<T>(this Task<Result<T>> resultTask, Action action)
  • public static Task<Result> OnFailure(this Task<Result> resultTask, Action action)
  • public static Task<Result<T, E>> OnFailure<T, E>(this Task<Result<T, E>> resultTask, Action action)
  • public static Task<UnitResult<E>> OnFailure<E>(this Task<UnitResult<E>> resultTask, Action action)
  • public static Task<UnitResult<E>> OnFailure<E>(this Task<UnitResult<E>> resultTask, Action<E> action)
  • public static Task<Result<T>> OnFailure<T>(this Task<Result<T>> resultTask, Action<string> action)
  • public static Task<Result<T, E>> OnFailure<T, E>(this Task<Result<T, E>> resultTask, Action<E> action)
  • public static Task<Result> OnFailure(this Task<Result> resultTask, Action<string> action)
  • public static Task<Result<T>> OnFailure<T>(this Result<T> result, Func<Task> func)
  • public static Task<Result<T, E>> OnFailure<T, E>(this Result<T, E> result, Func<Task> func)
  • public static Task<Result> OnFailure(this Result result, Func<Task> func)
  • public static Task<Result> OnFailure(this Result result, Func<string, Task> func)
  • public static Task<UnitResult<E>> OnFailure<E>(this UnitResult<E> result, Func<Task> func)
  • public static Task<UnitResult<E>> OnFailure<E>(this UnitResult<E> result, Func<E, Task> func)
  • public static Task<Result<T>> OnFailure<T>(this Result<T> result, Func<string, Task> func)
  • public static Task<Result<T, E>> OnFailure<T, E>(this Result<T, E> result, Func<E, Task> func)
  • public static Result<T, E> OnFailureCompensate<T, E>(this Result<T, E> result, Func<Result<T, E>> func)
  • public static Result<T> OnFailureCompensate<T>(this Result<T> result, Func<Result<T>> func)
  • public static Result OnFailureCompensate(this Result result, Func<Result> func)
  • public static Result<T, E> OnFailureCompensate<T, E>(this Result<T, E> result, Func<E, Result<T, E>> func)
  • public static Result<T> OnFailureCompensate<T>(this Result<T> result, Func<string, Result<T>> func)
  • public static Result OnFailureCompensate(this Result result, Func<string, Result> func)
  • public static Result<K, E> OnSuccess<T, K, E>(this Result<T, E> result, Func<T, K> func)
  • public static Result<K> OnSuccess<K>(this Result result, Func<K> func)
  • public static Result<K, E> OnSuccess<T, K, E>(this Result<T, E> result, Func<T, Result<K, E>> func)
  • public static Result<T> OnSuccess<T>(this Result result, Func<T> func)
  • public static Result<K> OnSuccess<K>(this Result result, Func<Result<K>> func)
  • public static Result<T> OnSuccess<T>(this Result result, Func<Result<T>> func)
  • public static Result<K> OnSuccess<T, K>(this Result<T> result, Func<Result<K>> func)
  • public static Result<T, E> OnSuccess<T, E>(this Result<T, E> result, Action<T> action)
  • public static Result OnSuccessTry(this Result result, Action action, Func<Exception, string> errorHandler = null)
  • public static Result OnSuccessTry<T>(this Result<T> result, Action<T> action, Func<Exception, string> errorHandler = null)
  • public static Task<Result> OnSuccessTry(this Task<Result> task, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result> OnSuccessTry<T>(this Task<Result<T>> task, Func<T, Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result> OnSuccessTry(this Task<Result> task, Action action, Func<Exception, string> errorHandler = null)
  • public static Task<Result> OnSuccessTry<T>(this Task<Result<T>> task, Action<T> action, Func<Exception, string> errorHandler = null)
  • public static Task<Result> OnSuccessTry(this Result result, Func<Task> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result> OnSuccessTry<T>(this Result<T> result, Func<T, Task> func, Func<Exception, string> errorHandler = null)
  • public static Result<T> OnSuccessTry<T>(this Result result, Func<T> func, Func<Exception, string> errorHandler = null)
  • public static Result<K> OnSuccessTry<T, K>(this Result<T> result, Func<T, K> func, Func<Exception, string> errorHandler = null)
  • public static Result<K, E> OnSuccessTry<T, K, E>(this Result<T, E> result, Func<T, K> func, Func<Exception, E> errorHandler)
  • public static Result<T, E> OnSuccessTry<T, E>(this Result<T, E> result, Func<T> func, Func<Exception, E> errorHandler)
  • public static Task<Result<T>> OnSuccessTry<T>(this Task<Result> task, Func<Task<T>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> OnSuccessTry<T, K>(this Task<Result<T>> task, Func<T, Task<K>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K, E>> OnSuccessTry<T, K, E>(this Task<Result<T, E>> task, Func<T, Task<K>> func, Func<Exception, E> errorHandler = null)
  • public static Task<Result<T, E>> OnSuccessTry<T, E>(this Task<Result<T, E>> task, Func<Task<T>> func, Func<Exception, E> errorHandler = null)
  • public static Task<Result<T>> OnSuccessTry<T>(this Task<Result> task, Func<T> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> OnSuccessTry<T, K>(this Task<Result<T>> task, Func<T, K> action, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K, E>> OnSuccessTry<T, K, E>(this Task<Result<T, E>> task, Func<T, K> action, Func<Exception, E> errorHandler = null)
  • public static Task<Result<T, E>> OnSuccessTry<T, E>(this Task<Result<T, E>> task, Func<T> func, Func<Exception, E> errorHandler = null)
  • public static Task<Result<T>> OnSuccessTry<T>(this Result result, Func<Task<T>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K>> OnSuccessTry<T, K>(this Result<T> result, Func<T, Task<K>> func, Func<Exception, string> errorHandler = null)
  • public static Task<Result<K, E>> OnSuccessTry<T, K, E>(this Result<T, E> result, Func<T, Task<K>> func, Func<Exception, E> errorHandler = null)
  • public static Task<Result<T, E>> OnSuccessTry<T, E>(this Result<T, E> result, Func<Task<T>> func, Func<Exception, E> errorHandler = null)
  • public static Result<K> OnSuccessWithTransactionScope<T, K>(this Result<T> self, Func<T, K> f)
  • public static Result<K> OnSuccessWithTransactionScope<K>(this Result self, Func<K> f)
  • public static Result<K> OnSuccessWithTransactionScope<T, K>(this Result<T> self, Func<T, Result<K>> f)
  • public static Result<K> OnSuccessWithTransactionScope<K>(this Result self, Func<Result<K>> f)
  • public static Result OnSuccessWithTransactionScope<T>(this Result<T> self, Func<T, Result> f)
  • public static Result OnSuccessWithTransactionScope(this Result self, Func<Result> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<T, K>(this Task<Result<T>> self, Func<T, Task<K>> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<K>(this Task<Result> self, Func<Task<K>> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<T, K>(this Task<Result<T>> self, Func<T, Task<Result<K>>> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<K>(this Task<Result> self, Func<Task<Result<K>>> f)
  • public static Task<Result> OnSuccessWithTransactionScope<T>(this Task<Result<T>> self, Func<T, Task<Result>> f)
  • public static Task<Result> OnSuccessWithTransactionScope(this Task<Result> self, Func<Task<Result>> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<T, K>(this Task<Result<T>> self, Func<T, K> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<K>(this Task<Result> self, Func<K> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<T, K>(this Task<Result<T>> self, Func<T, Result<K>> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<K>(this Task<Result> self, Func<Result<K>> f)
  • public static Task<Result> OnSuccessWithTransactionScope<T>(this Task<Result<T>> self, Func<T, Result> f)
  • public static Task<Result> OnSuccessWithTransactionScope(this Task<Result> self, Func<Result> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<T, K>(this Result<T> self, Func<T, Task<K>> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<K>(this Result self, Func<Task<K>> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<T, K>(this Result<T> self, Func<T, Task<Result<K>>> f)
  • public static Task<Result<K>> OnSuccessWithTransactionScope<K>(this Result self, Func<Task<Result<K>>> f)
  • public static Task<Result> OnSuccessWithTransactionScope<T>(this Result<T> self, Func<T, Task<Result>> f)
  • public static Task<Result> OnSuccessWithTransactionScope(this Result self, Func<Task<Result>> f)
  • public static Result<TR> SelectMany<T, TK, TR>(this Result<T> result, Func<T, Result<TK>> func, Func<T, TK, TR> project)
  • public static Result<TR, TE> SelectMany<T, TK, TE, TR>(this Result<T, TE> result, Func<T, Result<TK, TE>> func, Func<T, TK, TR> project)
  • public static Task<Result<TR>> SelectMany<T, TK, TR>(this Task<Result<T>> resultTask, Func<T, Task<Result<TK>>> func, Func<T, TK, TR> project)
  • public static Task<Result<TR, TE>> SelectMany<T, TK, TE, TR>(this Task<Result<T, TE>> resultTask, Func<T, Task<Result<TK, TE>>> func, Func<T, TK, TR> project)
  • public static Task<Result<TR>> SelectMany<T, TK, TR>(this Task<Result<T>> resultTask, Func<T, Result<TK>> func, Func<T, TK, TR> project)
  • public static Task<Result<TR, TE>> SelectMany<T, TK, TE, TR>(this Task<Result<T, TE>> resultTask, Func<T, Result<TK, TE>> func, Func<T, TK, TR> project)
  • public static Task<Result<TR>> SelectMany<T, TK, TR>(this Result<T> result, Func<T, Task<Result<TK>>> func, Func<T, TK, TR> project)
  • public static Task<Result<TR, TE>> SelectMany<T, TK, TE, TR>(this Result<T, TE> result, Func<T, Task<Result<TK, TE>>> func, Func<T, TK, TR> project)
  • public static Result Tap(this Result result, Action action)
  • public static Result<T> Tap<T>(this Result<T> result, Action action)
  • public static Result<T> Tap<T>(this Result<T> result, Action<T> action)
  • public static UnitResult<E> Tap<E>(this UnitResult<E> result, Action action)
  • public static Result<T, E> Tap<T, E>(this Result<T, E> result, Action action)
  • public static Result<T, E> Tap<T, E>(this Result<T, E> result, Action<T> action)
  • public static Result<T> Tap<T>(this Result<T> result, Func<T, Result> func)
  • public static Result<T> Tap<T, K>(this Result<T> result, Func<T, Result<K>> func)
  • public static Result<T, E> Tap<T, K, E>(this Result<T, E> result, Func<T, Result<K, E>> func)
  • public static Result<T, E> TapError<T, E>(this Result<T, E> result, Action action)
  • public static Result<T> TapError<T>(this Result<T> result, Action action)
  • public static Result TapError(this Result result, Action action)
  • public static UnitResult<E> TapError<E>(this UnitResult<E> result, Action<E> action)
  • public static UnitResult<E> TapError<E>(this UnitResult<E> result, Action action)
  • public static Result<T, E> TapError<T, E>(this Result<T, E> result, Action<E> action)
  • public static Result<T> TapError<T>(this Result<T> result, Action<string> action)
  • public static Result TapError(this Result result, Action<string> action)
  • public static Task<Result<T, E>> TapError<T, E>(this Task<Result<T, E>> resultTask, Func<Task> func)
  • public static Task<Result<T>> TapError<T>(this Task<Result<T>> resultTask, Func<Task> func)
  • public static Task<Result> TapError(this Task<Result> resultTask, Func<Task> func)
  • public static Task<Result> TapError(this Task<Result> resultTask, Func<string, Task> func)
  • public static Task<UnitResult<E>> TapError<E>(this Task<UnitResult<E>> resultTask, Func<E, Task> func)
  • public static Task<UnitResult<E>> TapError<E>(this Task<UnitResult<E>> resultTask, Func<Task> func)
  • public static Task<Result<T>> TapError<T>(this Task<Result<T>> resultTask, Func<string, Task> func)
  • public static Task<Result<T, E>> TapError<T, E>(this Task<Result<T, E>> resultTask, Func<E, Task> func)
  • public static Task<Result<T>> TapError<T>(this Task<Result<T>> resultTask, Action action)
  • public static Task<Result> TapError(this Task<Result> resultTask, Action action)
  • public static Task<Result<T, E>> TapError<T, E>(this Task<Result<T, E>> resultTask, Action action)
  • public static Task<UnitResult<E>> TapError<E>(this Task<UnitResult<E>> resultTask, Action action)
  • public static Task<UnitResult<E>> TapError<E>(this Task<UnitResult<E>> resultTask, Action<E> action)
  • public static Task<Result<T>> TapError<T>(this Task<Result<T>> resultTask, Action<string> action)
  • public static Task<Result<T, E>> TapError<T, E>(this Task<Result<T, E>> resultTask, Action<E> action)
  • public static Task<Result> TapError(this Task<Result> resultTask, Action<string> action)
  • public static Task<Result<T>> TapError<T>(this Result<T> result, Func<Task> func)
  • public static Task<Result<T, E>> TapError<T, E>(this Result<T, E> result, Func<Task> func)
  • public static Task<Result> TapError(this Result result, Func<Task> func)
  • public static Task<Result> TapError(this Result result, Func<string, Task> func)
  • public static Task<UnitResult<E>> TapError<E>(this UnitResult<E> result, Func<Task> func)
  • public static Task<UnitResult<E>> TapError<E>(this UnitResult<E> result, Func<E, Task> func)
  • public static Task<Result<T>> TapError<T>(this Result<T> result, Func<string, Task> func)
  • public static Task<Result<T, E>> TapError<T, E>(this Result<T, E> result, Func<E, Task> func)
  • public static Result TapErrorIf(this Result result, bool condition, Action action)
  • public static Result TapErrorIf(this Result result, bool condition, Action<string> action)
  • public static Result<T> TapErrorIf<T>(this Result<T> result, bool condition, Action action)
  • public static Result<T> TapErrorIf<T>(this Result<T> result, bool condition, Action<string> action)
  • public static UnitResult<E> TapErrorIf<E>(this UnitResult<E> result, bool condition, Action action)
  • public static UnitResult<E> TapErrorIf<E>(this UnitResult<E> result, bool condition, Action<E> action)
  • public static Result<T, E> TapErrorIf<T, E>(this Result<T, E> result, bool condition, Action action)
  • public static Result<T, E> TapErrorIf<T, E>(this Result<T, E> result, bool condition, Action<E> action)
  • public static Result TapErrorIf(this Result result, Func<string, bool> predicate, Action action)
  • public static Result TapErrorIf(this Result result, Func<string, bool> predicate, Action<string> action)
  • public static Result<T> TapErrorIf<T>(this Result<T> result, Func<string, bool> predicate, Action action)
  • public static Result<T> TapErrorIf<T>(this Result<T> result, Func<string, bool> predicate, Action<string> action)
  • public static Result<T, E> TapErrorIf<T, E>(this Result<T, E> result, Func<E, bool> predicate, Action action)
  • public static Result<T, E> TapErrorIf<T, E>(this Result<T, E> result, Func<E, bool> predicate, Action<E> action)
  • public static UnitResult<E> TapErrorIf<E>(this UnitResult<E> result, Func<E, bool> predicate, Action action)
  • public static UnitResult<E> TapErrorIf<E>(this UnitResult<E> result, Func<E, bool> predicate, Action<E> action)
  • public static Task<Result> TapErrorIf(this Task<Result> resultTask, bool condition, Func<Task> func)
  • public static Task<Result> TapErrorIf(this Task<Result> resultTask, bool condition, Func<string, Task> func)
  • public static Task<Result<T>> TapErrorIf<T>(this Task<Result<T>> resultTask, bool condition, Func<Task> func)
  • public static Task<Result<T>> TapErrorIf<T>(this Task<Result<T>> resultTask, bool condition, Func<string, Task> func)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<Task> func)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<E, Task> func)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this Task<UnitResult<E>> resultTask, bool condition, Func<Task> func)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this Task<UnitResult<E>> resultTask, bool condition, Func<E, Task> func)
  • public static Task<Result> TapErrorIf(this Task<Result> resultTask, Func<string, bool> predicate, Func<Task> func)
  • public static Task<Result> TapErrorIf(this Task<Result> resultTask, Func<string, bool> predicate, Func<string, Task> func)
  • public static Task<Result<T>> TapErrorIf<T>(this Task<Result<T>> resultTask, Func<string, bool> predicate, Func<Task> func)
  • public static Task<Result<T>> TapErrorIf<T>(this Task<Result<T>> resultTask, Func<string, bool> predicate, Func<string, Task> func)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Task<Result<T, E>> resultTask, Func<E, bool> predicate, Func<Task> func)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Task<Result<T, E>> resultTask, Func<E, bool> predicate, Func<E, Task> func)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this Task<UnitResult<E>> resultTask, Func<E, bool> predicate, Func<Task> func)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this Task<UnitResult<E>> resultTask, Func<E, bool> predicate, Func<E, Task> func)
  • public static Task<Result> TapErrorIf(this Task<Result> resultTask, bool condition, Action action)
  • public static Task<Result> TapErrorIf(this Task<Result> resultTask, bool condition, Action<string> action)
  • public static Task<Result<T>> TapErrorIf<T>(this Task<Result<T>> resultTask, bool condition, Action action)
  • public static Task<Result<T>> TapErrorIf<T>(this Task<Result<T>> resultTask, bool condition, Action<string> action)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Action action)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Action<E> action)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this Task<UnitResult<E>> resultTask, bool condition, Action action)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this Task<UnitResult<E>> resultTask, bool condition, Action<E> action)
  • public static Task<Result> TapErrorIf(this Task<Result> resultTask, Func<string, bool> predicate, Action action)
  • public static Task<Result> TapErrorIf(this Task<Result> resultTask, Func<string, bool> predicate, Action<string> action)
  • public static Task<Result<T>> TapErrorIf<T>(this Task<Result<T>> resultTask, Func<string, bool> predicate, Action action)
  • public static Task<Result<T>> TapErrorIf<T>(this Task<Result<T>> resultTask, Func<string, bool> predicate, Action<string> action)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Task<Result<T, E>> resultTask, Func<E, bool> predicate, Action action)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Task<Result<T, E>> resultTask, Func<E, bool> predicate, Action<E> action)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this Task<UnitResult<E>> resultTask, Func<E, bool> predicate, Action action)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this Task<UnitResult<E>> resultTask, Func<E, bool> predicate, Action<E> action)
  • public static Task<Result> TapErrorIf(this Result result, bool condition, Func<Task> func)
  • public static Task<Result> TapErrorIf(this Result result, bool condition, Func<string, Task> func)
  • public static Task<Result<T>> TapErrorIf<T>(this Result<T> result, bool condition, Func<Task> func)
  • public static Task<Result<T>> TapErrorIf<T>(this Result<T> result, bool condition, Func<string, Task> func)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Result<T, E> result, bool condition, Func<Task> func)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Result<T, E> result, bool condition, Func<E, Task> func)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this UnitResult<E> result, bool condition, Func<Task> func)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this UnitResult<E> result, bool condition, Func<E, Task> func)
  • public static Task<Result> TapErrorIf(this Result result, Func<string, bool> predicate, Func<Task> func)
  • public static Task<Result> TapErrorIf(this Result result, Func<string, bool> predicate, Func<string, Task> func)
  • public static Task<Result<T>> TapErrorIf<T>(this Result<T> result, Func<string, bool> predicate, Func<Task> func)
  • public static Task<Result<T>> TapErrorIf<T>(this Result<T> result, Func<string, bool> predicate, Func<string, Task> func)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Result<T, E> result, Func<E, bool> predicate, Func<Task> func)
  • public static Task<Result<T, E>> TapErrorIf<T, E>(this Result<T, E> result, Func<E, bool> predicate, Func<E, Task> func)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this UnitResult<E> result, Func<E, bool> predicate, Func<Task> func)
  • public static Task<UnitResult<E>> TapErrorIf<E>(this UnitResult<E> result, Func<E, bool> predicate, Func<E, Task> func)
  • public static Result TapIf(this Result result, bool condition, Action action)
  • public static Result<T> TapIf<T>(this Result<T> result, bool condition, Action action)
  • public static Result<T> TapIf<T>(this Result<T> result, bool condition, Action<T> action)
  • public static UnitResult<E> TapIf<E>(this UnitResult<E> result, bool condition, Action action)
  • public static Result<T, E> TapIf<T, E>(this Result<T, E> result, bool condition, Action action)
  • public static Result<T, E> TapIf<T, E>(this Result<T, E> result, bool condition, Action<T> action)
  • public static Result<T> TapIf<T>(this Result<T> result, Func<T, bool> predicate, Action action)
  • public static Result<T> TapIf<T>(this Result<T> result, Func<T, bool> predicate, Action<T> action)
  • public static Result<T, E> TapIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Action action)
  • public static Result<T, E> TapIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Action<T> action)
  • public static UnitResult<E> TapIf<E>(this UnitResult<E> result, Func<bool> predicate, Action action)
  • public static Result<T> TapIf<T>(this Result<T> result, bool condition, Func<T, Result> func)
  • public static Result<T> TapIf<T, K>(this Result<T> result, bool condition, Func<T, Result<K>> func)
  • public static Result<T, E> TapIf<T, K, E>(this Result<T, E> result, bool condition, Func<T, Result<K, E>> func)
  • public static Result<T> TapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Result> func)
  • public static Result<T> TapIf<T, K>(this Result<T> result, Func<T, bool> predicate, Func<T, Result<K>> func)
  • public static Result<T, E> TapIf<T, K, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Result<K, E>> func)
  • public static Result TapIfTry(this Result result, bool condition, Action action, Func<Exception, string> errorHandler = null)
  • public static Result<T> TapIfTry<T>(this Result<T> result, bool condition, Action action, Func<Exception, string> errorHandler = null)
  • public static Result<T> TapIfTry<T>(this Result<T> result, bool condition, Action<T> action, Func<Exception, string> errorHandler = null)
  • public static UnitResult<E> TapIfTry<E>(this UnitResult<E> result, bool condition, Action action, Func<Exception, E> errorHandler)
  • public static Result<T, E> TapIfTry<T, E>(this Result<T, E> result, bool condition, Action action, Func<Exception, E> errorHandler)
  • public static Result<T, E> TapIfTry<T, E>(this Result<T, E> result, bool condition, Action<T> action, Func<Exception, E> errorHandler)
  • public static Result<T> TapIfTry<T>(this Result<T> result, Func<T, bool> predicate, Action action, Func<Exception, string> errorHandler = null)
  • public static Result<T> TapIfTry<T>(this Result<T> result, Func<T, bool> predicate, Action<T> action, Func<Exception, string> errorHandler = null)
  • public static Result<T, E> TapIfTry<T, E>(this Result<T, E> result, Func<T, bool> predicate, Action action, Func<Exception, E> errorHandler)
  • public static Result<T, E> TapIfTry<T, E>(this Result<T, E> result, Func<T, bool> predicate, Action<T> action, Func<Exception, E> errorHandler)
  • public static Result TapTry(this Result result, Action action, Func<Exception, string> errorHandler = null)
  • public static Result<T> TapTry<T>(this Result<T> result, Action action, Func<Exception, string> errorHandler = null)
  • public static Result<T> TapTry<T>(this Result<T> result, Action<T> action, Func<Exception, string> errorHandler = null)
  • public static UnitResult<E> TapTry<E>(this UnitResult<E> result, Action action, Func<Exception, E> errorHandler)
  • public static Result<T, E> TapTry<T, E>(this Result<T, E> result, Action action, Func<Exception, E> errorHandler)
  • public static Result<T, E> TapTry<T, E>(this Result<T, E> result, Action<T> action, Func<Exception, E> errorHandler)
• public class ResultFailureException : Exception
• public class ResultFailureException<E> : ResultFailureException
• public class ResultSuccessException : Exception
• public abstract class SimpleValueObject<T> : ValueObject where T : IComparable
• public static class UnitResult
• public struct UnitResult<E> : IUnitResult<E>, IResult, IError<E>, ISerializable
• public abstract class ValueObject : IComparable, IComparable<ValueObject>

CSharpFunctionalExtensions.Obsolete

• public static class MaybeExtensions