#proc-macro #struct-fields #array #accessing #procedural #u32

macro named-array

A procedural macro for accessing struct fields as an array

2 releases

0.1.1 May 25, 2024
0.1.0 May 25, 2024

#590 in Procedural macros

MIT/Apache

10KB
142 lines

This crate provides the named_array derive macro, which allows you to access fields of a struct as if they were elements of an array. This provides an impl's of Index and IndexMut, which translates from a usize index to the fields, in the order in which they appear.

The type of all the fields must be the same, and written identically. For example, if one field is Option<()>, and another is core::option::Option<()>, the code will be rejected. This is because type information does not exist at the time of macro expansion, so there is no way to confirm that the two refer to the same type.

Indexing will panic if the index is out of bounds.

Example

#[derive(named_array)]
struct Example {
    a: u32,
    b: u32,
    c: u32,
}

let example = Example { a: 1, b: 2, c: 3 };
assert_eq!(example[0], example.a);
assert_eq!(example[1], example.b);
assert_eq!(example[2], example.c);

Tuple structs

This can be used with tuple structs as well. However, you may be better off using struct Foo([u32; 3]) instead of struct Foo(u32, u32, u32).

#[derive(named_array)]
struct Example(u32, u32, u32);
let example = Example(1, 2, 3);
assert_eq!(example[0], example.0);
assert_eq!(example[1], example.1);
assert_eq!(example[2], example.2);

Dependencies

~245–690KB
~16K SLoC