CSharpEssentials.Any 6.2.0

CSharpEssentials.Any

Discriminated Unions (Sum Types) for .NET. A type-safe way to represent a value that can be one of several fixed types.

Features

• Unions of 2 to 8 types: Any<T0, T1> through Any<T0, ..., T7>.
• Implicit Conversions: Assign values directly to the union type.
• Pattern Matching: Switch and Match for exhaustive handling.
• Type Helpers: Is<T>, As<T>, TryAs<T>, Deconstruct, ToTuple.
• JSON Support: Built-in serialization.

Installation

dotnet add package CSharpEssentials.Any

Usage

Creating Unions

using CSharpEssentials.Any;

Any<string, int> ParseInput(string input)
{
    if (int.TryParse(input, out int n))
        return n; // implicit to Any<string, int>
    return input;
}

Pattern Matching

Any<string, int> result = ParseInput("123");

// Match returns AnyActionResult<TResult>: Status tells whether a handler ran, Result holds its value
AnyActionResult<string> output = result.Match(
    first: str => $"String: {str}",
    second: num => $"Number: {num}");
Console.WriteLine(output.Result);

result.Switch(
    first: str => Console.WriteLine("It's a string"),
    second: num => Console.WriteLine("It's a number"));

Type Checking

if (result.IsSecond)
{
    int val = result.GetSecond();
}

// Generic helpers
bool isInt = result.Is<int, string, int>();
int? asInt = result.As<int, string, int>();
bool found = result.TryAs<int, string, int>(out int value);

Multiple Types

Any<string, int, Exception> response = GetData(5);

response.Switch(
    first: s => Console.WriteLine($"Success: {s}"),
    second: i => Console.WriteLine($"NotFound: {i}"),
    third: e => Console.WriteLine($"Error: {e.Message}"));

Collection Extensions

Scatter a sequence of unions into typed arrays in one pass:

// Classify API responses into successes and errors
var (users, errors) = responses
    .Traverse(r => ClassifyResponse(r));  // returns Any<UserDto, ApiError>

// Or partition an existing sequence of unions
var (drafts, published) = articles
    .Select(a => GetState(a))             // returns Any<Draft, Published>
    .Partition();

Partition and Traverse are available for all arities (Any<T0,T1> through Any<T0,...,T7>), returning a tuple with one typed array per variant.