Result<int, SingleError> Calculate(int input)
{
    return input != 0 
        ? 100 / input 
        : new SingleError("Division by zero");
}

var result = Calculate(10);
result.Match(
    onSuccess: value => Console.WriteLine($"Result: {value}"),
    onFailure: error => Console.WriteLine($"Error: {error.Message}")
);

Result<int, SingleError> result = Result.Success<int, SingleError>(5)
    .Map(x => x * 2)  // Transforms value if successful
    .Bind(x => x < 100 
        ? x * 3 
        : Result.Failure<int, SingleError>(new SingleError("Too large")))
    .Ensure(x => x % 2 == 0, () => new SingleError("Must be even"));

async ValueTask<Result<string, SingleError>> ProcessDataAsync(int id)
{
    return await FetchDataAsync(id)
        .MapAsync(async data => await TransformAsync(data))
        .BindAsync(async transformed => await ValidateAsync(transformed))
        .OnSuccessAsync(async result => await LogSuccessAsync(result))
        .OnFailureAsync(async error => await LogErrorAsync(error));
}

Result<User, ValidationError> ValidateUser(User user)
{
    return Result.Success<User, ValidationError>(user)
        .Ensure(u => u.Age >= 18, () => new ValidationError("Underage"))
        .Ensure(u => !string.IsNullOrEmpty(u.Email), () => new ValidationError("Invalid email"));
}

async ValueTask<Result<Report, BusinessError>> GenerateReportAsync(int userId)
{
    return await GetUser(userId)
        .Map(user => new ReportRequest(user))
        .BindAsync(async request => await ValidateRequestAsync(request))
        .MapAsync(async validRequest => await GenerateReportAsync(validRequest));
}

// Traditional approach (expensive exceptions)
try {
    var value = RiskyOperation();
    Process(value);
}
catch (Exception ex) {
    HandleError(ex);
}

// ZeroResult approach (explicit error handling)
var result = SafeOperation();
result.Match(
    onSuccess: Process,
    onFailure: HandleError
);

Result<Order, OrderError> orderResult = ProcessOrder(orderId);
string message = orderResult.Match(
    onSuccess: order => $"Order {order.Id} processed",
    onFailure: error => $"Failed: {error.Message}"
);

// Async version
string asyncMessage = await orderResult.MatchAsync(
    onSuccess: async order => await FormatOrderAsync(order),
    onFailure: async error => await FormatErrorAsync(error)
);

await GetUserAsync(userId)
    .TapAsync(async user => await AuditAccessAsync(user))
    .MapAsync(user => user.Profile)
    .Tap(profile => CacheProfile(profile));

var errors = new IError[] {
    new SingleError("Invalid email format", "VAL-001"),
    new SingleError("Password must be 8+ characters", "SEC-002"),
    new SingleError("Username already exists", "USER-003")
};

Result<Unit, MultiError> validationResult = new MultiError(errors);

Result<User, MultiError> ValidateUser(UserInput input)
{
    var builder = MultiError.CreateBuilder();
    
    if (string.IsNullOrEmpty(input.Email))
        builder.Add(new SingleError("Email required", "REQ-001"));
    
    if (input.Password.Length < 8)
        builder.Add(new SingleError("Password too short", "SEC-001"));
    
    if (input.Age < 18)
        builder.Add(new SingleError("Must be 18+", "AGE-001"));
    
    return builder.Count > 0
        ? Result.Failure<User, MultiError>(builder.Build())
        : MapToUser(input);
}

async ValueTask<Result<BatchReport, MultiError>> ProcessBatchAsync(int[] ids)
{
    var builder = MultiError.CreateBuilder();
    var successes = new List<ItemResult>();
    
    foreach (var id in ids)
    {
        var result = await ProcessItemAsync(id);
        result.Match(
            onSuccess: successes.Add,
            onFailure: builder.Add
        );
    }
    
    return builder.Count > 0
        ? Result.Failure<BatchReport, MultiError>(builder.Build())
        : new BatchReport(successes);
}

var addressResult = ValidateAddress(order.Address);
var paymentResult = ValidatePayment(order.PaymentMethod);

if (addressResult.IsFailure || paymentResult.IsFailure)
{
    var mergedErrors = MultiError.Merge(
        addressResult.IsFailure ? addressResult.Error : MultiError.Empty,
        paymentResult.IsFailure ? paymentResult.Error : MultiError.Empty
    );
    
    return Result.Failure<OrderConfirmation, MultiError>(mergedErrors);
}

Result<LoanApplication, MultiError> ValidateApplication(LoanApplication app)
{
    var builder = MultiError.CreateBuilder();
    
    // Financial validation
    if (app.Income < app.MonthlyPayment * 3)
        builder.Add(new SingleError("Income insufficient", "FIN-001"));
    
    // Document validation
    if (app.RequiredDocuments.Count < 3)
        builder.Add(new SingleError("Missing documents", "DOC-002"));
    
    // Business rules
    if (app.Age < 21)
        builder.Add(new SingleError("Minimum age not met", "AGE-003"));
    
    // Custom validation method
    ValidateCreditHistory(app.CreditScore, builder);
    
    return builder.Count > 0
        ? Result.Failure<LoanApplication, MultiError>(builder.Build())
        : app;
}

void ValidateCreditHistory(int score, MultiErrorBuilder builder)
{
    if (score < 650)
        builder.Add(new SingleError("Poor credit history", "CRD-004"));
}

var error = new MultiError(new IError[] {
    new SingleError("Invalid email format", "VAL-001"),
    new SingleError("Password too short", "SEC-002"),
    new SingleError("Terms not accepted", "REQ-003")
});

Console.WriteLine(error.Message);
/* Output:
Multiple errors occurred (3):
- Invalid email format (Code: VAL-001)
- Password too short (Code: SEC-002)
- Terms not accepted (Code: REQ-003)
*/

StackResult<Transaction, MultiError> ValidateTransaction(Transaction tx)
{
    var builder = MultiError.CreateBuilder();
    // ... validation logic
    return builder.Count > 0
        ? StackResult.Failure<Transaction, MultiError>(builder.Build())
        : tx;
}