Result & error model

A lookup reference for the result and error types. For the conceptual model and how these flow through handlers and decorators, see Results & errors.

All four core types live in Elarion.Abstractions. The two mappers live in the transport packages: Elarion.AppErrorMapper (JSON-RPC) and Elarion.AspNetCore.HttpAppErrorMapper (HTTP).

Result<T>

Elarion.Abstractions.Result<T> — a readonly struct wrapping either a success value or an AppError. It implements IResultLike and IResultFailureFactory<Result<T>>.

public readonly struct Result<T> : IResultLike, IResultFailureFactory<Result<T>> {
    public bool IsSuccess { get; }
    public T Value { get; }       // valid only when IsSuccess is true
    public AppError Error { get; } // valid only when IsSuccess is false

    public static Result<T> Success(T value);
    public static Result<T> Failure(AppError error);

    public static implicit operator Result<T>(T value);      // success
    public static implicit operator Result<T>(AppError error); // failure
}

The implicit conversions let a handler return a response value or an AppError directly:

return new Response(project.Id);                 // implicit Success
return AppError.NotFound($"Project {id} not found"); // implicit Failure

Result (non-generic)

Elarion.Abstractions.Result — the no-value companion for operations that produce no response, returned by the IHandler<T> convenience interface. It converts to Result<Unit> so it never enters the generic dispatch/decorator pipeline.

public readonly struct Result : IResultLike, IResultFailureFactory<Result> {
    public bool IsSuccess { get; }
    public AppError Error { get; } // valid only when IsSuccess is false

    public static Result Success();
    public static Result Failure(AppError error);

    public static implicit operator Result(AppError error); // failure

    public Result<Unit> ToResultUnit();
    public static implicit operator Result<Unit>(Result result);
}

Unit

Elarion.Abstractions.Results.Unit — a readonly struct with exactly one value, used as the "no value" payload for Result<Unit>. All Unit values are equal.

public readonly struct Unit : IEquatable<Unit> {
    public static Unit Value => default; // the single value
    // == always true, != always false, ToString() => "()"
}

using ResultUnit = Elarion.Abstractions.Results.Unit; // or: using DomainUnit = MyApp.Domain.Unit;

IResultLike

Elarion.Abstractions.IResultLike — the non-generic seam decorators use to inspect success/failure without knowing T:

public interface IResultLike {
    bool IsSuccess { get; }
}

Both Result<T> and Result implement it, so a decorator can branch on the outcome:

if (response is IResultLike { IsSuccess: true }) {
    await transaction.CommitAsync(ct);
} else {
    await transaction.RollbackAsync(ct);
}

AppError

Elarion.Abstractions.AppError — a transport-agnostic sealed record describing the kind of failure, not how a protocol should report it:

public sealed record AppError {
    public required ErrorKind Kind { get; init; }
    public required string Message { get; init; }
    public object? Data { get; init; }

    // Shared singleton for the generic internal-failure case.
    public static readonly AppError InternalError; // Kind = Internal, Message = "Internal error"
}

Factory methods

AppError.Validation("Invalid command.", new[] { "Name is required.", "Email is invalid." });
AppError.NotFound($"Client {id} was not found.");
AppError.BusinessRule("Credit limit exceeded.", data: limitInfo);

ValidationErrorData is the payload shape for the list-of-messages overload:

public sealed record ValidationErrorData {
    public required IReadOnlyList<string> Errors { get; init; }
}

ErrorKind

Elarion.Abstractions.ErrorKind — the semantic category. The transport layer maps it to protocol-specific codes.

ErrorKind mappings

Kind is the seam between application semantics and protocol codes. Each host owns its mapping; the tables below are the framework defaults. The unknown/default branch of both mappers falls through to the Internal row.

JSON-RPC error code

From Elarion.AppErrorMapper.MapToCode(ErrorKind). Protocol-level kinds reuse the JSON-RPC 2.0 spec codes; the remaining application kinds use the reserved server range (-32000 to -32099). AppErrorMapper.ToRpcError(AppError) wraps the code with the error's Message and Data.

HTTP status code

From Elarion.AspNetCore.HttpAppErrorMapper.MapToStatusCode(ErrorKind), used by ElarionHttpResults when translating a failed Result<T> into an RFC 7807 ProblemDetails response.