enum-typer is a procedural macro. It will run at compile time and transform your program's source code.

Adding `enum-typer` macro(s) as a dependency

Run this command in a terminal, in your project's directory:

cargo add enum-typer

To add it manually, edit your project's Cargo.toml file and add to the [dependencies] section:

enum-typer = "0.1.1"

You may need to import the macro(s) with use enum_typer::*.

Read the enum_typer documentation.

Back to the crate overview.

Readme

enum-typer

Type-indexed enums, pattern matching and GADTs for Rust

A procedural macro library that brings Generalized Algebraic Data Types (GADTs) to Rust through a powerful type_enum! macro. Define enums where each variant can refine the overall type, enabling compile-time type safety for complex data structures like type-safe expression trees, length-indexed vectors, and state machines.

Features

🎯 Type Indexing - Each variant can specify different type parameters, like GADTs in Haskell/OCaml
🔒 Phantom Types - Track compile-time state (empty/non-empty lists, type-level naturals)
📦 Trait Objects - Automatic trait generation with Box<dyn Trait> support for existential types
🔄 Pattern Matching - Runtime type-based matching with match_t! macro
🎨 Methods - Define methods directly in the enum with type-indexed return types
🧬 Variant Generics - Each variant can have its own generic parameters with trait bounds
⚡ Smart Inference - Automatic type parameter filtering and PhantomData injection

Quick Start

Add to your Cargo.toml:

[dependencies]
enum-typer = "0.1.0"

Basic Example

use enum_typer::type_enum;

type_enum! {
    enum Either<A, B> {
        Left(A),
        Right(B),
    }
}

// Use as trait objects
let value: Box<dyn Either<i32, String>> = Box::new(Left(42));

Type Indexing (GADTs)

Define enums where variants constrain the overall type parameter:

type_enum! {
    enum Either<A, B, Tag> {
        Left(A) : Either<A, B, LeftTag>,
        Right(B) : Either<A, B, RightTag>,
    }
}

struct LeftTag;
struct RightTag;

type EitherRef<A, B, Tag> = Box<dyn Either<A, B, Tag>>;

// Type system proves this value is Left
let value: EitherRef<i32, String, LeftTag> = Box::new(Left(42));

// Can't compile - type mismatch!
// let wrong: EitherRef<i32, String, LeftTag> = Box::new(Right("hello".to_string()));

Each variant acts as a type-level proof of which case you have. The Tag parameter is refined by the variant constructor.

Phantom Types for Compile-Time Safety

Track state at the type level to prevent runtime errors:

struct Empty;
struct NonEmpty;

type_enum! {
    enum SafeList<T, E> {
        Nil : SafeList<T, Empty>,
        Cons(T, SafeListRef<T, E>) : SafeList<T, NonEmpty>,
    }
}

type SafeListRef<T, E> = Box<dyn SafeList<T, E>>;

// This function only accepts non-empty lists
fn safe_head<T: 'static>(list: SafeListRef<T, NonEmpty>) -> T {
    match_t!(move list {
        Cons<T, NonEmpty>(head, _tail) => head,
    })
}

let list: SafeListRef<i32, _> = Box::new(
    Cons(1, Box::new(Cons(2, Box::new(Nil))))
);

let head = safe_head(list); // ✓ Compiles
// safe_head(Box::new(Nil)); // ✗ Compile error!

Pattern Matching with `match_t!`

Runtime pattern matching on trait objects:

type_enum! {
    enum Sum<A, B> {
        Inl(A),
        Inr(B),
    }
}

type SumRef<A, B> = Box<dyn Sum<A, B>>;

fn fold_sum<A, B, R>(sum: SumRef<A, B>, f_inl: fn(A) -> R, f_inr: fn(B) -> R) -> R
where
    A: 'static,
    B: 'static,
{
    match_t!(move sum {
        Inl<A>(a) => f_inl(a),
        Inr<B>(b) => f_inr(b),
    })
}

let val = Box::new(Inl(42));
let result = fold_sum(val, |a| a * 2, |b| if b { 1 } else { 0 });
assert_eq!(result, 84);

Methods and Existential Returns

Define methods that return type-indexed results. The return type T is existentially quantified - it depends on which variant you have:

type_enum! {
    enum Arith<T> {
        Num(i32) : Arith<i32>,
        Bool(bool) : Arith<bool>,
        Add(ArithRef<i32>, ArithRef<i32>) : Arith<i32>,
        Or(ArithRef<bool>, ArithRef<bool>) : Arith<bool>,
    }
    
    fn eval(&self) -> T {
        Num(i) => *i,
        Bool(b) => *b,
        Add(lhs, rhs) => lhs.eval() + rhs.eval(),
        Or(lhs, rhs) => lhs.eval() || rhs.eval(),
    }
}

type ArithRef<T> = Box<dyn Arith<T>>;

let expr: ArithRef<i32> = Box::new(
    Add(Box::new(Num(10)), Box::new(Num(5)))
);
assert_eq!(expr.eval(), 15);  // Returns i32

let bool_expr: ArithRef<bool> = Box::new(
    Or(Box::new(Bool(true)), Box::new(Bool(false)))
);
assert_eq!(bool_expr.eval(), true);  // Returns bool

The type system ensures you can't mix incompatible types - Add only accepts Arith<i32>, not Arith<bool>. The return type of eval() changes based on the type index T.

How It Works

The type_enum! macro transforms your enum definition into:

A trait with the enum's name containing any defined methods
Separate structs for each variant
Trait implementations with smart generic filtering to avoid unconstrained type parameters
Automatic PhantomData injection for phantom type parameters

Example Transformation

type_enum! {
    enum SafeList<T, E> {
        Nil : SafeList<T, Empty>,
        Cons(T, Box<dyn SafeList<T, E>>) : SafeList<T, NonEmpty>,
    }
}

Expands approximately to:

trait SafeList<T, E>: std::any::Any {}

struct Nil;
impl<T: 'static> SafeList<T, Empty> for Nil {}

struct Cons<T, E>(T, Box<dyn SafeList<T, E>>);
impl<T: 'static, E: 'static> SafeList<T, NonEmpty> for Cons<T, E> {}

Notice how Nil only has impl<T>, not impl<T, E> - the macro automatically filters unused type parameters.

Advanced Features

Variant-Level Generics

Variants can have their own generic parameters, independent of the enum's generics:

type_enum! {
    enum Container {
        Simple<T>(T) : Container,
        Nested<U: Container>(Box<U>) : Container,
    }
}

// Each variant is a struct with its own generics:
// struct Simple<T: 'static>(T);
// struct Nested<U: Container + 'static>(Box<U>);

let value: Box<dyn Container> = Box::new(Simple(42));
let nested: Box<dyn Container> = Box::new(Nested(value));

This enables:

Self-referential types: Variants can reference the enum trait itself with different type parameters
Per-variant constraints: Each variant can have its own trait bounds (e.g., U: Container)
Flexible composition: Build complex recursive structures without cluttering the main enum signature

type_enum! {
    enum Expression {
        Value<T>(T) : Expression,
        Lambda<F: Fn(i32) -> i32>(F) : Expression,
    }
}

let val = Box::new(Value(42));
let func = Box::new(Lambda(|x| x * 2));

Trait Bounds Preservation

Type parameter bounds are automatically preserved:

trait Nat {
    type Pred: Nat;
}

type_enum! {
    enum SafeVector<T, N: Nat> {
        VNil : SafeVector<T, Zero>,
        VCons(T, SafeVectorRef<T, N::Pred>) : SafeVector<T, Succ<N>>,
    }
}

// Generated impl preserves N: Nat bound
// impl<T: 'static, N: Nat + 'static> SafeVector<T, Succ<N>> for VCons<T, N> { ... }

Limitations

Inference limits: Associated types like N::Pred may require explicit type annotations
'static bound: All type parameters require 'static for trait object compatibility
No exhaustiveness: match_t! panics on unmatched patterns (no compile-time exhaustiveness checking)

Examples

See the tests/examples.rs file for more examples including:

Type-safe arithmetic expression trees
Empty/non-empty lists with compile-time guarantees
Length-indexed vectors with type-level naturals
Sum types with generic folding
Variants with their own generic parameters and trait bounds

License

MIT OR Apache-2.0

Adding enum-typer macro(s) as a dependency

Adding `enum-typer` macro(s) as a dependency