bijective reflection

[NyxCode]

I believe that a crucial missing feature of this library is the ability to stay within the category of types while doing reflection.
With facet as it is, I am forced to work with Shape, which only describes a type, with no good way to get back to the original type.

I feel like this creates a big rift between the actual types of the type system and the description of types Shape provides ¹.

As a start, I'd love to see some way from a Shape back to the actual type T.
For example, i'd love to be able to write the following:

// print "field: N bytes" for every field of struct T
fn size_of_fields<T>() {
    for field in "all fields of struct T" {
        type T = "type-system type of the field";
        println!("{}: {} bytes", field.name, size_of::<T>());
    }
}

(I'd be happy to also share some real use-cases other than this contrived example)

When I have implemented this "get all fields of a struct" operation in the past, I ended up with something similar to the following (playground):

fn size_of_fields<T: Facet>() {
    struct Visitor;
    impl FieldVisitor for Visitor {
        fn visit<T>(&self, name: &str) {
            println!("{name}: {} bytes", size_of::<T>());
        }
    }
    T::for_each_field(&Visitor);
}

That's certainly not very ergonomic, but it works.
An other approach I explored was to church-encode an actual list of types in rust, and treat that like any other type:

trait Facet {
    fn fields() -> impl TypeList;
}

trait TypeList: Copy + Clone {
    fn contains::<T>(self) -> bool;
    fn push::<T>(self) -> impl TypeList;
    fn for_each(v: &TypeVisitor);
    // ...
}

impl TypeList for () { .. }
impl<H, T: TypeList> TypeList for (PhantomData<H>,  T) { .. }

The final issue, however, is that just getting back the type T is not particularly useful, since the visitor in the above snippets can only call functions without trait bounds.
I always solved this by introducing the trait bound I needed for my use-case, but that won't work in a general-purpose library.
I suppose some way to downcast from a concrete "T" to a "impl SomeTrait" would solve this problem - or maybe GATs could help? Not sure.

Footnotes

1. Slightly off-topic, but that's an issue I see with the serialization stuff in facet - it kind of bypasses the type system. Types no longer fully control how they are serialized, but facet does. ↩

[NyxCode]

I started to play with this idea a bit more, implementing a first prototype here.
It does need nightly at the moment, but only for #![feature(freeze)].
While doing that, I found out about @soasis's previous efforts in this space, and my prototype goes in a similar direction.

Besides the derive macro & primitives, i've implemented serde's #[derive(Serialize)] and #[derive(Deserialize)] using them:

#[derive(Introspect)]
struct User {
  name: String,
  email: String,
}

let user = /* .. */;
let json: String = serde_json::to_string(&Reflect(&user)).unwrap();
let user: User = serde_json::from_str::<Reflect<_>>(&json).0;