Monad.NET.EntityFrameworkCore 2.0.0-beta.2

Monad.NET

Monad.NET is a functional programming library for .NET. Option, Result, Validation, Try, and more — with zero dependencies on .NET 6+.

// Transform nullable chaos into composable clarity
var result = user.ToOption()
    .Filter(u => u.IsActive)
    .Map(u => u.Email)
    .Bind(email => SendWelcome(email))
    .Match(
        some: _ => "Email sent",
        none: () => "User not found or inactive"
    );

Author: Behrang Mohseni
License: MIT — Free for commercial and personal use

Upgrading to v2.0

Version 2.0 is a major release focused on C#-idiomatic naming and API simplification:

• ~285 methods removed for better discoverability
• Rust-style → C#-style naming: Unwrap() → GetValue(), FlatMap → Bind, MapErr → MapError
• default(Result<T,E>) now protected: Throws InvalidOperationException to prevent invalid states
• 2,042 tests ensure correctness across all changes

All core functionality remains — removed methods have straightforward replacements using Match(), GetValueOr(), and LINQ.

See the full migration guide →

Table of Contents

• Why Monad.NET?
• Which Monad Should I Use?
• Installation
• Quick Start
• Documentation
• Examples
• Performance
• Resources
• FAQ
• Contributing

Why Monad.NET?

Modern C# has excellent features—nullable reference types, pattern matching, records. So why use Monad.NET?

The short answer: Composability. While C# handles individual cases well, chaining operations that might fail, be absent, or need validation quickly becomes verbose. Monad.NET provides a unified API for composing these operations elegantly.

Honest Comparisons with Modern C#

Optional Values: Option<T> vs Nullable Reference Types

Modern C# (NRT enabled):

User? user = FindUser(id);
if (user is not null)
{
    Profile? profile = user.GetProfile();
    if (profile is not null)
    {
        return profile.Email;  // Still might be null!
    }
}
return "default@example.com";

With Monad.NET:

return FindUser(id)
    .Bind(user => user.GetProfile())
    .Map(profile => profile.Email)
    .GetValueOr("default@example.com");

Verdict: NRTs catch null issues at compile time—use them! But Option<T> shines when you need to chain operations or transform optional values. If you're writing nested null checks, Option is cleaner.

Error Handling: Result<T, E> vs Exceptions

Modern C# with exceptions:

public Order ProcessOrder(OrderRequest request)
{
    try
    {
        var validated = ValidateOrder(request);      // throws ValidationException
        var inventory = ReserveInventory(validated); // throws InventoryException
        var payment = ChargePayment(inventory);      // throws PaymentException
        return CreateOrder(payment);
    }
    catch (ValidationException ex) { /* handle */ }
    catch (InventoryException ex) { /* handle */ }
    catch (PaymentException ex) { /* handle */ }
}

With Monad.NET:

public Result<Order, OrderError> ProcessOrder(OrderRequest request)
{
    return ValidateOrder(request)
        .Bind(ReserveInventory)
        .Bind(ChargePayment)
        .Bind(CreateOrder);
}

Verdict: Exceptions are fine for exceptional situations (network failures, disk errors). Use Result<T, E> when failure is expected (validation errors, business rule violations). The signature Result<Order, OrderError> tells callers exactly what can go wrong—no surprises.

Validation: Validation<T, E> vs FluentValidation

With FluentValidation (industry standard):

public class UserValidator : AbstractValidator<UserRequest>
{
    public UserValidator()
    {
        RuleFor(x => x.Name).NotEmpty().MinimumLength(2);
        RuleFor(x => x.Email).NotEmpty().EmailAddress();
        RuleFor(x => x.Age).InclusiveBetween(18, 120);
    }
}

// Usage
var result = await validator.ValidateAsync(request);
if (!result.IsOk)
    return BadRequest(result.Errors);

With Monad.NET:

var user = ValidateName(request.Name)
    .Apply(ValidateEmail(request.Email), (name, email) => (name, email))
    .Apply(ValidateAge(request.Age), (partial, age) => new User(partial.name, partial.email, age));

Verdict: FluentValidation is battle-tested and has more features (async rules, dependency injection, localization). Use it for complex scenarios. Validation<T, E> is lighter, has no dependencies, and works well with other Monad.NET types. Choose based on your needs.

Discriminated Unions: The Missing Feature in C#

The Problem: C# still lacks native discriminated unions (sum types) as of C# 14. Despite adding extension members, null-conditional assignment, field-backed properties, and other features—discriminated unions didn't make the cut. This remains one of the most requested language features, with the proposal actively discussed by the C# Language Design Team. F#, Rust, Swift, Kotlin, and TypeScript all have this feature. C# developers have been waiting for years.

With Monad.NET Source Generators:

[Union]
public abstract partial record GetUserResult
{
    public partial record Success(User User) : GetUserResult;
    public partial record NotFound : GetUserResult;
    public partial record ValidationError(string Message) : GetUserResult;
}

// Exhaustive matching - compiler ensures all cases handled
result.Match(
    success: s => Ok(s.User),
    notFound: _ => NotFound(),
    validationError: e => BadRequest(e.Message)
);

Design Principles

1. Explicit over implicit — No hidden nulls, no surprise exceptions
2. Composition over inheritance — Small, focused types that combine well
3. Immutability by default — All types are immutable and thread-safe
4. Minimal dependencies — Zero on .NET 6+; only Microsoft polyfills on netstandard2.x

Which Monad Should I Use?

Language Inspirations

These types come from functional programming languages. Here's the lineage:

Installation

# Core library
dotnet add package Monad.NET

# Optional: Discriminated unions via source generators
dotnet add package Monad.NET.SourceGenerators

# Optional: ASP.NET Core integration
dotnet add package Monad.NET.AspNetCore

# Optional: Entity Framework Core integration
dotnet add package Monad.NET.EntityFrameworkCore

Dependencies

Note: The netstandard2.x dependencies are Microsoft polyfill packages that provide modern .NET APIs to older frameworks. They are automatically included and have no transitive third-party dependencies.

Quick Start

Option — Handle missing values

// Method syntax (recommended)
var email = FindUser(id)
    .Select(user => user.Email)
    .Where(email => email.Contains("@"))
    .SelectMany(email => ValidateEmail(email));

// Or use Map/Filter/AndThen
var email = FindUser(id)
    .Map(user => user.Email)
    .Filter(email => email.Contains("@"))
    .Bind(email => ValidateEmail(email));

Result — Handle expected failures

public Result<Order, OrderError> ProcessOrder(OrderRequest request)
{
    return ValidateOrder(request)
        .Bind(order => CheckInventory(order))
        .Bind(order => ChargePayment(order))
        .Tap(order => _logger.LogInfo($"Order {order.Id} created"))
        .TapErr(err => _logger.LogError($"Order failed: {err}"));
}

Validation — Collect all errors

var user = ValidateName(form.Name)
    .Apply(ValidateEmail(form.Email), (name, email) => (name, email))
    .Apply(ValidateAge(form.Age), (partial, age) => new User(partial.name, partial.email, age));

// Shows ALL validation errors at once
user.Match(
    valid: u => CreateUser(u),
    invalid: errors => ShowErrors(errors)
);

Important: LINQ query syntax (from...select) on Validation short-circuits on the first error. Use Apply() or Zip() to accumulate all errors.

Discriminated Unions — Type-safe alternatives

[Union]
public abstract partial record Shape
{
    public partial record Circle(double Radius) : Shape;
    public partial record Rectangle(double Width, double Height) : Shape;
}

// Exhaustive matching
var area = shape.Match(
    circle: c => Math.PI * c.Radius * c.Radius,
    rectangle: r => r.Width * r.Height
);

Documentation

Examples

The examples/ folder contains a comprehensive example application:

• examples/Monad.NET.Examples — Interactive console app demonstrating all monad types with real-world patterns.

Performance

Monad.NET is designed for correctness and safety first, but performance is still a priority:

For typical use cases, the overhead is negligible (nanoseconds). The safety guarantees and code clarity typically outweigh any micro-optimization concerns.

Resources

Want to dive deeper into functional programming and these patterns?

Books

Online Resources

Videos & Talks

Related C# Libraries

Key Concepts

1. Railway Oriented Programming — Treat errors as alternate tracks, not exceptions
2. Making Illegal States Unrepresentable — Use types to prevent bugs at compile time
3. Parse, Don't Validate — Push validation to the boundaries, work with valid types internally
4. Composition over Inheritance — Small, focused types that combine well

When NOT to Use Monad.NET

Monad.NET is not always the right choice. Here's when to stick with native C#:

Good rule of thumb: If you're writing if (x != null) { ... } once, use nullable. If you're chaining multiple such checks, use Option.

FAQ

Can I use Monad.NET with Entity Framework?

Yes! Use Option<T> for optional relationships and Result<T, E> for operations that might fail. See EF Core Integration.

Can I use Monad.NET with ASP.NET Core?

Absolutely. See ASP.NET Core Integration.

What's the difference between Result and Validation?

• Result — Short-circuits on first error (like &&)
• Validation — Accumulates ALL errors (for showing multiple validation messages)

Is Monad.NET thread-safe?

Yes. All types are immutable readonly struct with no shared mutable state.

Contributing

Contributions are welcome. Please read CONTRIBUTING.md for guidelines.

Development requirements:

• .NET 8.0 SDK or later (for building all targets)
• Your preferred IDE (Visual Studio, Rider, VS Code)

git clone https://github.com/behrangmohseni/Monad.NET.git
cd Monad.NET
dotnet build
dotnet test

License

This project is licensed under the MIT License.

You are free to use, modify, and distribute this library in both commercial and open-source projects. See LICENSE for details.

Monad.NET — Functional programming for the pragmatic .NET developer.

Documentation · NuGet · Issues