# look_inside

This crate provides the `LookInside` custom derive macro that allows
introspecting the fields of structs and enums at compile time.

It also provides modules for working with different types:

- `enums` - Provides functionality for enum types.
- `fields` - Provides functionality for struct fields.
- `structs` - Provides functionality for struct types.
- `unions` - Provides functionality for union types.

The `LookInside` macro generates an implementation of the `LookInside`
trait which exposes the fields and variants in a structured way at
compile time. This allows iterating and matching on fields and variants
in macros.

Key items exported:

- `LookInside` - The custom derive macro.
- `Ident`, `Type`, etc. - Re-exports of useful types from Syn.
This crate provides a convenient way to introspect struct and enum fields at
compile time using the `LookInside` custom derive macro.

To use it to view the structure of your structs, enums, and unions, add
`#[derive(LookInside)]` to your struct or enum definition. This will
generate an implementation of the `LookInside` trait for that type, which exposes
its fields and variants in a structured way in a panic message.

For example:

``` Rust
#[derive(LookInside)]
struct MyStruct {
    field1: u32,
    field2: String,
}
```

Alternatively, this crate also contains the code to take a DeriveInput from the
syn crate and return structured representations of your types for use in your code.

Here's a simple example of how to print the fields of a struct:

``` Rust
let my_struct = MyStruct { field1: 42, field2: "foo".to_string() };

// Access fields:
let field1 = my_struct.look_inside().fields().field1;

// Iterate fields:
for field in my_struct.look_inside().fields() {
    println!("{}", field.ident);
}
```

This provides a convenient way to introspect and process structs, unions,
and enums generically in macros and procedural macros.