Opale 1.0.0-alpha.5

Opale

A lightweight Result type for functional error handling in C#. Model success and failure explicitly, eliminate defensive exception handling, and compose operations safely with full async support.

Result<User, string> result = await GetUserAsync(id)
    .BindAsync(user => ValidateEmailAsync(user))
    .MapAsync(user => user with { IsVerified = true });

result.Match(
    onSuccess: user => Console.WriteLine($"Welcome, {user.Name}"),
    onFailure: error => Console.WriteLine($"Error: {error}")
);

Table of Contents

• Installation
• Getting Started
• API Reference
  • Creating Results
  • Pattern Matching
  • Transformations
  • Recovery
  • Side Effects
  • Inspection
  • Conversion
  • Exception Interop
• Async Support
• License

Installation

Supports .NET 8.0, .NET 9.0, and .NET 10.0.

dotnet add package Opale

Getting Started

The core type is Result<T, TError> — a discriminated union that holds either a success value or an error, never both.

using Opale;

// Create results
Result<int, string> success = Result<int, string>.Ok(42);
Result<int, string> failure = Result<int, string>.Fail("Something went wrong");

// Implicit conversion from T
Result<int, string> implicit = 42; // equivalent to Ok(42)

// Check state
if (result.IsSuccess)
    Console.WriteLine(result.Value);

if (result.IsFailure)
    Console.WriteLine(result.Error);

Wrapping exception-prone code

Use Result.Try to capture exceptions as typed failures:

Result<int, Exception> result = Result.Try(() => int.Parse(userInput));

API Reference

Creating Results

Pattern Matching

Execute different branches based on the result state.

// With return value
string message = result.Match(
    onSuccess: value => $"Got {value}",
    onFailure: error => $"Failed: {error}"
);

// Void branches
result.Match(
    onSuccess: value => Console.WriteLine(value),
    onFailure: () => Console.WriteLine("Failed")
);

Transformations

Chain operations without unwrapping.

Result<string, string> result = Result<int, string>.Ok(42)
    .Map(n => n * 2)          // 84
    .Map(n => n.ToString())   // "84"
    .Bind(s => s.Length > 0
        ? Result<string, string>.Ok(s)
        : Result<string, string>.Fail("Empty"));

// Transform the error type
Result<int, int> mapped = failedResult.MapError(err => err.Length);

Recovery

Provide fallback values or results on failure.

int value = result
    .Recover(error => 0)          // fallback value
    .GetValueOrDefault(-1);       // safe unwrap

Result<int, string> recovered = failedResult
    .RecoverWith(error => Result<int, string>.Ok(0));

Side Effects

Execute actions without breaking the chain.

Result<User, string> result = await GetUserAsync(id)
    .OnSuccess(user => logger.LogInfo($"Found user {user.Id}"))
    .OnFailure(error => logger.LogError(error));

All side-effect methods return this, preserving the original result for further chaining.

Inspection

Evaluate predicates against the result's value or error.

bool isAdult = result.IsSuccessAnd(user => user.Age >= 18);
bool isNotFound = result.IsFailureAnd(err => err == "NOT_FOUND");
bool hasValue = result.IsContains(expectedUser);

Conversion

// Returns the value or null/default on failure
User? user = result.ToOption();

Exception Interop

Bridge between Result and exception-based APIs.

// Throws if the result is a failure
User user = result.ToException(error => new NotFoundException(error));

// Wrap exception-prone code
Result<Data, Exception> safe = Result.Try(() => JsonSerializer.Deserialize<Data>(json));

Async Support

Every operation has a full async counterpart. Async pipelines can start from either Result<T, TError> or Task<Result<T, TError>>, which keeps railway-oriented code fluent without manually awaiting each step.

Result<UserDto, string> result = await GetUserAsync(id)           // Task<Result<User, string>>
    .BindAsync(user => FetchPermissionsAsync(user))               // async bind
    .MapAsync(user => MapToDto(user))                             // sync map in async context
    .OnSuccessAsync(dto => auditLog.WriteAsync($"Read {dto.Id}")) // async side effect
    .MatchAsync(
        onSuccess: dto => dto,
        onFailure: error => UserDto.Empty
    );

Most async variants accept both Func<T, Task<TResult>> and Func<T, TResult> so you can mix sync and async delegates freely.

License

MIT — see LICENSE for details.