Variant Methods

Union generates three kinds of methods for each variant. Method names are derived from the variant name converted to snake_case.

is_* — Boolean Predicates

Generated for all variant kinds (unit, tuple, named):

use moxy::Union;

#[derive(Union)]
enum Status {
    Active,
    Paused(String),
    Error { code: i32, message: String },
}

let s = Status::Active;
assert!(s.is_active());
assert!(!s.is_paused());
assert!(!s.is_error());

as_* — Borrow Variant Data

Generated for tuple and named variants. Returns Option<&T> for single-field variants, Option<(&T1, &T2, ...)> for multi-field.

use moxy::Union;

#[derive(Union)]
enum Value {
    Text(String),
    Pair(i32, String),
    Record { id: u64, name: String },
}

let v = Value::Text("hello".into());
assert_eq!(v.as_text(), Some(&"hello".to_string()));

let v = Value::Pair(1, "one".into());
assert_eq!(v.as_pair(), Some((&1, &"one".to_string())));

let v = Value::Record { id: 42, name: "alice".into() };
assert_eq!(v.as_record(), Some((&42u64, &"alice".to_string())));

Returns None when the variant doesn’t match:

let v = Value::Text("hello".into());
assert_eq!(v.as_pair(), None);

to_* — Clone Variant Data

Same signatures as as_* but clones the data. Requires Clone on the inner types.

use moxy::Union;

#[derive(Union)]
enum Token {
    Ident(String),
    Literal(i32),
}

let t = Token::Ident("foo".into());
assert_eq!(t.to_ident(), Some("foo".to_string()));
assert_eq!(t.to_literal(), None);

Aliasing

Use #[moxy(variant(alias = "name"))] to control the generated method names:

use moxy::Union;

#[derive(Union)]
enum Expr {
    #[moxy(variant(alias = "num"))]
    NumberLiteral(f64),
}

let e = Expr::NumberLiteral(3.14);
assert!(e.is_num());
assert_eq!(e.as_num(), Some(&3.14));

Skipping Variants

Use #[moxy(variant(skip))] to exclude a variant from method generation:

use moxy::Union;

#[derive(Union)]
enum Event {
    Click(i32, i32),
    #[moxy(variant(skip))]
    Internal(Vec<u8>),
}

No is_internal, as_internal, or to_internal methods are generated.