Throwaway.CodeAnalysis.Analyzers 1.0.0

Throwaway

Exception-free error handling for C#. A lightweight Result pattern library with Roslyn analyzers that guide you toward explicit, composable error handling.

Overview

Throwaway provides:

• Result<T> and Result types - Explicit success/failure containers that replace exceptions for business logic
• Rich composition operators - Bind, Map, Match, Tap, Combine, TrySelect, OrElse, and more
• Heterogeneous Combine - Compose Results of different types into tuples
• Roslyn analyzers with code fixes - Detect anti-patterns and guide refactors in real-time

Installation

dotnet add package Throwaway.Core
dotnet add package Throwaway.CodeAnalysis.Analyzers

Quick Start

using Throwaway.Core;

public Result<User> GetUser(string id)
{
    // Explicit success or failure
    var userResult = await _db.GetUserAsync(id);
    if (userResult == null)
        return Result<User>.Failure(Error.NotFound("User not found"));

    return Result<User>.Success(userResult);
}

// Consume with explicit handling
userResult.Match(
    user => Console.WriteLine($"Hello {user.Name}"),
    error => Console.WriteLine($"Error: {error.Message}")
);

// Or pipeline operations
userResult
    .Bind(user => LoadPreferences(user.Id))
    .Tap(prefs => Console.WriteLine($"Loaded {prefs.Count} preferences"))
    .MapError(error => Error.Internal("Failed to load user"));

Heterogeneous Combine

Combine independent Results of different types into a single tuple Result:

using Throwaway.Core;
using static Throwaway.Core.Result;

var nameResult = ValidateName(input.Name);
var emailResult = ValidateEmail(input.Email);
var ageResult = ValidateAge(input.Age);

var combined = Result.Combine(nameResult, emailResult, ageResult);

combined.Match(
    (name, email, age) => CreateUser(name, email, age),
    error => HandleError(error)
);

Async version with parallel execution:

var combined = await Result.CombineAsync(
    ValidateNameAsync(input.Name),
    ValidateEmailAsync(input.Email),
    ValidateAgeAsync(input.Age)
);

Result Patterns

Bind (chain fallible operations)

userResult
    .Bind(user => LoadPreferences(user.Id))
    .Bind(prefs => ApplyTheme(prefs.SelectedTheme));

Map (transform success values)

userResult.Map(user => user.Name.ToUpper());

Match (handle both branches)

userResult.Match(
    user => $"Hello {user.Name}",
    error => $"Error: {error.Message}"
);

Tap (side effects)

userResult.Tap(user => _logger.LogInformation("Got user {UserId}", user.Id));

TrySelect (apply fallible operations to collections)

var userIds = new[] { 1, 2, 3 };
var results = await userIds.TrySelectAsync(id => GetUserAsync(id));

// Returns all successes OR first failure

OrElse (fallback on failure)

var result = await GetFromCacheAsync(key)
    .OrElse(() => GetFromDatabaseAsync(key))
    .OrElse(() => Result<User>.Success(DefaultUser));

Destructured Binding on Combined Results

Result.Combine(
    ValidateName(name),
    ValidateEmail(email),
    ValidateAge(age)
).Bind((validName, validEmail, validAge) =>
    CreateUser(validName, validEmail, validAge)
);

Analyzer Diagnostics

The analyzer package detects and helps fix common anti-patterns:

Documentation

• Design Spec: Heterogeneous Combine

License

MIT