Expand description
Statically-verified struct
field names as strings.
The field!
macro evaluates to a field’s name after verifying that the field exists on the specified struct
.
The type must be in scope, and the field must be visible (accessible) at the point of invocation of the macro.
§Usage
Invoke the macro as field!(field @ Struct)
:
use field::*;
struct User {
name: String,
age: u32,
}
let name = field!(name @ User);
assert_eq!(name, "name");
let age = field!(age @ User);
assert_eq!(age, "age");
A field that is not on the specified struct
or a type that is not in scope will cause a compilation error:
// This fails because there is no field named "address" on "User"
let address = field!(address @ User);
// This fails because their is no struct named "NonExistent"
let foo = field!(whatever @ NonExistent);
§Generics
field!
also works with generic types, as long as concrete type parameters are provided:
use field::*;
struct Pair<T> {
first: T,
second: T,
}
let first = field!(first @ Pair<()>);
assert_eq!(first, "first");
// Any type can be used for the type parameter(s)
let second = field!(second @ Pair<i32>);
assert_eq!(second, "second");
§Paths
That’s right, field!
also works with path syntax:
use field::*;
mod wrap {
pub struct Wrap<T> {
pub inner: T, // Must be pub so that it is visible at the point of invocation
}
}
let inner = field!(inner @ wrap::Wrap<()>);
assert_eq!(inner, "inner");
§Visibility
The specified field and struct
must be visible (aka accessible) at the point of invocation of the macro:
use field::*;
mod int {
pub struct Int {
pub int: i32,
}
}
let int = field!(int @ int::Int);
assert_eq!(int, "int");
A type or field that is not visible will result in a compilation error:
use field::*;
mod example {
struct Secret {
pub secret: String,
}
pub struct Empty {
empty: ()
}
}
// This fails because the "Secret" struct is not visible to the outer module
let secret = field!(secret @ example::Secret);
// This fails because the "empty" field is not visible to the outer module
let empty = field!(empty @ example::Empty);
§Dependencies
This crate is completely dependency-free.
#[no_std]
is also supported by default.
Macros§
- field
- Checks for the presence of a field on a
struct
at compile-time and returns the field’s name as a&'static str
.