#field-name #struct-fields #run-time #proc-macro #derive #variant-name

macro field_names

A proc-macro for exposing a struct's field names at runtime

3 unstable releases

0.2.0 Jan 4, 2022
0.1.1 Jan 11, 2021
0.1.0 Jan 8, 2021

#2107 in Procedural macros

Download history 860/week @ 2023-11-20 826/week @ 2023-11-27 845/week @ 2023-12-04 744/week @ 2023-12-11 849/week @ 2023-12-18 432/week @ 2023-12-25 1814/week @ 2024-01-01 2235/week @ 2024-01-08 9113/week @ 2024-01-15 10246/week @ 2024-01-22 11159/week @ 2024-01-29 9389/week @ 2024-02-05 10519/week @ 2024-02-12 9403/week @ 2024-02-19 9179/week @ 2024-02-26 6019/week @ 2024-03-04

35,717 downloads per month
Used in 2 crates

MIT license

11KB
202 lines

field_names

Build Status Latest Version

field_names is a Rust crate to expose a field or variant names from source code as strings at runtime.

Example

Consider a simple struct such as this one.

#[derive(FieldNames)]
struct Example {
    hello: String,
    world: String,
    #[field_names(skip)]
    ignore_me: bool,
}

field_names will emit the following:

#[automatically_derived]
impl Example {
    const FIELDS: [&'static str; 2] = [
        "hello",
        "world",
    ];
}

Enums are the same:

#[derive(VariantNames)]
enum Example {
    Hello(String),
    #[variant_names(skip)]
    Secret(String),
    World,
}

field_names will emit the following:

#[automatically_derived]
impl Example {
    const VARIANTS: [&'static str; 2] = [
        "Hello",
        "World",
    ];
}

Uses

This crate was originally created for a case where a set of rules were being read at runtime which referenced fields of structs elsewhere in the code base. The referenced struct exposed a method which had a match statement to go from strings to its fields, but there was not a way to ensure the arms of that match statement stayed in sync with the struct definition. With this crate, a unit test could be created to ensure that every field on the struct - except those deliberately omitted - was handled by the method.

This crate can also be used to enforce relationships among structs and enums at unit-test time that cannot be expressed at compile-time. See tests/keep_in_sync for an example and explanation of that scenario.

FAQs

Why aren't FieldNames and VariantNames traits?

Using field_names is an implementation convenience; it shouldn't force you to change your crate's public API.

How do I make FIELDS or VARIANTS public?

You can add your own inherent method, e.g. fields() -> &[&'static str], or define a trait that matches your use-case and reference FIELDS in the trait implementation.

Can I get field names for an enum variant?

This currently isn't supported, using newtype variants and separate structs per variant is currently the recommended approach. You can use the from_variants crate to auto-generate conversions from those structs into the enum.

Dependencies

~1.5MB
~40K SLoC