// ❌ Naive підхід - що може піти не так?
public void TransferMoney(string fromAccount, string toAccount, decimal amount)
{
    var from = _accounts[fromAccount];
    var to = _accounts[toAccount];

    from.Balance -= amount;
    to.Balance += amount;

    _repository.Save(from);
    _repository.Save(to);
}

public class SyntacticExamples
{
    public void ValidateInput(string email, string ageRaw, string json)
    {
        // 1. Формат (Regex/Library)
        if (!new EmailAddressAttribute().IsValid(email))
            throw new FormatException("Invalid email format");

        // 2. Тип даних (Parsing)
        if (!int.TryParse(ageRaw, out _))
            throw new FormatException("Age must be a number");

        // 3. Структура (Well-formedness)
        try {
            JsonDocument.Parse(json);
        } catch (JsonException) {
            throw new FormatException("Invalid JSON structure");
        }
    }
}

public void SemanticChecks(DateTime dateOfBirth, string countryCode)
{
    // Синтаксично дата валідна (це struct DateTime),
    // але семантично вона не може бути в майбутньому для народження.
    if (dateOfBirth > DateTime.Now)
        return Result.Fail("Date of birth cannot be in the future");

    // "ZZ" — це валідний рядок з 2 літер (синтаксис),
    // але такої країни не існує (семантика).
    if (!IsoCountries.Contains(countryCode))
        return Result.Fail($"Country code '{countryCode}' is not supported");
}

public class Period : IValidatableObject
{
    public DateTime Start { get; set; }
    public DateTime End { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext context)
    {
        // Перевірка відношення між полями
        if (End < Start)
        {
            yield return new ValidationResult(
                "End date must be greater than or equal to Start date",
                new[] { nameof(End) });
        }
    }
}

// Приклад умовної залежності
public void ValidatePayment(PaymentDto dto)
{
    if (dto.Method == PaymentMethod.CreditCard && string.IsNullOrEmpty(dto.CardNumber))
    {
        // CardNumber сам по собі може бути null (для готівки),
        // але в комбінації з CreditCard — це помилка структури.
        AddError("CardNumber is required for Credit Card payments");
    }
}

public async Task<Result> CancelOrderAsync(int orderId, int userId)
{
    var order = await _repo.GetByIdAsync(orderId);

    // 1. State-based validation
    if (order.Status == OrderStatus.Shipped)
        return Result.Fail("Cannot cancel an order that has already been shipped.");

    // 2. Ownership/Permission evaluation (Authorization as Validation)
    if (order.CustomerId != userId && !User.IsAdmin)
        return Result.Fail("You do not have permission to cancel this order.");

    // 3. External Constraint
    if (await _warehouse.IsProcessingAsync(orderId))
        return Result.Fail("Order is currently being processed by warehouse.");

    // Якщо дійшли сюди — контекст дозволяє дію
    order.Status = OrderStatus.Cancelled;
    await _repo.SaveAsync(order);
    return Result.Ok();
}

public void ProcessOrder(Order order, User user)
{
    // ❌ Без guard clauses - nested hell
    if (order != null)
    {
        if (user != null)
        {
            if (order.Items.Count > 0)
            {
                if (user.IsActive)
                {
                    // Фактична логіка десь тут...
                }
                else
                    throw new InvalidOperationException("User is not active");
            }
            else
                throw new ArgumentException("Order has no items");
        }
        else
            throw new ArgumentNullException(nameof(user));
    }
    else
        throw new ArgumentNullException(nameof(order));
}

// ✅ З guard clauses - linear and clear
public void ProcessOrder(Order order, User user)
{
    // Guards спочатку - виходимо рано при проблемах
    ArgumentNullException.ThrowIfNull(order);
    ArgumentNullException.ThrowIfNull(user);

    if (order.Items.Count == 0)
        throw new ArgumentException("Order must contain at least one item", nameof(order));

    if (!user.IsActive)
        throw new InvalidOperationException("Cannot process order for inactive user");

    // Happy path - без вкладеності
    var total = order.CalculateTotal();
    _paymentService.Charge(user, total);
    _emailService.SendConfirmation(user.Email, order);
}

public class ArgumentNullExceptionExamples
{
    // ✅ Modern way (.NET 6+)
    public void ModernGuards(string name, int age, List<string> items)
    {
        ArgumentNullException.ThrowIfNull(name);
        ArgumentNullException.ThrowIfNull(items);
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(age);
        ArgumentOutOfRangeException.ThrowIfZero(items.Count);
    }

    // ❌ Old way (before .NET 6)
    public void OldGuards(string name, int age, List<string> items)
    {
        if (name == null)
            throw new ArgumentNullException(nameof(name));
        if (items == null)
            throw new ArgumentNullException(nameof(items));
        if (age <= 0)
            throw new ArgumentOutOfRangeException(nameof(age), "Age must be positive");
        if (items.Count == 0)
            throw new ArgumentOutOfRangeException(nameof(items), "Items cannot be empty");
    }
}

public static class Guard
{
    public static void AgainstNullOrEmpty(string value, string paramName)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value, paramName);
    }

    public static void AgainstNegative(decimal value, string paramName)
    {
        if (value < 0)
            throw new ArgumentOutOfRangeException(paramName, $"{paramName} cannot be negative");
    }

    public static void AgainstInvalidEmail(string email, string paramName)
    {
        if (!new EmailAddressAttribute().IsValid(email))
            throw new ArgumentException($"Invalid email format: {email}", paramName);
    }

    public static void AgainstPastDate(DateTime date, string paramName)
    {
        if (date < DateTime.Now)
            throw new ArgumentException($"{paramName} cannot be in the past", paramName);
    }

    public static void AgainstOutOfRange<T>(T value, T min, T max, string paramName)
        where T : IComparable<T>
    {
        if (value.CompareTo(min) < 0 || value.CompareTo(max) > 0)
            throw new ArgumentOutOfRangeException(paramName,
                $"{paramName} must be between {min} and {max}");
    }
}

// Використання
public void ScheduleEvent(string title, DateTime eventDate, decimal ticketPrice)
{
    Guard.AgainstNullOrEmpty(title, nameof(title));
    Guard.AgainstPastDate(eventDate, nameof(eventDate));
    Guard.AgainstNegative(ticketPrice, nameof(ticketPrice));

    // Business logic
}

#nullable enable

public class UserService
{
    // Compiler попереджає, якщо можливий null
    public void SendEmail(User user)  // user is non-nullable
    {
        Console.WriteLine(user.Email);  // Safe
    }

    public void SendEmailNullable(User? user)  // user is nullable
    {
        // ❌ Compiler warning: Possible null reference
        // Console.WriteLine(user.Email);

        // ✅ Explicit null check
        if (user is not null)
        {
            Console.WriteLine(user.Email);
        }
    }
}

public class NullSafetyExamples
{
    public string GetUserName(User? user)
    {
        // Null coalescing operator (??)
        return user?.Name ?? "Anonymous";  // Якщо null, повертає "Anonymous"
    }

    public int GetOrderCount(User? user)
    {
        // Null-conditional operator (?.) + null coalescing
        return user?.Orders?.Count ?? 0;  // Безпечний ланцюг
    }

    public void ProcessUser(User? user)
    {
        // Null coalescing assignment (??=) - .NET 8+
        user ??= new User { Name = "Default" };  // Присвоює, якщо null

        // Тепер user гарантовано не null
        Console.WriteLine(user.Name);
    }
}

using System.ComponentModel.DataAnnotations;

public class RegisterUserDto
{
    [Required(ErrorMessage = "Email is required")]
    [EmailAddress(ErrorMessage = "Invalid email format")]
    [MaxLength(100, ErrorMessage = "Email cannot exceed 100 characters")]
    public string Email { get; set; }

    [Required]
    [StringLength(50, MinimumLength = 3, ErrorMessage = "Name must be between 3 and 50 characters")]
    public string Name { get; set; }

    [Range(18, 120, ErrorMessage = "Age must be between 18 and 120")]
    public int Age { get; set; }

    [Phone]
    public string? PhoneNumber { get; set; }

    [Url]
    public string? Website { get; set; }

    [RegularExpression(@"^[A-Z]{2}\d{4}$", ErrorMessage = "Invalid format. Expected: XX1234")]
    public string EmployeeCode { get; set; }

    [CreditCard]
    public string? CardNumber { get; set; }

    [Compare(nameof(Password), ErrorMessage = "Passwords do not match")]
    public string ConfirmPassword { get; set; }

    [Required]
    [MinLength(8, ErrorMessage = "Password must be at least 8 characters")]
    public string Password { get; set; }
}

public class ValidationService
{
    public (bool IsValid, List<string> Errors) ValidateObject(object obj)
    {
        var context = new ValidationContext(obj);
        var results = new List<ValidationResult>();

        bool isValid = Validator.TryValidateObject(obj, context, results, validateAllProperties: true);

        var errors = results.Select(r => r.ErrorMessage ?? "Unknown error").ToList();

        return (isValid, errors);
    }
}

// Використання
var dto = new RegisterUserDto
{
    Email = "invalid-email",  // ❌ Invalid format
    Name = "Jo",              // ❌ Too short
    Age = 15                  // ❌ Below minimum
};

var (isValid, errors) = new ValidationService().ValidateObject(dto);

if (!isValid)
{
    foreach (var error in errors)
        Console.WriteLine($"- {error}");

    // Output:
    // - Invalid email format
    // - Name must be between 3 and 50 characters
    // - Age must be between 18 and 120
}

public class EventBookingDto : IValidatableObject
{
    [Required]
    public DateTime StartDate { get; set; }

    [Required]
    public DateTime EndDate { get; set; }

    [Range(1, 1000)]
    public int Attendees { get; set; }

    [Required]
    public string EventType { get; set; }  // "Conference", "Workshop", etc.

    // Custom validation logic
    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        // Cross-field validation: EndDate must be after StartDate
        if (EndDate <= StartDate)
        {
            yield return new ValidationResult(
                "End date must be after start date",
                new[] { nameof(EndDate) }  // Specify which property has error
            );
        }

        // Conditional validation: Conferences require at least 10 attendees
        if (EventType == "Conference" && Attendees < 10)
        {
            yield return new ValidationResult(
                "Conferences must have at least 10 attendees",
                new[] { nameof(Attendees) }
            );
        }

        // Time-based validation: Cannot book events less than 24 hours in advance
        if (StartDate < DateTime.Now.AddHours(24))
        {
            yield return new ValidationResult(
                "Events must be booked at least 24 hours in advance",
                new[] { nameof(StartDate) }
            );
        }
    }
}

dotnet add package FluentValidation
dotnet add package FluentValidation.DependencyInjectionExtensions

using FluentValidation;

public class CreateUserDto
{
    public string Email { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public string Password { get; set; }
}

public class CreateUserValidator : AbstractValidator<CreateUserDto>
{
    public CreateUserValidator()
    {
        RuleFor(x => x.Email)
            .NotEmpty().WithMessage("Email is required")
            .EmailAddress().WithMessage("Invalid email format")
            .MaximumLength(100).WithMessage("Email is too long");

        RuleFor(x => x.Name)
            .NotEmpty()
            .Length(3, 50).WithMessage("Name must be between 3 and 50 characters")
            .Matches(@"^[a-zA-Z\s]+$").WithMessage("Name can only contain letters and spaces");

        RuleFor(x => x.Age)
            .InclusiveBetween(18, 120).WithMessage("Age must be between 18 and 120");

        RuleFor(x => x.Password)
            .NotEmpty()
            .MinimumLength(8).WithMessage("Password must be at least 8 characters")
            .Matches(@"[A-Z]").WithMessage("Password must contain at least one uppercase letter")
            .Matches(@"[a-z]").WithMessage("Password must contain at least one lowercase letter")
            .Matches(@"[0-9]").WithMessage("Password must contain at least one digit")
            .Matches(@"[@$!%*?&#]").WithMessage("Password must contain at least one special character");
    }
}

var dto = new CreateUserDto
{
    Email = "invalid",
    Name = "Jo",
    Age = 15,
    Password = "weak"
};

var validator = new CreateUserValidator();
var result = validator.Validate(dto);

if (!result.IsValid)
{
    foreach (var error in result.Errors)
    {
        Console.WriteLine($"[{error.PropertyName}] {error.ErrorMessage}");
    }

    // Output:
    // [Email] Invalid email format
    // [Name] Name must be between 3 and 50 characters
    // [Age] Age must be between 18 and 120
    // [Password] Password must be at least 8 characters
    // [Password] Password must contain at least one uppercase letter
    // [Password] Password must contain at least one lowercase letter
    // [Password] Password must contain at least one digit
    // [Password] Password must contain at least one special character
}

// Program.cs або Startup.cs
using FluentValidation;
using FluentValidation.AspNetCore;

var builder = WebApplication.CreateBuilder(args);

// Додавання FluentValidation до DI
builder.Services.AddControllers()
    .AddFluentValidation(config =>
    {
        // Автоматична реєстрація всіх валідаторів з assembly
        config.RegisterValidatorsFromAssemblyContaining<Program>();

        // Автоматична валідація при Model Binding
        config.AutomaticValidationEnabled = true;
    });

// Controller usage
[ApiController]
[Route("api/users")]
public class UsersController : ControllerBase
{
    [HttpPost]
    public IActionResult CreateUser([FromBody] CreateUserDto dto)
    {
        // Якщо валідація провалена, ASP.NET автоматично повертає 400 Bad Request
        if (!ModelState.IsValid)
            return BadRequest(ModelState);

        // Business logic
        return Ok();
    }
}

// ❌ Exception-Driven Development
public User GetUserByEmail(string email)
{
    var user = _repository.FindByEmail(email);

    if (user == null)
        throw new UserNotFoundException($"User with email {email} not found");

    if (!user.IsActive)
        throw new UserInactiveException("User account is deactivated");

    if (user.IsLocked)
        throw new UserLockedException("User account is locked");

    return user;
}

// Calling code
try
{
    var user = GetUserByEmail("test@example.com");
    ProcessUser(user);
}
catch (UserNotFoundException ex)
{
    return NotFound(ex.Message);
}
catch (UserInactiveException ex)
{
    return BadRequest(ex.Message);
}
catch (UserLockedException ex)
{
    return Forbidden(ex.Message);
}

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

public class ExceptionVsResultBenchmark
{
    [Benchmark]
    public int ExceptionFlow()
    {
        try
        {
            return DivideWithException(10, 0);
        }
        catch
        {
            return -1;
        }
    }

    [Benchmark]
    public int ResultFlow()
    {
        var result = DivideWithResult(10, 0);
        return result.IsSuccess ? result.Value : -1;
    }

    private int DivideWithException(int a, int b)
    {
        if (b == 0) throw new DivideByZeroException();
        return a / b;
    }

    private Result<int> DivideWithResult(int a, int b)
    {
        if (b == 0) return Result.Fail<int>("Cannot divide by zero");
        return Result.Ok(a / b);
    }
}

// Запуск: dotnet run -c Release
BenchmarkRunner.Run<ExceptionVsResultBenchmark>();

public class Result
{
    public bool IsSuccess { get; }
    public bool IsFailure => !IsSuccess;
    public string Error { get; }

    protected Result(bool isSuccess, string error)
    {
        if (isSuccess && !string.IsNullOrEmpty(error))
            throw new InvalidOperationException("Success result cannot have an error");

        if (!isSuccess && string.IsNullOrEmpty(error))
            throw new InvalidOperationException("Failure result must have an error");

        IsSuccess = isSuccess;
        Error = error ?? string.Empty;
    }

    // Factory methods
    public static Result Ok() => new Result(true, null);
    public static Result Fail(string error) => new Result(false, error);
}

// Generic version for results with value
public class Result<T> : Result
{
    public T Value { get; }

    protected Result(T value, bool isSuccess, string error)
        : base(isSuccess, error)
    {
        Value = value;
    }

    // Factory methods
    public static Result<T> Ok(T value) => new Result<T>(value, true, null);
    public static Result<T> Fail(string error) => new Result<T>(default, false, error);
}

public class UserService
{
    public Result<User> GetUserByEmail(string email)
    {
        // Validation
        if (string.IsNullOrWhiteSpace(email))
            return Result<User>.Fail("Email is required");

        var user = _repository.FindByEmail(email);

        // Business logic check
        if (user == null)
            return Result<User>.Fail("User not found");

        if (!user.IsActive)
            return Result<User>.Fail("User account is deactivated");

        if (user.IsLocked)
            return Result<User>.Fail("User account is locked");

        return Result<User>.Ok(user);
    }
}

// Calling code - явна обробка результату
var result = _userService.GetUserByEmail("test@example.com");

if (result.IsFailure)
{
    _logger.LogWarning("Failed to get user: {Error}", result.Error);
    return BadRequest(result.Error);
}

var user = result.Value;
ProcessUser(user);

/// <summary>
/// Represents a domain error with a unique code and descriptive message.
/// </summary>
public sealed record Error
{
    /// <summary>
    /// Unique error code (e.g., "User.NotFound").
    /// </summary>
    public string Code { get; }

    /// <summary>
    /// Human-readable error message for debugging.
    /// </summary>
    public string Message { get; }

    /// <summary>
    /// Represents the absence of an error.
    /// </summary>
    public static readonly Error None = new(string.Empty, string.Empty);

    private Error(string code, string message)
    {
        Code = code;
        Message = message;
    }

    /// <summary>
    /// Factory method to create a new error.
    /// </summary>
    public static Error Create(string code, string message) => new(code, message);

    // Implicit conversion для зручності
    public static implicit operator string(Error error) => error.Code;
}

public class Result
{
    public bool IsSuccess { get; }
    public bool IsFailure => !IsSuccess;
    public Error Error { get; }

    protected Result(bool isSuccess, Error error)
    {
        // Інваріанти
        if (isSuccess && error != Error.None)
            throw new InvalidOperationException("Success result cannot have an error");

        if (!isSuccess && error == Error.None)
            throw new InvalidOperationException("Failure result must have an error");

        IsSuccess = isSuccess;
        Error = error;
    }

    // Factory methods
    public static Result Ok() => new(true, Error.None);
    public static Result Fail(Error error) => new(false, error);
}

// Generic версія
public class Result<T> : Result
{
    public T Value { get; }

    protected Result(T value, bool isSuccess, Error error)
        : base(isSuccess, error)
    {
        Value = value;
    }

    public static Result<T> Ok(T value) => new(value, true, Error.None);
    public static Result<T> Fail(Error error) => new(default, false, error);
}

/// <summary>
/// Централізоване сховище всіх доменних помилок.
/// </summary>
public static class DomainErrors
{
    /// <summary>
    /// Помилки, пов'язані з User aggregate.
    /// </summary>
    public static class User
    {
        public static readonly Error NotFound = Error.Create(
            "User.NotFound",
            "The user with the specified identifier was not found.");

        public static readonly Error InvalidCredentials = Error.Create(
            "User.InvalidCredentials",
            "The provided email or password is incorrect.");

        public static readonly Error EmailTaken = Error.Create(
            "User.EmailTaken",
            "The specified email is already registered.");

        public static readonly Error Inactive = Error.Create(
            "User.Inactive",
            "The user account is deactivated.");

        public static readonly Error Locked = Error.Create(
            "User.Locked",
            "The user account is temporarily locked due to multiple failed login attempts.");
    }

    /// <summary>
    /// Помилки, пов'язані з Order aggregate.
    /// </summary>
    public static class Order
    {
        public static readonly Error NotFound = Error.Create(
            "Order.NotFound",
            "The order with the specified identifier was not found.");

        public static readonly Error Empty = Error.Create(
            "Order.Empty",
            "Order must contain at least one item.");

        public static readonly Error AlreadyShipped = Error.Create(
            "Order.AlreadyShipped",
            "Cannot modify an order that has already been shipped.");

        public static readonly Error InvalidTotal = Error.Create(
            "Order.InvalidTotal",
            "Order total must be greater than zero.");
    }

    /// <summary>
    /// Помилки, пов'язані з Payment process.
    /// </summary>
    public static class Payment
    {
        public static readonly Error InsufficientFunds = Error.Create(
            "Payment.InsufficientFunds",
            "Insufficient funds in the account.");

        public static readonly Error InvalidCard = Error.Create(
            "Payment.InvalidCard",
            "The provided credit card is invalid or expired.");

        public static readonly Error GatewayError = Error.Create(
            "Payment.GatewayError",
            "Payment gateway is currently unavailable.");

        public static readonly Error AmountTooLow = Error.Create(
            "Payment.AmountTooLow",
            "Payment amount must be at least $1.00.");
    }
}

public class UserService
{
    public Result<User> GetUserByEmail(string email)
    {
        if (string.IsNullOrWhiteSpace(email))
            return Result<User>.Fail(DomainErrors.User.InvalidCredentials);

        var user = _repository.FindByEmail(email);

        if (user is null)
            return Result<User>.Fail(DomainErrors.User.NotFound);

        if (!user.IsActive)
            return Result<User>.Fail(DomainErrors.User.Inactive);

        if (user.IsLocked)
            return Result<User>.Fail(DomainErrors.User.Locked);

        return Result<User>.Ok(user);
    }

    public Result RegisterUser(string email, string password)
    {
        if (_repository.ExistsByEmail(email))
            return Result.Fail(DomainErrors.User.EmailTaken);

        var user = new User(email, _passwordHasher.Hash(password));
        _repository.Add(user);

        return Result.Ok();
    }
}

// Використання в Controller
[HttpGet("{email}")]
public IActionResult GetUser(string email)
{
    var result = _userService.GetUserByEmail(email);

    if (result.IsFailure)
    {
        // Pattern matching за кодом помилки
        return result.Error.Code switch
        {
            "User.NotFound" => NotFound(result.Error.Message),
            "User.Inactive" => BadRequest(result.Error.Message),
            "User.Locked" => StatusCode(423, result.Error.Message), // 423 Locked
            _ => BadRequest(result.Error.Message)
        };
    }

    return Ok(result.Value);
}

public class Result<T>
{
    // ... попередній код ...

    // Map: Transform value if success
    public Result<TNew> Map<TNew>(Func<T, TNew> mapper)
    {
        if (IsFailure)
            return Result<TNew>.Fail(Error);

        return Result<TNew>.Ok(mapper(Value));
    }

    // Bind (FlatMap): Chain operations that return Result
    public Result<TNew> Bind<TNew>(Func<T, Result<TNew>> binder)
    {
        if (IsFailure)
            return Result<TNew>.Fail(Error);

        return binder(Value);
    }

    // OnSuccess: Execute action if success
    public Result<T> OnSuccess(Action<T> action)
    {
        if (IsSuccess)
            action(Value);

        return this;
    }

    // OnFailure: Execute action if failure
    public Result<T> OnFailure(Action<string> action)
    {
        if (IsFailure)
            action(Error);

        return this;
    }

    // Match: Handle both cases
    public TResult Match<TResult>(
        Func<T, TResult> onSuccess,
        Func<string, TResult> onFailure)
    {
        return IsSuccess ? onSuccess(Value) : onFailure(Error);
    }
}

public class BankingService
{
    public Result TransferMoney(string fromAccountId, string toAccountId, decimal amount)
    {
        return GetAccount(fromAccountId)
            .Bind(fromAccount => GetAccount(toAccountId)
                .Map(toAccount => (From: fromAccount, To: toAccount)))
            .Bind(accounts => ValidateTransfer(accounts.From, amount))
            .Bind(fromAccount => DebitAccount(fromAccount, amount))
            .Bind(fromAccount => CreditAccount(toAccountId, amount)
                .Map(_ => fromAccount))
            .OnSuccess(fromAccount =>
                _logger.LogInformation("Transfer completed from {From}", fromAccount.Id))
            .OnFailure(error =>
                _logger.LogWarning("Transfer failed: {Error}", error));
    }

    private Result<Account> GetAccount(string accountId)
    {
        var account = _repository.Find(accountId);
        return account != null
            ? Result<Account>.Ok(account)
            : Result<Account>.Fail($"Account {accountId} not found");
    }

    private Result<Account> ValidateTransfer(Account account, decimal amount)
    {
        if (amount <= 0)
            return Result<Account>.Fail("Amount must be positive");

        if (account.Balance < amount)
            return Result<Account>.Fail("Insufficient funds");

        return Result<Account>.Ok(account);
    }

    private Result<Account> DebitAccount(Account account, decimal amount)
    {
        account.Balance -= amount;
        _repository.Update(account);
        return Result<Account>.Ok(account);
    }

    private Result CreditAccount(string accountId, decimal amount)
    {
        return GetAccount(accountId)
            .Bind(account =>
            {
                account.Balance += amount;
                _repository.Update(account);
                return Result.Ok();
            });
    }
}

dotnet add package FluentResults

using FluentResults;

public class UserService
{
    public Result<User> CreateUser(string email, string password)
    {
        // Simple failure
        if (string.IsNullOrEmpty(email))
            return Result.Fail("Email is required");

        // Failure with typed error
        if (!IsValidEmail(email))
            return Result.Fail(new InvalidEmailError(email));

        // Multiple errors
        var errors = new List<IError>();

        if (password.Length < 8)
            errors.Add(new Error("Password too short"));

        if (!HasSpecialChar(password))
            errors.Add(new Error("Password must contain special character"));

        if (errors.Any())
            return Result.Fail(errors);

        var user = new User { Email = email };
        _repository.Add(user);

        // Success with value
        return Result.Ok(user);
    }
}

// Custom Error Type
public class InvalidEmailError : Error
{
    public InvalidEmailError(string email)
        : base($"Email '{email}' is invalid")
    {
        Metadata.Add("EmailValue", email);
    }
}