IndQuestResults 1.4.1

IndQuestResults - Enterprise-Grade Result<T> Library

A battle-tested, enterprise-grade Result<T> library for functional error handling in .NET applications. Provides type-safe, performant, and expressive ways to represent operation outcomes without exceptions.

Key Features

• Type safety: eliminate null-reference exceptions in control flow
• Performance: Span-based optimizations and reduced allocations
• Functional: Map, Bind, Match, Recover with fluent composition
• Thread-safe: immutable design, no shared mutable state
• JSON serializable: API responses and persistence ready (System.Text.Json)
• Warnings on success: diagnostics with quality metadata
• Quality: mutation-tested, high coverage

Quick Start

Installation

dotnet add package IndQuestResults

Basic Usage

using IndQuestResults;

// Success results
var ok = Result.Success();
var okWithValue = Result<string>.Success("Hello World");

// Failure results
var fail = Result.WithFailure("Operation failed");
var failWithValue = Result<int>.WithFailure("Parse error", value: 0);

// Multiple errors
var many = Result.WithFailure(new[] { "Error 1", "Error 2" });

// Warnings (successful with diagnostics)
var withWarnings = Result<string>.WithWarnings(
    new[] { "Performance warning" },
    "Operation completed"
);

// Warnings with quality metadata (confidence + missing data ratio)
var withWarnsAndMeta = Result<string>.WithWarnings(
    warnings: new[] { "Heuristic fill for missing fields", "Low signal period" },
    value: "Computed",
    confidence: 0.82,            // clamped to [0,1]
    missingDataRatio: 0.25       // clamped to [0,1]
);
Console.WriteLine(withWarnsAndMeta.Confidence);        // 0.82
Console.WriteLine(withWarnsAndMeta.MissingDataRatio);  // 0.25
Console.WriteLine(string.Join(", ", withWarnsAndMeta.Warnings));

Functional Programming (Sync)

using IndQuestResults;

Result<UserDto> CreateUser(string userId)
{
    return Result<string>.Success(userId)
        .Ensure(id => !string.IsNullOrWhiteSpace(id), "empty id")
        .Bind(id => LoadUser(id))
        .Map(user => user.ToDto())
        .Tap(dto => _logger.LogInformation($"User {dto.Id} processed"))
        .Recover(() => Result<UserDto>.Success(UserDto.Default));
}

Async

Use the async API in IndQuestResults.Async.ResultAsync for fluent async composition.

using IndQuestResults;
using IndQuestResults.Async;

var dto = await ResultAsync
    .BindAsync(GetUserAsync(userId), user => ValidateUserAsync(user))
    .MapAsync(valid => valid.ToDtoAsync())
    .TapAsync(dto => CacheAsync(dto))
    .RecoverAsync(() => GetDefaultUserDtoAsync());

// Collections
var users = await ResultAsync.TraverseParallelAsync(
    userIds,
    id => GetUserAsync(id),
    maxDegreeOfParallelism: 4
);

Async railway verbs: Then, Ensure, ToResult

The short, conventional railway verbs are available directly on Task<Result<T>> (and Then on Result<T>), mirroring the synchronous surface so the async chain is no longer asymmetric:

using IndQuestResults;
using IndQuestResults.Operations;

Task<Result<OrderDto>> Handle(CreateOrder request) =>
    Result.Success(request)                              // chain-starting factory on the non-generic Result
        .ValidateNotNull(r => (r.CustomerId, nameof(request.CustomerId)))
        .Then(r => Result<Order>.Success(new Order(r)))  // returns Result<T> => binds/flattens (no nesting)
        .ThenAsync(order => _repo.SaveAsync(order))      // async-bind
        .Ensure(order => order.Total > 0, "empty order") // async predicate guard
        .Then(OrderDto.ToDto);                           // returns a value => maps

// ToResult: adapt a nullable-async lookup to a Result<T>, failing on null.
Task<Result<Customer>> customer =
    _repo.FindCustomerAsync(id)        // Task<Customer?>
         .ToResult("customer not found");

Then disambiguation (bind-preferred): a delegate returning Result<TOut> (or Task<Result<TOut>>) binds/flattens — you never get a nested Result<Result<TOut>>; a delegate returning a plain value maps. When intent is unclear at the call site, reach for the explicit primitives Then delegates to — Map/Bind (sync) or ThenMap/ThenAsync (async).

ToResult precedence: an existing failure propagates first (its errors preserved); only a successful-but-null value is converted to failure(errorMessage).

Full API and patterns: docs/Result-Manual.md

More docs: docs/README.md

Note: Optional analyzers are available in IndQuestResults.Analyzers to guide async usage. Rule IQR0001 suggests using ResultAsync for async chaining and includes a one-click code fix.

Package Information

• Target Framework: .NET 10.0+
• Dependencies: none (zero external dependencies)
• Package ID: IndQuestResults
• License: MIT
• Coverage: 74.5% with comprehensive test suite
• Quality: 85%+ mutation testing score

Release Notes & Download

• Recommended: Release/IndQuestResults.1.0.7.nupkg
• Previous: Release/IndQuestResults.1.0.5.nupkg, Release/IndQuestResults.1.0.4.nupkg, Release/IndQuestResults.1.0.3.nupkg, Release/IndQuestResults.1.0.2.nupkg, Release/IndQuestResults.1.0.1.nupkg
• See CHANGELOG.md for details

Contributing

We welcome high-quality contributions! See CONTRIBUTING.md and CODE_OF_CONDUCT.md.

• 100% unit test coverage for new code
• Mutation testing score ≥ 85%
• Zero compilation warnings (warnings as errors)
• XML documentation for public APIs
• Benchmarks for performance-sensitive changes

License

This project is licensed under the MIT License - see the LICENSE file for details.

Support & Community

• Discussions: GitHub Discussions
• Issues: GitHub Issues
• Documentation: docs/Result-Manual.md
• Examples: Src/Code/samples/

Quality First: We maintain enterprise-grade standards because this library powers production applications. Every contribution makes the .NET ecosystem stronger!