MonadicSharpRailway-Oriented Programming

// Exception-driven: contract invisible to callers
public User CreateUser(string name, string email)
{
    if (string.IsNullOrWhiteSpace(name))
        throw new ValidationException("Name required");

    if (!email.Contains('@'))
        throw new ValidationException("Invalid email");

    var existing = _db.Users
        .FirstOrDefault(u => u.Email == email);
    if (existing != null)
        throw new ConflictException("Email taken");

    return _db.Save(new User(name, email));
}
// Every caller needs try/catch.
// Errors are invisible in the signature.

// Railway-Oriented: contract explicit in the return type
public Result<User> CreateUser(string name, string email) =>
    ValidateName(name)
        .Bind(_ => ValidateEmail(email))
        .Bind(_ => CheckEmailNotTaken(email))
        .Map(_ => new User(name, email))
        .Bind(user => _db.Users.AddAsync(user));

// The signature tells the truth.
// Errors propagate automatically — no try/catch.
// Compose at the controller with Match:
return result.Match(
    onSuccess: user  => Ok(user),
    onFailure: error => error.Type switch {
        ErrorType.Validation => BadRequest(error.Message),
        ErrorType.Conflict   => Conflict(error.Message),
        _                    => Problem(error.Message)
    });