wraps 1.0.0

create marker types that wrap other, inner, types - with trait impls matching PhantomData
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# wraps
Simple Rust macro for creating marker types that also encode some "inner type information" as a type argument - essentially like [`PhantomData`][pd] - and that implement traits 
such as [`Default`][default] and [`Debug`][debug] for _all_ type arguments rather than just type arguments that themselves implement the relevant traits (as would occur if you used the `#[derive]` annotation).

Designed for use in creating wrapper types for use inside marker types in a more advanced version of the pattern observed in [`bevy_ecs`][bevy-impl], where wrapper types are used to disambiguate relevant traits or properties of some subcomponent of the marker type.

You could also create wrapper types fairly simply without any macro but it's slightly more cumbersome - and if you want the structure to be exactly like [`PhantomData`][pd] - for example, having _universal_ implementations of traits like [`Debug`][debug], [`Copy`][copy] and [`Clone`][clone] that don't require the type argument to implement those traits - then it takes a lot of boilerplate code that this crate will create for you automatically. 

## Example Usage
```rust
trait PropertyA {
    fn a(&self);
}
trait PropertyB {
    fn b(&self);
}

mod marker {
    wraps::marker! {
        /// Interpret type as implementing [`super::PropertyA`], inner field 
        /// is public.
        pub(crate) struct PropertyA;
        /// Interpret type as implementing [`super::PropertyB`], inner field 
        /// is not public.
        pub struct PropertyB<MyTypeName>;
        /// Interpret type as mysterious property C with default type being `()`, 
        /// inner field is public.
        pub struct PropertyC<pub Weird = ()>;
    }
}

pub trait AnswerMyQuestion<M> {
    fn emit_properties(&self);
}

impl <T: PropertyA, Q: PropertyB> 
    AnswerMyQuestion<(marker::PropertyA<T>, marker::PropertyB<Q>)> for (T, Q) 
{
    fn emit_properties(&self) {
        self.0.a(); 
        self.1.b();
    }    
} 


impl <T: PropertyB, Q: PropertyA> 
    AnswerMyQuestion<(marker::PropertyB<T>, marker::PropertyA<Q>)> for (T, Q) 
{
    fn emit_properties(&self) {
        self.0.b(); 
        self.1.a();
    }    
} 
```

[pd]: https://doc.rust-lang.org/nightly/core/marker/struct.PhantomData.html
[copy]: https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html
[clone]:https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html
[default]:https://doc.rust-lang.org/nightly/core/default/trait.Default.html
[debug]:https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html
[bevy-impl]: https://docs.rs/bevy_ecs/0.15.3/src/bevy_ecs/system/function_system.rs.html#978

## License
This crate is licensed under MPL-2.0.