Struct beagle::consts::One

pub struct One;

Trait Implementations

impl IsLargerThan<Zero> for One

impl NotSame<Zero> for One

impl DecrementIfLargerThan<Zero> for One

type Result = <One as HasSmaller>::Smaller

impl HasSmaller for One

type Smaller = Zero

impl IsSmallerThan<Two> for One

fn index_array<T>(a0: &<Two as Array<T>>::Type) -> &T

Index an array of size C safely.

impl NotSame<Two> for One

impl DecrementIfLargerThan<Two> for One

type Result = One

impl IsSmallerThan<Three> for One

fn index_array<T>(a0: &<Three as Array<T>>::Type) -> &T

Index an array of size C safely.

impl NotSame<Three> for One

impl DecrementIfLargerThan<Three> for One

type Result = One

impl IsSmallerThan<Four> for One

fn index_array<T>(a0: &<Four as Array<T>>::Type) -> &T

Index an array of size C safely.

impl NotSame<Four> for One

impl DecrementIfLargerThan<Four> for One

type Result = One

impl HasLarger for One

type Larger = Two

impl Clone for One

fn clone(&self) -> One

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for One

impl Debug for One

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for One

fn default() -> One

Returns the "default value" for a type.

impl PartialEq for One

fn eq(&self, __arg_0: &One) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd for One

fn partial_cmp(&self, __arg_0: &One) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Ord for One

fn cmp(&self, __arg_0: &One) -> Ordering

This method returns an Ordering between self and other.

impl Eq for One

impl Hash for One

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Constant for One

const VALUE: usize

VALUE: usize = 1

impl<T> Array<T> for One

type RawType = [T; 1]

A raw array of the size equal to the dimension this type represents.

type Type = CustomArrayOne<T>

A custom array of the size equal to the dimension this type represents.

fn from_value(v: T) -> Self::Type where
    T: Clone, 

Construct an array from a single value v, replicating it to all positions in the array.

fn apply<F>(a0: Self::Type, f: F) where
    F: FnMut(T), 

Apply f to all the elements of the array

fn apply2<U, F>(a0: Self::Type, a1: Self::Type, f: F) where
    F: FnMut(T, U), 

Apply f to all elements of two arrays.

fn fold<O, F>(a0: Self::Type, init: O, f: F) -> O where
    F: FnMut(O, T) -> O, 

Fold all the elements of the array with function f

fn fold2<U, O, F>(a0: Self::Type, a1: Self::Type, init: O, f: F) -> O where
    F: FnMut(O, T, U) -> O, 

Fold all the elements of two arrays with function f

fn map<O, F>(a0: Self::Type, f: F) -> Self::Type where
    F: FnMut(T) -> O, 

Map all the elements of the array with function f

fn map_into_2<O1, O2, F>(a0: Self::Type, f: F) -> (Self::Type, Self::Type) where
    F: FnMut(T) -> (O1, O2), 

Map all the elements into two arrays with function f

fn map2<U, O, F>(a0: Self::Type, a1: Self::Type, f: F) -> Self::Type where
    F: FnMut(T, U) -> O, 

Map all the elements of two arrays with function f

fn map3<T2, T3, O, F>(
    a0: Self::Type,
    a1: Self::Type,
    a2: Self::Type,
    f: F
) -> Self::Type where
    F: FnMut(T, T2, T3) -> O, 

Map all the elements of three arrays with function f

fn transpose<U, S>(a0: Self::Type) -> <U as Array<Self::Type>>::Type where
    U: Dim<S, Type = T> + Dim<Self::Type>,
    U::Smaller: Array<S> + Array<Self::Type>, 

Transpose the elements of a 2d array

fn transpose_helper<U>(a0: <U as Array<Self::Type>>::Type) -> Self::Type where
    U: Array<Self::Type> + Array<T>, 

A helper to transpose the elements of a 2d array (recursion)

impl<T> ArrayRef<T> for One

fn get_ref(a0: &Self::Type) -> Self::Type

impl<T> ArrayMut<T> for One

fn get_mut(a0: &mut Self::Type) -> Self::Type

impl<T> Dim<T> for One

fn split(a0: Self::Type) -> (T, <Self::Smaller as Array<T>>::Type)

Split the array into an element and a smaller array.

fn split_ref(a0: &Self::Type) -> (&T, &<Self::Smaller as Array<T>>::Type)

Split the array into a reference to an element and a reference to a smaller array.

fn split_ref_end(a0: &Self::Type) -> (&<Self::Smaller as Array<T>>::Type, &T)

Split the array into a reference to a smaller array and a reference to an element.

fn split_mut(
    a0: &mut Self::Type
) -> (&mut T, &mut <Self::Smaller as Array<T>>::Type)

Split the array into a mutable reference to an element and a mutable reference to a smaller array.

fn split_mut_end(
    a0: &mut Self::Type
) -> (&mut <Self::Smaller as Array<T>>::Type, &mut T)

Split the array into a mutable reference to a smaller array and a mutable reference to an element.

fn chain(a0v0: T, a0: <Self::Smaller as Array<T>>::Type) -> Self::Type

The opposite of split.

impl ExtractItem<Zero> for One

fn extract<T>(
    a0: Self::Type
) -> (T, <<One as HasSmaller>::Smaller as Array<T>>::Type)

impl<T> DimRef<T> for One

impl<T> DimMut<T> for One

impl<T, D: Dim<T>> TwoDim<T, D> for One where
    D::Smaller: Array<T>, 

impl<T, D: DimRef<T>> TwoDimRef<T, D> for One where
    D::Smaller: Array<T> + Array<&'a T>, 

impl<T, D: DimMut<T>> TwoDimMut<T, D> for One where
    D::Smaller: Array<T> + Array<&'a T> + Array<&'a mut T>, 

impl<I0: Constant, I1: Constant> SelectTwo<I0, I1> for One

type Selected = I1

impl<I0: Constant, I1: Constant, I2: Constant> SelectThree<I0, I1, I2> for One

type Selected = I1

impl<I0: Constant, I1: Constant, I2: Constant, I3: Constant> SelectFour<I0, I1, I2, I3> for One

type Selected = I1