Trait Behavior

pub trait Behavior: Copy + 'static {
    // Required methods
    fn add<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T
       where T: Add<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>,
             T::Output: Eq + Ord + Into<T>,
             Saturating<T>: Add<Output = Saturating<T>>,
             <Saturating<T> as Add>::Output: Eq + Ord + Into<Saturating<T>>;
    fn sub<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T
       where T: Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>,
             T::Output: Eq + Ord + Into<T>,
             Saturating<T>: Sub<Output = Saturating<T>>,
             <Saturating<T> as Sub>::Output: Eq + Ord + Into<Saturating<T>>;
    fn mul<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T
       where T: Mul<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>,
             T::Output: Eq + Ord + Into<T>,
             Saturating<T>: Mul<Output = Saturating<T>>,
             <Saturating<T> as Mul>::Output: Eq + Ord + Into<Saturating<T>>;
    fn div<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T
       where T: Div<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>,
             T::Output: Eq + Ord + Into<T>,
             Saturating<T>: Div<Output = Saturating<T>>,
             <Saturating<T> as Div>::Output: Eq + Ord + Into<Saturating<T>>;
    fn rem<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T
       where T: Rem<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>,
             <T as Rem>::Output: Eq + Ord + Into<T>,
             <T as Sub>::Output: Eq + Ord + Into<T>,
             Saturating<T>: Rem<Output = Saturating<T>>,
             <Saturating<T> as Rem>::Output: Eq + Ord + Into<Saturating<T>>;
    fn bitand<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T
       where T: BitAnd<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>,
             <T as BitAnd>::Output: Eq + Ord + Into<T>,
             <T as Sub>::Output: Eq + Ord + Into<T>,
             Saturating<T>: BitAnd<Output = Saturating<T>>,
             <Saturating<T> as BitAnd>::Output: Eq + Ord + Into<Saturating<T>>;
    fn bitor<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T
       where T: BitOr<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>,
             <T as BitOr>::Output: Eq + Ord + Into<T>,
             <T as Sub>::Output: Eq + Ord + Into<T>,
             Saturating<T>: BitOr<Output = Saturating<T>>,
             <Saturating<T> as BitOr>::Output: Eq + Ord + Into<Saturating<T>>;
    fn bitxor<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T
       where T: BitXor<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>,
             <T as BitXor>::Output: Eq + Ord + Into<T>,
             <T as Sub>::Output: Eq + Ord + Into<T>,
             Saturating<T>: BitXor<Output = Saturating<T>>,
             <Saturating<T> as BitXor>::Output: Eq + Ord + Into<Saturating<T>>;
    fn neg<T>(val: T, params: OpBehaviorParams<T>) -> T
       where T: Neg<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>,
             <T as Neg>::Output: Eq + Ord + Into<T>,
             <T as Sub>::Output: Eq + Ord + Into<T>,
             Saturating<T>: Neg<Output = Saturating<T>>,
             <Saturating<T> as Neg>::Output: Eq + Ord + Into<Saturating<T>>;
    fn not<T>(val: T, params: OpBehaviorParams<T>) -> T
       where T: Not<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>,
             <T as Not>::Output: Eq + Ord + Into<T>,
             <T as Sub>::Output: Eq + Ord + Into<T>,
             Saturating<T>: Not<Output = Saturating<T>>,
             <Saturating<T> as Not>::Output: Eq + Ord + Into<Saturating<T>>;
}

Required Methods

fn add<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T

where T: Add<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>, T::Output: Eq + Ord + Into<T>, Saturating<T>: Add<Output = Saturating<T>>, <Saturating<T> as Add>::Output: Eq + Ord + Into<Saturating<T>>,

fn sub<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T

where T: Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>, T::Output: Eq + Ord + Into<T>, Saturating<T>: Sub<Output = Saturating<T>>, <Saturating<T> as Sub>::Output: Eq + Ord + Into<Saturating<T>>,

fn mul<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T

where T: Mul<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>, T::Output: Eq + Ord + Into<T>, Saturating<T>: Mul<Output = Saturating<T>>, <Saturating<T> as Mul>::Output: Eq + Ord + Into<Saturating<T>>,

fn div<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T

where T: Div<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>, T::Output: Eq + Ord + Into<T>, Saturating<T>: Div<Output = Saturating<T>>, <Saturating<T> as Div>::Output: Eq + Ord + Into<Saturating<T>>,

fn rem<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T

where T: Rem<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>, <T as Rem>::Output: Eq + Ord + Into<T>, <T as Sub>::Output: Eq + Ord + Into<T>, Saturating<T>: Rem<Output = Saturating<T>>, <Saturating<T> as Rem>::Output: Eq + Ord + Into<Saturating<T>>,

fn bitand<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T

where T: BitAnd<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>, <T as BitAnd>::Output: Eq + Ord + Into<T>, <T as Sub>::Output: Eq + Ord + Into<T>, Saturating<T>: BitAnd<Output = Saturating<T>>, <Saturating<T> as BitAnd>::Output: Eq + Ord + Into<Saturating<T>>,

fn bitor<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T

where T: BitOr<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>, <T as BitOr>::Output: Eq + Ord + Into<T>, <T as Sub>::Output: Eq + Ord + Into<T>, Saturating<T>: BitOr<Output = Saturating<T>>, <Saturating<T> as BitOr>::Output: Eq + Ord + Into<Saturating<T>>,

fn bitxor<T>(lhs: T, rhs: T, params: OpBehaviorParams<T>) -> T

where T: BitXor<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>, <T as BitXor>::Output: Eq + Ord + Into<T>, <T as Sub>::Output: Eq + Ord + Into<T>, Saturating<T>: BitXor<Output = Saturating<T>>, <Saturating<T> as BitXor>::Output: Eq + Ord + Into<Saturating<T>>,

fn neg<T>(val: T, params: OpBehaviorParams<T>) -> T

where T: Neg<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>, <T as Neg>::Output: Eq + Ord + Into<T>, <T as Sub>::Output: Eq + Ord + Into<T>, Saturating<T>: Neg<Output = Saturating<T>>, <Saturating<T> as Neg>::Output: Eq + Ord + Into<Saturating<T>>,

fn not<T>(val: T, params: OpBehaviorParams<T>) -> T

where T: Not<Output = T> + Sub<Output = T> + 'static + Copy + Eq + Ord + InherentLimits<T>, <T as Not>::Output: Eq + Ord + Into<T>, <T as Sub>::Output: Eq + Ord + Into<T>, Saturating<T>: Not<Output = Saturating<T>>, <Saturating<T> as Not>::Output: Eq + Ord + Into<Saturating<T>>,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Behavior for Panicking

impl Behavior for Saturating