Rustly 10.2.0

Rustly (v10.2.0)

Rust-inspired Result<T, E>, Option<T>, Unit, and EnumValue types for C#. Replace exceptions with explicit, composable error handling. Zero-allocation value types.

All types and helpers are auto-imported when you add the package -- no using statements needed.

Installation

dotnet add package Rustly --version 10.2.0

Types

Usage

Option<T>

// Implicit conversion: T -> Some(T)
Option<int> age = 25;                        // Some(25)
Option<string> name = "Alice";               // Some("Alice")

// None via default
Option<int> empty = default;                 // None
Option<string> noName = default;             // None

// Note: Option<object> cannot be assigned null directly -- use default
Option<object> obj = default;                // None (correct)
// Option<object> obj = null;                // compile error

// Explicit cast: Option<T> -> T (equivalent to Unwrap)
int value = (int)age;                        // 25

// Safe access
Option<string> FindUser(int id) =>
    id == 1 ? Some("Admin") : None<string>();

string name = FindUser(1).UnwrapOr("Unknown");

// Chaining
var greeting = FindUser(1)
    .Map(n => $"Hello, {n}!")
    .UnwrapOr("Hello, stranger!");

// Filtering
var admin = FindUser(1).Filter(n => n == "Admin");

// Convert to Result
Result<string, string> r = FindUser(42).OkOr("User not found");

// Pattern matching (U is inferred from lambdas)
var message = FindUser(42).Match(
    n => $"Found: {n}",
    () => "Not found"
);

Result<T, E>

// Implicit conversion: T -> Ok(T)
Result<int, string> Divide(int a, int b) =>
    b == 0 ? Err<int, string>("Division by zero") : a / b;

// Explicit cast: E -> Err(E)
Result<int, string> err = (Result<int, string>)"something went wrong";

// Explicit cast: Result<T, E> -> T (equivalent to Unwrap)
int value = (int)Divide(10, 2);              // 5

// Pattern matching (U is inferred from lambdas)
string message = Divide(10, 0).Match(
    value => $"Result: {value}",
    error => $"Error: {error}"
);

// Chaining
var doubled = Divide(10, 2)
    .Map(x => x * 2)
    .UnwrapOr(0);

// Composition
var final = Divide(10, 2)
    .AndThen(x => Divide(x, 3))
    .MapErr(e => $"Pipeline failed: {e}");

// Querying
bool isPositive = Divide(10, 2).IsOkAnd(x => x > 0);
bool isBadInput = Divide(10, 0).ContainsErr("Division by zero");

Result<Unit, E> (void operations)

Result<Unit, string> SaveFile(string path)
{
    // ... operation ...
    return Unit.Value;  // implicit Unit -> Ok
}

SaveFile("/tmp/data.txt")
    .InspectErr(e => Console.WriteLine($"Save failed: {e}"));

Combining

// Zip two options
var pair = Some(1).Zip(Some("hello"));  // Some((1, "hello"))

// Flatten nested types
Option<Option<int>> nested = Some(Some(42));
Option<int> flat = nested.Flatten();  // Some(42)

// Transpose
Option<Result<int, string>> optRes = Some(Ok<int, string>(42));
Result<Option<int>, string> resOpt = optRes.Transpose();  // Ok(Some(42))

// Xor
var a = Some(1);
var b = None<int>();
var x = a.Xor(b);  // Some(1) -- exactly one is Some

EnumValue -- Rust-style Enum Variants

using Rustly.Extensions;

public enum LogLevel
{
    [EnumValue("TRC")] Trace,
    [EnumValue("DBG")] Debug,
    [EnumValue("INF")] Info,
}

var label = LogLevel.Trace.Value<string>();          // "TRC"
var opt   = LogLevel.Debug.ValueOption<string>();     // Some("DBG")
var raw   = LogLevel.Info.RawValue();                 // (object)"INF"

JSON Serialization

Option<T> and Result<T, E> work with System.Text.Json automatically (.NET 5+). No registration needed:

// Option<T> -- Some(x) serializes as x, None as null
JsonSerializer.Serialize(Some("hello"));             // "hello"
JsonSerializer.Serialize(None<string>());            // null
JsonSerializer.Deserialize<Option<int>>("42");       // Some(42)

// Result<T, E> -- Ok(x) as {"ok": x}, Err(e) as {"err": e}
JsonSerializer.Serialize(Ok<int, string>(42));       // {"ok":42}
JsonSerializer.Serialize(Err<int, string>("fail"));  // {"err":"fail"}

// Works inside other objects too
public record User(string Name, Option<string> Email);
JsonSerializer.Serialize(new User("Alice", "a@b.c"));   // {"Name":"Alice","Email":"a@b.c"}
JsonSerializer.Serialize(new User("Bob", default));      // {"Name":"Bob","Email":null}

API Reference

Result<T, E>

Option<T>

Prelude (auto-imported)

License

MIT