#string #enums #macro-derive #macro

macro enum2str

enum2str is a rust derive macro that creates a Display impl for enums. This is useful for strongly typing composable sets of strings.

11 releases

0.1.10 Dec 8, 2023
0.1.9 Aug 8, 2023
0.1.7 Jul 13, 2023
0.1.6 Mar 25, 2023

#1743 in Procedural macros

Download history 591/week @ 2023-11-26 560/week @ 2023-12-03 689/week @ 2023-12-10 498/week @ 2023-12-17 44/week @ 2023-12-24 225/week @ 2023-12-31 265/week @ 2024-01-07 280/week @ 2024-01-14 356/week @ 2024-01-21 247/week @ 2024-01-28 314/week @ 2024-02-04 342/week @ 2024-02-11 287/week @ 2024-02-18 393/week @ 2024-02-25 342/week @ 2024-03-03 23/week @ 2024-03-10

1,060 downloads per month
Used in chdb

MIT license

17KB
235 lines

enum2str

github crates.io docs.rs

enum2str is a rust derive macro that creates a Display impl for enums. This is useful for strongly typing composable sets of strings.

Usage

Add this to your Cargo.toml:

enum2str = "0.1.10"

Example:

use enum2str::EnumStr;

#[derive(EnumStr)]
enum Object {
    Generic(String),

    #[enum2str("Color: {}. Shape: {}.")]
    Complex(Color, Shape),

    // Variant fields can be ignored
    #[enum2str("Material")]
    Material(Color),
}

#[derive(EnumStr)]
enum Color {
    Green,

    #[enum2str("Burgundy")]
    Red,

    Blue {
        _hue: u8,
    },

    #[enum2str("Custom Color")]
    Custom {
        _red: u8,
        _green: u8,
        _blue: u8,
    },

    #[enum2str("Unique - {label}_{id}")]
    Unique {
        id: u8,
        label: String,
    },
}

#[derive(EnumStr)]
enum Shape {
    #[enum2str("Circle with radius: {}")]
    Circle(u8),
}

#[test]
fn color_variant_names() {
    assert_eq!(
        Color::variant_names(),
        vec![
            "Green".to_string(),
            "Red".to_string(),
            "Blue".to_string(),
            "Custom".to_string(),
            "Unique".to_string(),
        ]
    );
}

#[test]
fn unit_to_string() {
    assert_eq!(Color::Green.to_string(), "Green");
}

#[test]
fn unit_override_string() {
    assert_eq!(Color::Red.to_string(), "Burgundy");
}

#[test]
fn unnamed_to_string() {
    assert_eq!(Object::Generic("Hello!".to_string()).to_string(), "Hello!");
}

#[test]
fn nested_to_string() {
    assert_eq!(
        Object::Complex(Color::Green, Shape::Circle(2)).to_string(),
        "Color: Green. Shape: Circle with radius: 2."
    );
}

#[test]
fn unit_template() {
    assert_eq!(Color::Green.template(), "Green");
}

#[test]
fn unit_override_template() {
    assert_eq!(Color::Red.template(), "Burgundy");
}

#[test]
fn unnamed_template() {
    assert_eq!(Shape::Circle(2).template(), "Circle with radius: {}");
}

#[test]
fn nested_template() {
    assert_eq!(
        Object::Complex(Color::Green, Shape::Circle(2)).template(),
        "Color: {}. Shape: {}."
    );
}

#[test]
fn unit_args() {
    assert_eq!(Color::Green.arguments().len(), 0);
}

#[test]
fn unnamed_args() {
    assert_eq!(
        Object::Generic("Hello!".to_string()).arguments(),
        vec!["Hello!".to_string()]
    );
}

#[test]
fn complex_args() {
    assert_eq!(
        Object::Complex(Color::Green, Shape::Circle(2)).arguments(),
        vec!["Green", "Circle with radius: 2"],
    );
}

#[test]
fn plain_to_string() {
    assert_eq!(Color::Blue { _hue: 3 }.to_string(), "Blue");
}

#[test]
fn unique_to_string() {
    assert_eq!(
        Color::Unique {
            label: "unique_color".to_string(),
            id: 3
        }
        .to_string(),
        "Unique - unique_color_3",
    );
}

#[test]
fn custom_args() {
    assert_eq!(
        Color::Unique {
            label: "unique_color".to_string(),
            id: 3
        }
        .arguments()
        .len(),
        2
    );
}

Dependencies

~1.5MB
~34K SLoC