Aramiscd.Result 1.0.0

Aramiscd.Result

This package provides a result type that can contain either a result value or an error value. It can be used as the return type for methods that may fail. This enables clear and explicit error handling without having to resort to exceptions.

Use as return type

Division without throwing an exception:

public static Result<int, DivideByZeroException> Divide(int a, int b) =>
    b == 0
        ? Result<int, DivideByZeroException>.Fail(new DivideByZeroException())
        : Result<int, DivideByZeroException>.Ok(a / b);

Reading a file without throwing an exception:

public static Result<string, Exception> ReadFile(string path)
{
    try
    {
        return Result<string, Exception>.Ok(File.ReadAllText(path));
    }
    catch (Exception ex)
    {
        return Result<string, Exception>.Fail(ex);
    }
}

Array access without throwing an exception:

public static Result<T, ValueTuple> GetElementAt<T>(this IList<T> list, int index) =>
    index < 0 || index >= list.Count
        ? Result<T, ValueTuple>.Fail(new ValueTuple())
        : Result<T, ValueTuple>.Ok(list[index]);

Parsing integers without throwing an exception and using a custom unit error type:

public readonly record struct Unit;

public static Result<string, Unit> TryParseInt(string input)
{
    return int.TryParse(input, out var result)
        ? Result<string, Unit>.Ok(result.ToString())
        : Result<string, Unit>.Fail(new Unit());
}

HTTP requests without throwing an exception:

public static async Task<Result<HttpResponseMessage, Exception>> HttpGet(string requestUri)
{
    try
    {
        return Result<HttpResponseMessage, Exception>.Ok(await Client.GetAsync(requestUri));
    }
    catch (Exception ex)
    {
        return Result<HttpResponseMessage, Exception>.Fail(ex);
    }
}

Further processing of results

var r = myList.GetElementAt(123);

if (r.IsOk)
{
    // If r.IsOk and the success type is not nullable,
    // then r.Value is guaranteed not to be null.

    var mySuccessValue = r.Value!;
}
else
{
    // If !r.IsOk and the failure type is not nullable,
    // then r.Failure is guaranteed not to be null.
    
    var myFailureValue = r.Failure!;
}

Match expressions

bool fileExists = ReadFile("/path/to/file").Match(
    onOk: _ => true,
    onFailure: _ => false
);

Mapping success values

        var r1 = Divide(10, 2).Map(x => 3 * x);
        // r1.IsOk is true
        // r1.Value is 15

        var r2 = Divide(10, 0).Map(x => 3 * x);
        // r2.IsOk is false
        // r2.Error is DivideByZeroException

Chaining of consecutive computations

You can chain computations that return suitable Result values in such a way that, if successful, the chain runs cleanly to the end, but if an intermediate step fails, the failure value is passed through to the end.

var r3 = Divide(64, 2)
    .Bind(x => Divide(x, 2))
    .Bind(x => Divide(x, 2))
    .Bind(x => Divide(x, 2))
    .Bind(x => Divide(x, 2))
    .Bind(x => Divide(x, 2));

// r3.IsOk is true
// r3.Value is 1

var r4 = Divide(64, 2)
    .Bind(x => Divide(x, 2))
    .Bind(x => Divide(x, 2))
    .Bind(x => Divide(x, 0))
    .Bind(x => Divide(x, 2))
    .Bind(x => Divide(x, 2));

// r4.IsOk is false
// r4.Failure is DivideByZeroException