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

added TryRecover extensions
All checks were successful
.NET Test / test (push) Successful in 1m14s
Details

Browse Source
This commit is contained in:
JustFixMe
2023-12-18 18:24:15 +04:00
parent 57e83fbafa
commit 3d34a3021d
7 changed files with 176 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
README.md
View File

@@ -69,9 +69,9 @@ Result<T> Bar()
```csharp
Result<int> result = GetResult();
var value = result
.Append("new")
.Map((i, s) => $"{s} result {i}")
string value = result
.Append("new") // -> Result<(int, string)>
.Map((i, s) => $"{s} result {i}") // -> Result<string>
.Match(
onSuccess: x => x,
onFailure: err => err.ToString()
@@ -81,6 +81,17 @@ var value = result
Result<int> GetResult() => Result.Success(1);
```
#### Recover from failure
```csharp
Result<string> failed = new NotImplementedException();
Result<string> result = failed.TryRecover(err => err.Type == "System.NotImplementedException"
? "recovered"
: err);
// result with value: "recovered"
```
### Try
```csharp
@@ -99,9 +110,9 @@ int SomeFunction() => 1;
### Ensure
```csharp
var value = GetValue();
Result<int> result = Ensure.That(value)
.NotNull()
int? value = GetValue();
Result<int> result = Ensure.That(value) // -> Ensure<int?>
.NotNull() // -> Ensure<int>
.Satisfies(i => i < 100)
.Result();

30
Railway.SourceGenerator/EnsureExtensionsExecutor.cs
View File

@@ -41,22 +41,46 @@ public sealed class EnsureExtensionsExecutor : IGeneratorExecutor
var sb = new StringBuilder();
sb.AppendLine($"#region Satisfies");
sb.AppendLine("#region Satisfies");
errorGenerationDefinitions.ForEach(def => GenerateSatisfiesExtensions(sb, def.ErrorParameterDecl, def.ErrorValueExpr));
sb.AppendLine("#endregion");
sb.AppendLine($"#region NotNull");
sb.AppendLine("#region NotNull");
errorGenerationDefinitions.ForEach(def => GenerateNotNullExtensions(sb, def.ErrorParameterDecl, def.ErrorValueExpr));
sb.AppendLine("#endregion");
sb.AppendLine($"#region NotEmpty");
sb.AppendLine("#region NotEmpty");
errorGenerationDefinitions.ForEach(def => GenerateNotEmptyExtensions(sb, def.ErrorParameterDecl, def.ErrorValueExpr));
sb.AppendLine("#endregion");
sb.AppendLine("#region NotWhitespace");
errorGenerationDefinitions.ForEach(def => GenerateNotWhitespaceExtensions(sb, def.ErrorParameterDecl, def.ErrorValueExpr));
sb.AppendLine("#endregion");
return sb.ToString();
}
private void GenerateNotWhitespaceExtensions(StringBuilder sb, string errorParameterDecl, string errorValueExpr)
{
string defaultErrorExpr = "?? Error.New(DefaultErrorType, $\"Value {{{ensure.ValueExpression}}} is empty or consists exclusively of white-space characters.\")";
sb.AppendLine($$"""
[PureAttribute]
[GeneratedCodeAttribute("{{nameof(EnsureExtensionsExecutor)}}", "1.0.0.0")]
public static Ensure<string> NotWhitespace(this in Ensure<string> ensure, {{errorParameterDecl}})
{
return ensure.State switch
{
ResultState.Success => string.IsNullOrWhiteSpace(ensure.Value)
? new({{errorValueExpr}} {{defaultErrorExpr}}, ensure.ValueExpression)
: new(ensure.Value!, ensure.ValueExpression),
ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
_ => throw new EnsureNotInitializedException(nameof(ensure))
};
}
""");
}
private void GenerateNotEmptyExtensions(StringBuilder sb, string errorParameterDecl, string errorValueExpr)
{
string defaultErrorExpr = "?? Error.New(DefaultErrorType, $\"Value {{{ensure.ValueExpression}}} is empty.\")";

1
Railway.SourceGenerator/ExtensionsMethodGenerator.cs
View File

@@ -17,6 +17,7 @@ public class ExtensionsMethodGenerator : IIncrementalGenerator
new ResultMapExecutor(),
new ResultBindExecutor(),
new ResultTapExecutor(),
new ResultTryRecoverExecutor(),
new ResultAppendExecutor(),
new TryExtensionsExecutor(),
new EnsureExtensionsExecutor(),

86
Railway.SourceGenerator/ResultTryRecoverExecutor.cs Normal file
View File

@@ -0,0 +1,86 @@
using System.Collections.Immutable;
using System.Linq;
using System.Text;
using Microsoft.CodeAnalysis;
namespace Just.Railway.SourceGen;
internal sealed class ResultTryRecoverExecutor : ResultExtensionsExecutor
{
protected override string ExtensionType => "TryRecover";
protected override void GenerateMethodsForArgCount(StringBuilder sb, int argCount)
{
if (argCount > 1) return;
var templateArgNames = Enumerable.Repeat("T", argCount)
.ToImmutableArray();
string methodTemplateDecl = GenerateTemplateDecl(templateArgNames);
string resultTypeDef = GenerateResultTypeDef(templateArgNames);
sb.AppendLine($"#region {resultTypeDef}");
sb.AppendLine($$"""
[PureAttribute]
[GeneratedCodeAttribute("{{nameof(ResultTryRecoverExecutor)}}", "1.0.0.0")]
public static {{resultTypeDef}} TryRecover{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func<Error, {{resultTypeDef}}> recover)
{
return result.State switch
{
ResultState.Success => ({{resultTypeDef}})result.Value,
ResultState.Error => recover(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
""");
GenerateAsyncMethods("Task", sb, templateArgNames, resultTypeDef, methodTemplateDecl);
GenerateAsyncMethods("ValueTask", sb, templateArgNames, resultTypeDef, methodTemplateDecl);
sb.AppendLine("#endregion");
}
private static void GenerateAsyncMethods(string taskType, StringBuilder sb, ImmutableArray<string> templateArgNames, string resultTypeDef, string methodTemplateDecl)
{
sb.AppendLine($$"""
[PureAttribute]
[GeneratedCodeAttribute("{{nameof(ResultTryRecoverExecutor)}}", "1.0.0.0")]
public static async {{taskType}}<{{resultTypeDef}}> TryRecover{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func<Error, {{resultTypeDef}}> recover)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => ({{resultTypeDef}})result.Value,
ResultState.Error => recover(result.Error!),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
""");
sb.AppendLine($$"""
[PureAttribute]
[GeneratedCodeAttribute("{{nameof(ResultTryRecoverExecutor)}}", "1.0.0.0")]
public static async {{taskType}}<{{resultTypeDef}}> TryRecover{{methodTemplateDecl}}(this {{resultTypeDef}} result, Func<Error, {{taskType}}<{{resultTypeDef}}>> recover)
{
return result.State switch
{
ResultState.Success => ({{resultTypeDef}})result.Value,
ResultState.Error => await recover(result.Error!).ConfigureAwait(false),
_ => throw new ResultNotInitializedException(nameof(result))
};
}
""");
sb.AppendLine($$"""
[PureAttribute]
[GeneratedCodeAttribute("{{nameof(ResultTryRecoverExecutor)}}", "1.0.0.0")]
public static async {{taskType}}<{{resultTypeDef}}> TryRecover{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func<Error, {{taskType}}<{{resultTypeDef}}>> recover)
{
var result = await resultTask.ConfigureAwait(false);
return result.State switch
{
ResultState.Success => ({{resultTypeDef}})result.Value,
ResultState.Error => await recover(result.Error!).ConfigureAwait(false),
_ => throw new ResultNotInitializedException(nameof(resultTask))
};
}
""");
}
}

12
Railway/Ensure.cs
View File

@@ -34,18 +34,6 @@ public static partial class Ensure
_ => throw new EnsureNotInitializedException(nameof(ensureTask))
};
}
[Pure] public static Ensure<string> NotWhitespace(this in Ensure<string> ensure, Error error = default!)
{
return ensure.State switch
{
ResultState.Success => string.IsNullOrWhiteSpace(ensure.Value)
? new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty or consists exclusively of white-space characters."), ensure.ValueExpression)
: new(ensure.Value, ensure.ValueExpression),
ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
_ => throw new EnsureNotInitializedException(nameof(ensure))
};
}
}
public readonly struct Ensure<T>

18
Railway/Result.cs
View File

@@ -8,6 +8,7 @@ internal enum ResultState : byte
public readonly partial struct Result : IEquatable<Result>
{
internal SuccessUnit Value => new();
internal readonly Error? Error;
internal readonly ResultState State;
@@ -51,12 +52,17 @@ public readonly partial struct Result : IEquatable<Result>
[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(Exception exception) => new(
new ExceptionalError(exception ?? throw new ArgumentNullException(nameof(exception))));
[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!),
_ => throw new ResultNotInitializedException(nameof(result))
};
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Result(SuccessUnit _) => new(null);
[Pure] public bool IsSuccess => Error is null;
[Pure] public bool IsFailure => Error is not null;
@@ -139,14 +145,20 @@ public readonly struct Result<T> : IEquatable<Result<T>>
Error = default;
}
[Pure] public static explicit operator Result(Result<T> result) => result.State switch
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator Result(Result<T> result) => result.State switch
{
ResultState.Success => new(null),
ResultState.Error => new(result.Error!),
_ => throw new ResultNotInitializedException(nameof(result))
};
[Pure] public static implicit operator Result<T>(Error error) => new(error);
[Pure] public static implicit operator Result<T>(T value) => new(value);
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Result<T>(Error error) => new(error);
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Result<T>(Exception exception) => new(
new ExceptionalError(exception ?? throw new ArgumentNullException(nameof(exception))));
[Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator Result<T>(T value) => new(value);
[Pure] public bool IsSuccess => State == ResultState.Success;
[Pure] public bool IsFailure => State == ResultState.Error;

29
Raliway.Tests/Results/GeneralUsage.cs
View File

@@ -128,4 +128,33 @@ public class GeneralUsage
// Then
Assert.Equal("satisfied", result);
}
[Fact]
public void RecoverResultFromFailureState()
{
// Given
Result<string> failed = new NotImplementedException();
// When
var result = failed.TryRecover(err =>
{
Assert.IsType<NotImplementedException>(err.ToException());
return "recovered";
});
// Then
Assert.True(result.IsSuccess);
Assert.Equal("recovered", result.Value);
}
[Fact]
public void WhenCanNotRecoverResultFromFailureState()
{
// Given
var error = Error.New("test");
Result<string> failed = new NotImplementedException();
// When
var result = failed.TryRecover(err => error);
// Then
Assert.True(result.IsFailure);
Assert.Equal(error, result.Error);
}
}