Trait Ternary 

pub unsafe trait Ternary<T>: Results<T, 3> + Sync {
    // Required methods
    fn one(&self, x: T, y: T, z: T) -> Self::Out;
    fn judged(&self, x: T, y: T, z: T) -> (Self::Out, bool);
    fn slice(
        &self,
        args: [Arg<'_, T>; 3],
        n: usize,
        out: &mut [MaybeUninit<Self::Out>],
    ) -> bool;

    // Provided methods
    fn checked(&self, x: T, y: T, z: T) -> Option<Self::Out> { ... }
    fn many(
        &self,
        x: Arg<'_, T>,
        y: Arg<'_, T>,
        z: Arg<'_, T>,
        n: usize,
        out: &mut Vec<Self::Out>,
    ) -> bool
       where T: Copy + Sync { ... }
    fn many_into(
        &self,
        x: Arg<'_, T>,
        y: Arg<'_, T>,
        z: Arg<'_, T>,
        n: usize,
        out: &mut Slots<'_, Self::Out>,
    ) -> bool
       where T: Copy { ... }
}

A function of three items as a value, as Unary is for one.

Safety

The slice body initializes every slot in its output before returning.

Required Methods

fn one(&self, x: T, y: T, z: T) -> Self::Out

fn judged(&self, x: T, y: T, z: T) -> (Self::Out, bool)

fn slice( &self, args: [Arg<'_, T>; 3], n: usize, out: &mut [MaybeUninit<Self::Out>], ) -> bool

Provided Methods

fn checked(&self, x: T, y: T, z: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, z: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, z: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Ternary<Complex<f32>> for Choose

impl Ternary<Complex<f64>> for Choose

impl Ternary<bool> for Choose

impl Ternary<char> for Choose

impl Ternary<f16> for Choose

impl Ternary<f32> for Choose

impl Ternary<f64> for Choose

impl Ternary<i16> for Choose

impl Ternary<i32> for Choose

impl Ternary<i64> for Choose

impl Ternary<u8> for Choose

impl<T: KernelItem, K: Ternary<T>> Ternary<T> for Wrapped<K>