# schema -- A Generic Schema Derivation for Rust
This crate is pretty simple in concept: it exposes a trait, `Schema`, and a
derive macro for that trait. The trait has a single method, `Schema::schema()`,
that produces a struct of type `syn::DeriveInput` (which this crate re-exports)
that represents the schema for the type on which `schema()` is invoked.
```rust
#[derive(Schema)]
struct MyType {
a: u32,
}
```
If we `println!("{:#?}", MyType::schema())` we get:
```
DeriveInput {
attrs: [],
vis: Inherited,
ident: Ident(
MyType,
),
generics: Generics {
lt_token: None,
params: [],
gt_token: None,
where_clause: None,
},
data: Struct(
DataStruct {
struct_token: Struct,
fields: Named(
FieldsNamed {
brace_token: Brace,
named: [
Field {
attrs: [],
vis: Inherited,
ident: Some(
Ident(
a,
),
),
colon_token: Some(
Colon,
),
ty: Path(
TypePath {
qself: None,
path: Path {
leading_colon: None,
segments: [
PathSegment {
ident: Ident(
u32,
),
arguments: None,
},
],
},
},
),
},
],
},
),
semi_token: None,
},
),
}
```
---
## FAQ
### 1. Ok, so what is this for?
Right. I'm not 100% sure. It seems potentially useful for developing or testing
proc macros. It also seems useful in situations where one might make a proc
macro but can't be bothered to deal with defining a trait on a bunch of base
types.
### 2. Why did you make this?
Fair. I was doing some work with OpenAPI and JSON Schema and found it
surprising I couldn't find a generic schema crate, something that provided a
subset of Java reflection, say.
I found someone squatting on the name `schema` on crates.io. "Aha!" I thought,
"I'll teach that evil squatter a lesson!" So I mailed him and he responded in
the worst possible way: "okay, I sent an invite." Suddenly I was the evil squatter.
Months passed as they do.
I had the odd idea of a derive macro that parsed an item and then teleported
that structure from proc macro context into program context. I usually want an
actual use case to drive a project, but this seemed like a *neat* trick. It led
to weird code like this (i.e. not exactly this):
```rust
impl Teleporter for TokenStream {
fn teleport(&self) -> TokenStream {
quote! {
quote! {
#self
}
}
}
//...
}
```
I'm not really sure what this crate is or if it's useful, but it was an
interesting experiment. If you find it useful, have a different idea for how it
should work, or just think `schema` should be a totally different crate: let me
know.
### 3. I'm using it and...
Please tell me about what you're doing with it... you were saying...
### 4. ... I'm seeing an error on some type
Please file an issue. PRs welcome too.