assert-impl-trait 1.0.0

Provides a macro to assert that a type implements a trait.
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
65
66
67
68

# `assert-impl-trait`

This crate provides a simple `assert_impl` macro for making compile-time
assertions that a type implements a given trait.

The macro supports generic parameters via `for<...>` syntax and trait bounds via
`where ...` syntax.

The macro is useful for crates that need tests to ensure their types implement
the correct traits, and is aspecially useful if those types contain generics.

The macro can also be used to assert that a trait is dyn-compatible.

## Examples

```rust
use assert_impl_trait::assert_impl;

// Assert that `u8` implements `Clone`.
assert_impl!(u8: Clone);

// Assert that for any type `T` that implements `Clone`, `Vec<T>` also
// implements `Clone`.
assert_impl!(
    for<T: Clone> {
        Vec<T>: Clone,
    }
);

// Assert that for any type `T` and any integer `N`:
// - If `T` implements `Clone`, `[T; N]` also implements `Clone`.
// - If `T` implements `Copy`, `[T; N]` also implements `Copy`.
// - If `T` is valid for a lifetime, `[T; N]` is also valid for it.
assert_impl!(
    for<T, const N: usize> {
        where T: Clone {
            [T; N]: Clone,
        }
        where T: Copy {
            [T; N]: Copy,
        }

        for<'a> where T: 'a {
            [T; N]: 'a,
        }
    }
);

// Assert that `Debug` is a dyn-compatible trait.
assert_impl!(dyn core::fmt::Debug:);
```

## Usage

Add this to your Cargo.toml:

```toml
[dependencies]
assert-impl-trait = "1.0.0"
```

## Dependencies

This crate depends on [`proc-macro2`](https://crates.io/crates/proc-macro2) and [`quote`](https://crates.io/crates/quote).

## License

Licensed under either Apache License Version 2.0 or MIT license at your option.