#[inherent]

This crate provides an attribute macro to make trait methods callable without the trait in scope.

[dependencies]
inherent = "1.0"

Example

mod types {
    use inherent::inherent;

    trait Trait {
        fn f(self);
    }

    pub struct Struct;

    #[inherent]
    impl Trait for Struct {
        pub fn f(self) {}
    }
}

fn main() {
    // types::Trait is not in scope, but method can be called.
    types::Struct.f();
}

Without the inherent macro on the trait impl, this would have failed with the following error:

error[E0599]: no method named `f` found for type `types::Struct` in the current scope
  --> src/main.rs:18:19
   |
8  |     pub struct Struct;
   |     ------------------ method `f` not found for this
...
18 |     types::Struct.f();
   |                   ^
   |
   = help: items from traits can only be used if the trait is implemented and in scope
   = note: the following trait defines an item `f`, perhaps you need to implement it:
           candidate #1: `types::Trait`

The inherent macro expands to inherent methods on the Self type of the trait impl that forward to the trait methods. In the case above, the generated code would be:

impl Struct {
    pub fn f(self) {
        <Self as Trait>::f(self)
    }
}

License

^{Licensed under either of Apache License, Version 2.0 or MIT license at your option.}

_{Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.}