Enum `CanDerive`

enum CanDerive

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.

Implementations

`impl BitOr for CanDerive`

fn bitor(self: Self, rhs: Self) -> <Self as >::Output

`impl BitOrAssign for CanDerive`

fn bitor_assign(self: &mut Self, rhs: Self)

`impl Clone for CanDerive`

fn clone(self: &Self) -> CanDerive

`impl Copy for CanDerive`

`impl Debug for CanDerive`

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

`impl Default for CanDerive`

fn default() -> CanDerive

`impl Eq for CanDerive`

`impl Freeze for CanDerive`

`impl Ord for CanDerive`

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

`impl PartialEq for CanDerive`

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

`impl PartialOrd for CanDerive`

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

`impl RefUnwindSafe for CanDerive`

`impl Send for CanDerive`

`impl StructuralPartialEq for CanDerive`

`impl Sync for CanDerive`

`impl Unpin for CanDerive`

`impl UnwindSafe for CanDerive`

`impl<T> Any for CanDerive`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for CanDerive`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for CanDerive`

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

`impl<T> CloneToUninit for CanDerive`

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

`impl<T> From for CanDerive`

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

`impl<T> ToOwned for CanDerive`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for CanDerive`

fn into(self: 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`

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

`impl<T, U> TryInto for CanDerive`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>