# field_names
[](https://github.com/TedDriggs/field_names/actions)
[](https://crates.io/crates/field_names)
`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.
```rust
#[derive(FieldNames)]
struct Example {
hello: String,
world: String,
#[field_names(skip)]
ignore_me: bool,
}
```
`field_names` will emit the following:
```rust
#[automatically_derived]
impl Example {
const FIELDS: [&'static str; 2] = [
"hello",
"world",
];
}
```
Enums are the same:
```rust
#[derive(VariantNames)]
enum Example {
Hello(String),
#[variant_names(skip)]
Secret(String),
World,
}
```
`field_names` will emit the following:
```rust
#[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`](https://crates.io/crates/from_variants) crate to auto-generate conversions from those structs into the enum.