Trait ordes::OrdesCons

pub trait OrdesCons<Input> {
    type Output;

    // Required method
    fn cons(self, value: Input) -> Self::Output;
}

Required Associated Types

type Output

Required Methods

fn cons(self, value: Input) -> Self::Output

Add an element to the start of self and return the sum.

Examples

Using an array:

let foo: [u8; 4] = [1, 2, 3, 4];
let foo = foo.cons(0);
assert_eq!(foo, [0, 1, 2, 3, 4]);

Using a tuple:

let foo = (false, b'c', "d");
let foo = foo.cons('a');
assert_eq!(foo, ('a', false, b'c', "d"));

Implementations on Foreign Types

impl<T> OrdesCons<T> for [T; 12]

type Output = [T; 13]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 6]

type Output = [T; 7]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6> OrdesCons<T6> for (T0, T1, T2, T3, T4, T5)

type Output = (T6, T0, T1, T2, T3, T4, T5)

fn cons(self, value: T6) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> OrdesCons<T16> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

type Output = (T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn cons(self, value: T16) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> OrdesCons<T26> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)

type Output = (T26, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)

fn cons(self, value: T26) -> Self::Output

impl<T> OrdesCons<T> for [T; 2]

type Output = [T; 3]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 3]

type Output = [T; 4]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 18]

type Output = [T; 19]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> OrdesCons<T20> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)

type Output = (T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)

fn cons(self, value: T20) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> OrdesCons<T24> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)

type Output = (T24, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)

fn cons(self, value: T24) -> Self::Output

impl<T> OrdesCons<T> for [T; 21]

type Output = [T; 22]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 14]

type Output = [T; 15]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> OrdesCons<T23> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)

type Output = (T23, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)

fn cons(self, value: T23) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> OrdesCons<T19> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)

type Output = (T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)

fn cons(self, value: T19) -> Self::Output

impl<T> OrdesCons<T> for [T; 30]

type Output = [T; 31]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> OrdesCons<T22> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)

type Output = (T22, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)

fn cons(self, value: T22) -> Self::Output

impl<T> OrdesCons<T> for [T; 17]

type Output = [T; 18]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 7]

type Output = [T; 8]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 24]

type Output = [T; 25]

fn cons(self, value: T) -> Self::Output

impl<T0, T1> OrdesCons<T1> for (T0,)

type Output = (T1, T0)

fn cons(self, value: T1) -> Self::Output

impl<T> OrdesCons<T> for [T; 25]

type Output = [T; 26]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32> OrdesCons<T32> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)

type Output = (T32, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)

fn cons(self, value: T32) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7> OrdesCons<T7> for (T0, T1, T2, T3, T4, T5, T6)

type Output = (T7, T0, T1, T2, T3, T4, T5, T6)

fn cons(self, value: T7) -> Self::Output

impl<T> OrdesCons<T> for [T; 32]

type Output = [T; 33]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> OrdesCons<T25> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)

type Output = (T25, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)

fn cons(self, value: T25) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrdesCons<T12> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

type Output = (T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

fn cons(self, value: T12) -> Self::Output

impl<T> OrdesCons<T> for [T; 19]

type Output = [T; 20]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 29]

type Output = [T; 30]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 1]

type Output = [T; 2]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3> OrdesCons<T3> for (T0, T1, T2)

type Output = (T3, T0, T1, T2)

fn cons(self, value: T3) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> OrdesCons<T9> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

type Output = (T9, T0, T1, T2, T3, T4, T5, T6, T7, T8)

fn cons(self, value: T9) -> Self::Output

impl<T0, T1, T2> OrdesCons<T2> for (T0, T1)

type Output = (T2, T0, T1)

fn cons(self, value: T2) -> Self::Output

impl<T> OrdesCons<T> for [T; 15]

type Output = [T; 16]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> OrdesCons<T14> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

type Output = (T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

fn cons(self, value: T14) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> OrdesCons<T15> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

type Output = (T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

fn cons(self, value: T15) -> Self::Output

impl<T> OrdesCons<T> for [T; 31]

type Output = [T; 32]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29> OrdesCons<T29> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)

type Output = (T29, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)

fn cons(self, value: T29) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> OrdesCons<T21> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)

type Output = (T21, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)

fn cons(self, value: T21) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30> OrdesCons<T30> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)

type Output = (T30, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)

fn cons(self, value: T30) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> OrdesCons<T18> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)

type Output = (T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)

fn cons(self, value: T18) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31> OrdesCons<T31> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)

type Output = (T31, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)

fn cons(self, value: T31) -> Self::Output

impl<T> OrdesCons<T> for [T; 20]

type Output = [T; 21]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 5]

type Output = [T; 6]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 13]

type Output = [T; 14]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 26]

type Output = [T; 27]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 11]

type Output = [T; 12]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> OrdesCons<T17> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

type Output = (T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

fn cons(self, value: T17) -> Self::Output

impl<T0, T1, T2, T3, T4> OrdesCons<T4> for (T0, T1, T2, T3)

type Output = (T4, T0, T1, T2, T3)

fn cons(self, value: T4) -> Self::Output

impl<T> OrdesCons<T> for [T; 28]

type Output = [T; 29]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> OrdesCons<T28> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)

type Output = (T28, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)

fn cons(self, value: T28) -> Self::Output

impl<T> OrdesCons<T> for [T; 9]

type Output = [T; 10]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> OrdesCons<T27> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)

type Output = (T27, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)

fn cons(self, value: T27) -> Self::Output

impl<T> OrdesCons<T> for [T; 22]

type Output = [T; 23]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> OrdesCons<T8> for (T0, T1, T2, T3, T4, T5, T6, T7)

type Output = (T8, T0, T1, T2, T3, T4, T5, T6, T7)

fn cons(self, value: T8) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> OrdesCons<T13> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

type Output = (T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

fn cons(self, value: T13) -> Self::Output

impl<T> OrdesCons<T> for [T; 8]

type Output = [T; 9]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 4]

type Output = [T; 5]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 27]

type Output = [T; 28]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrdesCons<T11> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

type Output = (T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

fn cons(self, value: T11) -> Self::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrdesCons<T10> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

type Output = (T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

fn cons(self, value: T10) -> Self::Output

impl<T> OrdesCons<T> for [T; 10]

type Output = [T; 11]

fn cons(self, value: T) -> Self::Output

impl<T0, T1, T2, T3, T4, T5> OrdesCons<T5> for (T0, T1, T2, T3, T4)

type Output = (T5, T0, T1, T2, T3, T4)

fn cons(self, value: T5) -> Self::Output

impl<T> OrdesCons<T> for [T; 16]

type Output = [T; 17]

fn cons(self, value: T) -> Self::Output

impl<T> OrdesCons<T> for [T; 23]

type Output = [T; 24]

fn cons(self, value: T) -> Self::Output

Implementors