# trait_guard
`trait_guard` is a macro used to protect a trait implementation from usage with a custom message, note, and label.
It abuses the `on_unimplemented` attribute to provide a custom error message when the trait is not implemented. It requires
the `negative_impls` and `trivial_bounds` nightly features to be enabled.
You can use any trait (even if it's an STD trait or from another crate)!
## Installation
To use `trait_guard`, run the following command in your terminal:
```bash
cargo add trait_guard
```
## Example usage:
```rust
trait_guard!(
MyType, // the type that will be guarded
MyTrait, // the trait that is being guarded
trait_guard = MyGuardTrait, // optional: custom name for the guard trait, shown in the diagnostic message
guard_struct = MyGuardStruct, // optional: custom name for the guard struct, shown in the diagnostic message
{
// this is the body of the trait implementation
fn my_method(&self) {
// implementation
}
},
message = "MyType does not implement MyTrait",
// note = "This is a custom note",
// label = "MyType needs to implement MyTrait"
);
```
The example above will refuse to compile if the `MyTrait` implementation of `MyType` is used anywhere in the user's code.
If you want to guard multiple traits/types, you can change the name of `trait_guard` and `guard_struct` to avoid conflicts.
## Example for [`std::fmt::Display`]
```rust
use trait_guard::trait_guard;
#[derive(Debug)]
struct A;
trait_guard!(
A, // the type that will be guarded
std::fmt::Display, // the trait that is being guarded
{
// this is the body of the trait implementation
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
unreachable!("It will never be called because A does not implement Display");
}
},
message = "A does not implement std::fmt::Display",
);
```