just/Just.Railway
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases 11 Activity

added Bind, Map and Match extensions generators
All checks were successful
.NET Test / test (push) Successful in 4m41s
Details

Browse Source
This commit is contained in:
JustFixMe
2023-11-28 21:41:01 +04:00
parent ac18863426
commit 6726ba07b3
8 changed files with 365 additions and 617 deletions
Download Patch File Download Diff File Expand all files Collapse all files

606
Railway/ResultExtensions.cs
View File

@@ -1,10 +1,9 @@
namespace Just.Railway;
public static class ResultExtensions
public static partial class ResultExtensions
{
#region Match
#region Match<>
#region <>
[Pure]
public static R Match<R>(this in Result result, Func<R> onSuccess, Func<Error, R> onFailure)
{
@@ -52,211 +51,7 @@ public static class ResultExtensions
#endregion
#region <T>
[Pure]
public static R Match<T, R>(this in Result<T> result, Func<T, R> onSuccess, Func<Error, R> onFailure)
{
return result.State switch
{
ResultState.Success => onSuccess(result.Value),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<R> Match<T, R>(this in Result<T> result, Func<T, Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
{
return result.State switch
{
ResultState.Success => onSuccess(result.Value),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<R> Match<T, R>(this Task<Result<T>> resultTask, Func<T, R> onSuccess, Func<Error, R> onFailure)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => onSuccess(result.Value),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<R> Match<T, R>(this Task<Result<T>> resultTask, Func<T, Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
{
var result = await resultTask.ConfigureAwait(false);
var matchTask = result.State switch
{
ResultState.Success => onSuccess(result.Value),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
return await matchTask.ConfigureAwait(false);
}
#endregion
#region <T1, T2>
[Pure]
public static R Match<T1, T2, R>(this in Result<(T1, T2)> result, Func<T1, T2, R> onSuccess, Func<Error, R> onFailure)
{
return result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<R> Match<T1, T2, R>(this in Result<(T1, T2)> result, Func<T1, T2, Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
{
return result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<R> Match<T1, T2, R>(this Task<Result<(T1, T2)>> resultTask, Func<T1, T2, R> onSuccess, Func<Error, R> onFailure)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<R> Match<T1, T2, R>(this Task<Result<(T1, T2)>> resultTask, Func<T1, T2, Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
{
var result = await resultTask.ConfigureAwait(false);
var matchTask = result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
return await matchTask.ConfigureAwait(false);
}
#endregion
#region <T1, T2, T3>
[Pure]
public static R Match<T1, T2, T3, R>(this in Result<(T1, T2, T3)> result, Func<T1, T2, T3, R> onSuccess, Func<Error, R> onFailure)
{
return result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2, result.Value.Item3),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<R> Match<T1, T2, T3, R>(this in Result<(T1, T2, T3)> result, Func<T1, T2, T3, Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
{
return result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2, result.Value.Item3),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<R> Match<T1, T2, T3, R>(this Task<Result<(T1, T2, T3)>> resultTask, Func<T1, T2, T3, R> onSuccess, Func<Error, R> onFailure)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2, result.Value.Item3),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<R> Match<T1, T2, T3, R>(this Task<Result<(T1, T2, T3)>> resultTask, Func<T1, T2, T3, Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
{
var result = await resultTask.ConfigureAwait(false);
var matchTask = result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2, result.Value.Item3),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
return await matchTask.ConfigureAwait(false);
}
#endregion
#region <T1, T2, T3, T4>
[Pure]
public static R Match<T1, T2, T3, T4, R>(this in Result<(T1, T2, T3, T4)> result, Func<T1, T2, T3, T4, R> onSuccess, Func<Error, R> onFailure)
{
return result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<R> Match<T1, T2, T3, T4, R>(this in Result<(T1, T2, T3, T4)> result, Func<T1, T2, T3, T4, Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
{
return result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<R> Match<T1, T2, T3, T4, R>(this Task<Result<(T1, T2, T3, T4)>> resultTask, Func<T1, T2, T3, T4, R> onSuccess, Func<Error, R> onFailure)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<R> Match<T1, T2, T3, T4, R>(this Task<Result<(T1, T2, T3, T4)>> resultTask, Func<T1, T2, T3, T4, Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
{
var result = await resultTask.ConfigureAwait(false);
var matchTask = result.State switch
{
ResultState.Success => onSuccess(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
return await matchTask.ConfigureAwait(false);
}
#endregion
#endregion
#region Map
#region <>
#region Map<>
[Pure]
public static Result<R> Map<R>(this in Result result, Func<R> mapping)
@@ -306,211 +101,7 @@ public static class ResultExtensions
#endregion
#region <T>
[Pure]
public static Result<R> Map<T, R>(this in Result<T> result, Func<T, R> mapping)
{
return result.State switch
{
ResultState.Success => mapping(result.Value),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Map<T, R>(this Result<T> result, Func<T, Task<R>> mapping)
{
return result.State switch
{
ResultState.Success => await mapping(result.Value).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Map<T, R>(this Task<Result<T>> resultTask, Func<T, R> mapping)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => mapping(result.Value),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<R>> Map<T, R>(this Task<Result<T>> resultTask, Func<T, Task<R>> mapping)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await mapping(result.Value).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region <T1, T2>
[Pure]
public static Result<R> Map<T1, T2, R>(this in Result<(T1, T2)> result, Func<T1, T2, R> mapping)
{
return result.State switch
{
ResultState.Success => mapping(result.Value.Item1, result.Value.Item2),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Map<T1, T2, R>(this Result<(T1, T2)> result, Func<T1, T2, Task<R>> mapping)
{
return result.State switch
{
ResultState.Success => await mapping(result.Value.Item1, result.Value.Item2).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Map<T1, T2, R>(this Task<Result<(T1, T2)>> resultTask, Func<T1, T2, R> mapping)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => mapping(result.Value.Item1, result.Value.Item2),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<R>> Map<T1, T2, R>(this Task<Result<(T1, T2)>> resultTask, Func<T1, T2, Task<R>> mapping)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await mapping(result.Value.Item1, result.Value.Item2).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region <T1, T2, T3>
[Pure]
public static Result<R> Map<T1, T2, T3, R>(this in Result<(T1, T2, T3)> result, Func<T1, T2, T3, R> mapping)
{
return result.State switch
{
ResultState.Success => mapping(result.Value.Item1, result.Value.Item2, result.Value.Item3),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Map<T1, T2, T3, R>(this Result<(T1, T2, T3)> result, Func<T1, T2, T3, Task<R>> mapping)
{
return result.State switch
{
ResultState.Success => await mapping(result.Value.Item1, result.Value.Item2, result.Value.Item3).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Map<T1, T2, T3, R>(this Task<Result<(T1, T2, T3)>> resultTask, Func<T1, T2, T3, R> mapping)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => mapping(result.Value.Item1, result.Value.Item2, result.Value.Item3),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<R>> Map<T1, T2, T3, R>(this Task<Result<(T1, T2, T3)>> resultTask, Func<T1, T2, T3, Task<R>> mapping)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await mapping(result.Value.Item1, result.Value.Item2, result.Value.Item3).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region <T1, T2, T3, T4>
[Pure]
public static Result<R> Map<T1, T2, T3, T4, R>(this in Result<(T1, T2, T3, T4)> result, Func<T1, T2, T3, T4, R> mapping)
{
return result.State switch
{
ResultState.Success => mapping(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Map<T1, T2, T3, T4, R>(this Result<(T1, T2, T3, T4)> result, Func<T1, T2, T3, T4, Task<R>> mapping)
{
return result.State switch
{
ResultState.Success => await mapping(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Map<T1, T2, T3, T4, R>(this Task<Result<(T1, T2, T3, T4)>> resultTask, Func<T1, T2, T3, T4, R> mapping)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => mapping(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<R>> Map<T1, T2, T3, T4, R>(this Task<Result<(T1, T2, T3, T4)>> resultTask, Func<T1, T2, T3, T4, Task<R>> mapping)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await mapping(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#endregion
#region Bind
#region <>
#region Bind<>
[Pure]
public static Result Bind(this in Result result, Func<Result> binding)
@@ -600,195 +191,6 @@ public static class ResultExtensions
#endregion
#region <T>
[Pure]
public static Result<R> Bind<T, R>(this in Result<T> result, Func<T, Result<R>> binding)
{
return result.State switch
{
ResultState.Success => binding(result.Value),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<Result<R>> Bind<T, R>(this in Result<T> result, Func<T, Task<Result<R>>> binding)
{
return result.State switch
{
ResultState.Success => binding(result.Value),
ResultState.Error => Task.FromResult<Result<R>>(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Bind<T, R>(this Task<Result<T>> resultTask, Func<T, Result<R>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => binding(result.Value),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<R>> Bind<T, R>(this Task<Result<T>> resultTask, Func<T, Task<Result<R>>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await binding(result.Value).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region <T1, T2>
[Pure]
public static Result<R> Bind<T1, T2, R>(this in Result<(T1, T2)> result, Func<T1, T2, Result<R>> binding)
{
return result.State switch
{
ResultState.Success => binding(result.Value.Item1, result.Value.Item2),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<Result<R>> Bind<T1, T2, R>(this in Result<(T1, T2)> result, Func<T1, T2, Task<Result<R>>> binding)
{
return result.State switch
{
ResultState.Success => binding(result.Value.Item1, result.Value.Item2),
ResultState.Error => Task.FromResult<Result<R>>(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Bind<T1, T2, R>(this Task<Result<(T1, T2)>> resultTask, Func<T1, T2, Result<R>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => binding(result.Value.Item1, result.Value.Item2),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<R>> Bind<T1, T2, R>(this Task<Result<(T1, T2)>> resultTask, Func<T1, T2, Task<Result<R>>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await binding(result.Value.Item1, result.Value.Item2).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region <T1, T2, T3>
[Pure]
public static Result<R> Bind<T1, T2, T3, R>(this in Result<(T1, T2, T3)> result, Func<T1, T2, T3, Result<R>> binding)
{
return result.State switch
{
ResultState.Success => binding(result.Value.Item1, result.Value.Item2, result.Value.Item3),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<Result<R>> Bind<T1, T2, T3, R>(this in Result<(T1, T2, T3)> result, Func<T1, T2, T3, Task<Result<R>>> binding)
{
return result.State switch
{
ResultState.Success => binding(result.Value.Item1, result.Value.Item2, result.Value.Item3),
ResultState.Error => Task.FromResult<Result<R>>(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Bind<T1, T2, T3, R>(this Task<Result<(T1, T2, T3)>> resultTask, Func<T1, T2, T3, Result<R>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => binding(result.Value.Item1, result.Value.Item2, result.Value.Item3),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<R>> Bind<T1, T2, T3, R>(this Task<Result<(T1, T2, T3)>> resultTask, Func<T1, T2, T3, Task<Result<R>>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await binding(result.Value.Item1, result.Value.Item2, result.Value.Item3).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region <T1, T2, T3, T4>
[Pure]
public static Result<R> Bind<T1, T2, T3, T4, R>(this in Result<(T1, T2, T3, T4)> result, Func<T1, T2, T3, T4, Result<R>> binding)
{
return result.State switch
{
ResultState.Success => binding(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<Result<R>> Bind<T1, T2, T3, T4, R>(this in Result<(T1, T2, T3, T4)> result, Func<T1, T2, T3, T4, Task<Result<R>>> binding)
{
return result.State switch
{
ResultState.Success => binding(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4),
ResultState.Error => Task.FromResult<Result<R>>(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Bind<T1, T2, T3, T4, R>(this Task<Result<(T1, T2, T3, T4)>> resultTask, Func<T1, T2, T3, T4, Result<R>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => binding(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<R>> Bind<T1, T2, T3, T4, R>(this Task<Result<(T1, T2, T3, T4)>> resultTask, Func<T1, T2, T3, T4, Task<Result<R>>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await binding(result.Value.Item1, result.Value.Item2, result.Value.Item3, result.Value.Item4).ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#endregion
#region Append
#region <>