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

made all extensions source generated
All checks were successful
.NET Test / test (push) Successful in 1m9s
Details

Browse Source
This commit is contained in:
JustFixMe
2023-12-07 23:21:00 +04:00
parent b79192ec6c
commit f39b899514
12 changed files with 675 additions and 899 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Railway/Railway.csproj
View File

@@ -8,6 +8,7 @@
<RootNamespace>Just.Railway</RootNamespace>
<Authors>JustFixMe</Authors>
<Copyright>Copyright (c) 2023 JustFixMe</Copyright>
<PackageLicenseExpression>MIT</PackageLicenseExpression>
<RepositoryUrl>https://gitea.jstdev.ru/just/Just.Railway/</RepositoryUrl>

33
Railway/Result.cs
View File

@@ -17,13 +17,34 @@ public readonly partial struct Result : IEquatable<Result>
State = error is null ? ResultState.Success : ResultState.Error;
}
[Pure] public static Result Success() => new(null);
[Pure] public static Result<T> Success<T>(T value) => new(value);
[Pure] public static Result Failure(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
[Pure] public static Result<T> Failure<T>(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Result Success() => new(null);
[Pure] public static implicit operator Result(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
[Pure] public static implicit operator Result<SuccessUnit>(Result result) => result.State switch
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Result<T> Success<T>(T value) => new(value);
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Result<(T1, T2)> Success<T1, T2>(T1 value1, T2 value2) => new((value1, value2));
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Result<(T1, T2, T3)> Success<T1, T2, T3>(T1 value1, T2 value2, T3 value3) => new((value1, value2, value3));
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Result<(T1, T2, T3, T4)> Success<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4) => new((value1, value2, value3, value4));
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Result<(T1, T2, T3, T4, T5)> Success<T1, T2, T3, T4, T5>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5) => new((value1, value2, value3, value4, value5));
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Result Failure(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Result<T> Failure<T>(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Result(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Result<SuccessUnit>(Result result) => result.State switch
{
ResultState.Success => new(new SuccessUnit()),
ResultState.Error => new(result.Error!),

795
Railway/ResultExtensions.cs
View File

@@ -2,770 +2,41 @@ namespace Just.Railway;
public static partial class ResultExtensions
{
#region Match<>
[Pure]
public static R Match<R>(this in Result result, Func<R> onSuccess, Func<Error, R> onFailure)
{
return result.State switch
{
ResultState.Success => onSuccess(),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<R> Match<R>(this in Result result, Func<Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
{
return result.State switch
{
ResultState.Success => onSuccess(),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure] public static async Task<R> Match<R>(this Task<Result> resultTask, Func<R> onSuccess, Func<Error, R> onFailure)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => onSuccess(),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<R> Match<R>(this Task<Result> resultTask, Func<Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
{
var result = await resultTask.ConfigureAwait(false);
var matchTask = result.State switch
{
ResultState.Success => onSuccess(),
ResultState.Error => onFailure(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
return await matchTask.ConfigureAwait(false);
}
#endregion
#region Map<>
[Pure]
public static Result<R> Map<R>(this in Result result, Func<R> mapping)
{
return result.State switch
{
ResultState.Success => mapping(),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Map<R>(this Result result, Func<Task<R>> mapping)
{
return result.State switch
{
ResultState.Success => await mapping().ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Map<R>(this Task<Result> resultTask, Func<R> mapping)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => mapping(),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<R>> Map<R>(this Task<Result> resultTask, Func<Task<R>> mapping)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await mapping().ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region Bind<>
[Pure]
public static Result Bind(this in Result result, Func<Result> binding)
{
return result.State switch
{
ResultState.Success => binding(),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<Result> Bind(this in Result result, Func<Task<Result>> binding)
{
return result.State switch
{
ResultState.Success => binding(),
ResultState.Error => Task.FromResult<Result>(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result> Bind(this Task<Result> resultTask, Func<Result> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => binding(),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result> Bind(this Task<Result> resultTask, Func<Task<Result>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await binding().ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static Result<R> Bind<R>(this in Result result, Func<Result<R>> binding)
{
return result.State switch
{
ResultState.Success => binding(),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<Result<R>> Bind<R>(this in Result result, Func<Task<Result<R>>> binding)
{
return result.State switch
{
ResultState.Success => binding(),
ResultState.Error => Task.FromResult<Result<R>>(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<R>> Bind<R>(this Task<Result> resultTask, Func<Result<R>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => binding(),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<R>> Bind<R>(this Task<Result> resultTask, Func<Task<Result<R>>> binding)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await binding().ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region Append
#region <>
[Pure] public static Result Append(this in Result result, Result next)
{
Error? error = null;
if ((result.State & next.State) == ResultState.Bottom)
{
throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
{
if (r1 == ResultState.Bottom)
yield return nameof(result);
if (r2 == ResultState.Bottom)
yield return nameof(next);
}
}
if (result.IsFailure)
{
error += result.Error;
}
if (next.IsFailure)
{
error += next.Error;
}
return error is null
? new(null)
: new(error);
}
#endregion
#region <T>
[Pure] public static Result<T> Append<T>(this in Result result, T value)
{
return result.State switch
{
ResultState.Success => value,
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure] public static Result<T> Append<T>(this in Result result, Result<T> next)
{
Error? error = null;
if ((result.State & next.State) == ResultState.Bottom)
{
throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
{
if (r1 == ResultState.Bottom)
yield return nameof(result);
if (r2 == ResultState.Bottom)
yield return nameof(next);
}
}
if (result.IsFailure)
{
error += result.Error;
}
if (next.IsFailure)
{
error += next.Error;
}
return error is null
? new(next.Value)
: new(error);
}
[Pure] public static Result<T> Append<T>(this in Result<T> result, Result next)
{
Error? error = null;
if ((result.State & next.State) == ResultState.Bottom)
{
throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
{
if (r1 == ResultState.Bottom)
yield return nameof(result);
if (r2 == ResultState.Bottom)
yield return nameof(next);
}
}
if (result.IsFailure)
{
error += result.Error;
}
if (next.IsFailure)
{
error += next.Error;
}
return error is null
? new(result.Value)
: new(error);
}
[Pure]
public static Result<T> Append<T>(this in Result result, Func<Result<T>> next)
{
return result.State switch
{
ResultState.Success => next(),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static Task<Result<T>> Append<T>(this in Result result, Func<Task<Result<T>>> next)
{
return result.State switch
{
ResultState.Success => next(),
ResultState.Error => Task.FromResult<Result<T>>(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<T>> Append<T>(this Task<Result> resultTask, Func<Task<Result<T>>> next)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => await next().ConfigureAwait(false),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<T>> Append<T>(this Task<Result> resultTask, Func<Result<T>> next)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => next(),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region <T1, T2>
[Pure] public static Result<(T1, T2)> Append<T1, T2>(this in Result<T1> result, T2 value)
{
return result.State switch
{
ResultState.Success => (result.Value, value),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure] public static Result<(T1, T2)> Append<T1, T2>(this in Result<T1> result, Result<T2> next)
{
Error? error = null;
if ((result.State & next.State) == ResultState.Bottom)
{
throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
{
if (r1 == ResultState.Bottom)
yield return nameof(result);
if (r2 == ResultState.Bottom)
yield return nameof(next);
}
}
if (result.IsFailure)
{
error += result.Error;
}
if (next.IsFailure)
{
error += next.Error;
}
return error is null
? new((result.Value, next.Value))
: new(error);
}
[Pure] public static Result<(T1, T2)> Append<T1, T2>(this in Result<(T1, T2)> result, Result next)
{
Error? error = null;
if ((result.State & next.State) == ResultState.Bottom)
{
throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
{
if (r1 == ResultState.Bottom)
yield return nameof(result);
if (r2 == ResultState.Bottom)
yield return nameof(next);
}
}
if (result.IsFailure)
{
error += result.Error;
}
if (next.IsFailure)
{
error += next.Error;
}
return error is null
? new(result.Value)
: new(error);
}
[Pure]
public static Result<(T1, T2)> Append<T1, T2>(this in Result<T1> result, Func<Result<T2>> next)
{
return result.State switch
{
ResultState.Success => result.Append(next()),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<(T1, T2)>> Append<T1, T2>(this Result<T1> result, Func<Task<Result<T2>>> next)
{
return result.State switch
{
ResultState.Success => result.Append(await next().ConfigureAwait(false)),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<(T1, T2)>> Append<T1, T2>(this Task<Result<T1>> resultTask, Func<Task<Result<T2>>> next)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => result.Append(await next().ConfigureAwait(false)),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<(T1, T2)>> Append<T1, T2>(this Task<Result<T1>> resultTask, Func<Result<T2>> next)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => result.Append(next()),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region <T1, T2, T3>
[Pure] public static Result<(T1, T2, T3)> Append<T1, T2, T3>(this in Result<(T1, T2)> result, T3 value)
{
return result.State switch
{
ResultState.Success => (result.Value.Item1, result.Value.Item2, value),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure] public static Result<(T1, T2, T3)> Append<T1, T2, T3>(this in Result<(T1, T2)> result, Result<T3> next)
{
Error? error = null;
if ((result.State & next.State) == ResultState.Bottom)
{
throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
{
if (r1 == ResultState.Bottom)
yield return nameof(result);
if (r2 == ResultState.Bottom)
yield return nameof(next);
}
}
if (result.IsFailure)
{
error += result.Error;
}
if (next.IsFailure)
{
error += next.Error;
}
return error is null
? new((result.Value.Item1, result.Value.Item2, next.Value))
: new(error);
}
[Pure] public static Result<(T1, T2, T3)> Append<T1, T2, T3>(this in Result<(T1, T2, T3)> result, Result next)
{
Error? error = null;
if ((result.State & next.State) == ResultState.Bottom)
{
throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
{
if (r1 == ResultState.Bottom)
yield return nameof(result);
if (r2 == ResultState.Bottom)
yield return nameof(next);
}
}
if (result.IsFailure)
{
error += result.Error;
}
if (next.IsFailure)
{
error += next.Error;
}
return error is null
? new(result.Value)
: new(error);
}
[Pure]
public static Result<(T1, T2, T3)> Append<T1, T2, T3>(this in Result<(T1, T2)> result, Func<Result<T3>> next)
{
return result.State switch
{
ResultState.Success => result.Append(next()),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<(T1, T2, T3)>> Append<T1, T2, T3>(this Result<(T1, T2)> result, Func<Task<Result<T3>>> next)
{
return result.State switch
{
ResultState.Success => result.Append(await next().ConfigureAwait(false)),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<(T1, T2, T3)>> Append<T1, T2, T3>(this Task<Result<(T1, T2)>> resultTask, Func<Task<Result<T3>>> next)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => result.Append(await next().ConfigureAwait(false)),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<(T1, T2, T3)>> Append<T1, T2, T3>(this Task<Result<(T1, T2)>> resultTask, Func<Result<T3>> next)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => result.Append(next()),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#region <T1, T2, T3, T4>
[Pure] public static Result<(T1, T2, T3, T4)> Append<T1, T2, T3, T4>(this in Result<(T1, T2, T3)> result, T4 value)
{
return result.State switch
{
ResultState.Success => (result.Value.Item1, result.Value.Item2, result.Value.Item3, value),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure] public static Result<(T1, T2, T3, T4)> Append<T1, T2, T3, T4>(this in Result<(T1, T2, T3)> result, Result<T4> next)
{
Error? error = null;
if ((result.State & next.State) == ResultState.Bottom)
{
throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
{
if (r1 == ResultState.Bottom)
yield return nameof(result);
if (r2 == ResultState.Bottom)
yield return nameof(next);
}
}
if (result.IsFailure)
{
error += result.Error;
}
if (next.IsFailure)
{
error += next.Error;
}
return error is null
? new((result.Value.Item1, result.Value.Item2, result.Value.Item3, next.Value))
: new(error);
}
[Pure] public static Result<(T1, T2, T3, T4)> Append<T1, T2, T3, T4>(this in Result<(T1, T2, T3, T4)> result, Result next)
{
Error? error = null;
if ((result.State & next.State) == ResultState.Bottom)
{
throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
{
if (r1 == ResultState.Bottom)
yield return nameof(result);
if (r2 == ResultState.Bottom)
yield return nameof(next);
}
}
if (result.IsFailure)
{
error += result.Error;
}
if (next.IsFailure)
{
error += next.Error;
}
return error is null
? new(result.Value)
: new(error);
}
[Pure]
public static Result<(T1, T2, T3, T4)> Append<T1, T2, T3, T4>(this in Result<(T1, T2, T3)> result, Func<Result<T4>> next)
{
return result.State switch
{
ResultState.Success => result.Append(next()),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<(T1, T2, T3, T4)>> Append<T1, T2, T3, T4>(this Result<(T1, T2, T3)> result, Func<Task<Result<T4>>> next)
{
return result.State switch
{
ResultState.Success => result.Append(await next().ConfigureAwait(false)),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(result))
};
}
[Pure]
public static async Task<Result<(T1, T2, T3, T4)>> Append<T1, T2, T3, T4>(this Task<Result<(T1, T2, T3)>> resultTask, Func<Task<Result<T4>>> next)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => result.Append(await next().ConfigureAwait(false)),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
[Pure]
public static async Task<Result<(T1, T2, T3, T4)>> Append<T1, T2, T3, T4>(this Task<Result<(T1, T2, T3)>> resultTask, Func<Result<T4>> next)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => result.Append(next()),
ResultState.Error => result.Error!,
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
#endregion
#endregion
#region Tap<>
[Pure]
public static ref readonly Result Tap(this in Result result, Action? onSuccess = null, Action<Error>? onFailure = null)
{
switch (result.State)
{
case ResultState.Success:
onSuccess?.Invoke();
break;
case ResultState.Error:
onFailure?.Invoke(result.Error!);
break;
default: throw new ResultNotInitializedException(nameof(result));
}
return ref result;
}
[Pure]
public static async Task<Result> Tap(this Task<Result> resultTask, Action? onSuccess = null, Action<Error>? onFailure = null)
{
var result = await resultTask.ConfigureAwait(false);
switch (result.State)
{
case ResultState.Success:
onSuccess?.Invoke();
break;
case ResultState.Error:
onFailure?.Invoke(result.Error!);
break;
default: throw new ResultNotInitializedException(nameof(resultTask));
}
return result;
}
[Pure]
public static async Task<Result> Tap(this Result result, Func<Task>? onSuccess = null, Func<Error, Task>? onFailure = null)
{
switch (result.State)
{
case ResultState.Success:
if (onSuccess is not null)
await onSuccess.Invoke().ConfigureAwait(false);
break;
case ResultState.Error:
if (onFailure is not null)
await onFailure.Invoke(result.Error!).ConfigureAwait(false);
break;
default: throw new ResultNotInitializedException(nameof(result));
}
return result;
}
[Pure]
public static async Task<Result> Tap(this Task<Result> resultTask, Func<Task>? onSuccess = null, Func<Error, Task>? onFailure = null)
{
var result = await resultTask.ConfigureAwait(false);
switch (result.State)
{
case ResultState.Success:
if (onSuccess is not null)
await onSuccess.Invoke().ConfigureAwait(false);
break;
case ResultState.Error:
if (onFailure is not null)
await onFailure.Invoke(result.Error!).ConfigureAwait(false);
break;
default: throw new ResultNotInitializedException(nameof(resultTask));
}
return result;
}
#endregion
#region Merge
public static Result Merge(this IEnumerable<Result> results)
{
List<Error>? errors = null;
bool hasErrors = false;
foreach (var result in results.OrderBy(x => x.State))
{
switch (result.State)
{
case ResultState.Error:
hasErrors = true;
errors ??= [];
errors.Add(result.Error!);
break;
case ResultState.Success:
if (hasErrors) goto afterLoop;
break;
default: throw new ResultNotInitializedException(nameof(results));
}
}
afterLoop:
return hasErrors
? new(new ManyErrors(errors!))
: new(null);
}
public static async Task<Result> Merge(this IEnumerable<Task<Result>> tasks)
{
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
return results.Merge();
}
public static Result<IEnumerable<T>> Merge<T>(this IEnumerable<Result<T>> results)
{
List<T>? values = null;