Enum `ImplementsTrait`

pub enum ImplementsTrait

Whether it is possible or not to automatically derive trait for an item.

        No
         ^
         |
     Manually
         ^
         |
        Yes

Initially we assume that we can derive trait for all types and then update our understanding as we learn more about each type.

Variants

Yes

Yes, we can derive automatically.

Manually

The only thing that stops us from automatically deriving is that array with more than maximum number of elements is used.

This means we probably can "manually" implement such trait.

No

No, we cannot.

Trait Implementations

`impl BitOr for CanDerive`

type Output = CanDerive;
fn bitor(self, rhs: Self) -> Self::Output

`impl BitOrAssign for CanDerive`

fn bitor_assign(&mut self, rhs: Self)

`impl Clone for CanDerive`

fn clone(&self) -> CanDerive

`impl Copy for CanDerive`

`impl Debug for CanDerive`

fn fmt(&self, f: &mut Formatter<'_>) -> Result

`impl Default for CanDerive`

fn default() -> CanDerive

`impl Eq for CanDerive`

`impl Ord for CanDerive`

fn cmp(&self, other: &CanDerive) -> Ordering

`impl PartialEq for CanDerive`

fn eq(&self, other: &CanDerive) -> bool

`impl PartialOrd for CanDerive`

fn partial_cmp(&self, other: &CanDerive) -> Option<Ordering>

`impl StructuralPartialEq for CanDerive`

Auto Trait Implementations

`impl Freeze for CanDerive`

`impl RefUnwindSafe for CanDerive`

`impl Send for CanDerive`

`impl Sync for CanDerive`

`impl Unpin for CanDerive`

`impl UnsafeUnpin for CanDerive`

`impl UnwindSafe for CanDerive`

Blanket Implementations

`impl<T> Any for CanDerive where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for CanDerive where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for CanDerive where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for CanDerive where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for CanDerive`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> IntoEither for CanDerive`

`impl<T> ToOwned for CanDerive where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T, U> Into for CanDerive where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for CanDerive where U: Into<T>,`

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

`impl<T, U> TryInto for CanDerive where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>