Trait ordes::OrdesPop

pub trait OrdesPop {
    type Newlen;
    type Output;

    // Required method
    fn pop(self) -> (Self::Newlen, Self::Output);
}

Trait for defining the removal of the last element from an array- or tuple-like data structure.

Required Associated Types

type Newlen

Type of the container after .pop() has been called.

type Output

Type of the removed value.

Required Methods

fn pop(self) -> (Self::Newlen, Self::Output)

Remove the last element from self and return it.

Examples

Using an array:

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

Using a tuple:

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

Implementations on Foreign Types

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

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

type Output = T12

fn pop(self) -> (Self::Newlen, T12)

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> OrdesPop 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 Newlen = (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

fn pop(self) -> (Self::Newlen, T22)

impl<T> OrdesPop for [T; 25]

type Newlen = [T; 24]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 11]

type Newlen = [T; 10]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 7]

type Newlen = [T; 6]

type Output = T

fn pop(self) -> (Self::Newlen, 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> OrdesPop 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 Newlen = (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

fn pop(self) -> (Self::Newlen, T26)

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

type Newlen = (T0, T1, T2)

type Output = T3

fn pop(self) -> (Self::Newlen, T3)

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

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

type Output = T7

fn pop(self) -> (Self::Newlen, T7)

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

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

type Output = T19

fn pop(self) -> (Self::Newlen, T19)

impl<T> OrdesPop for [T; 24]

type Newlen = [T; 23]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 1]

type Newlen = ()

type Output = T

fn pop(self) -> (Self::Newlen, T)

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

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

type Output = T20

fn pop(self) -> (Self::Newlen, T20)

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> OrdesPop 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 Newlen = (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

fn pop(self) -> (Self::Newlen, T25)

impl<T> OrdesPop for [T; 5]

type Newlen = [T; 4]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 8]

type Newlen = [T; 7]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

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

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

type Output = T18

fn pop(self) -> (Self::Newlen, T18)

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

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

type Output = T16

fn pop(self) -> (Self::Newlen, T16)

impl<T> OrdesPop for [T; 22]

type Newlen = [T; 21]

type Output = T

fn pop(self) -> (Self::Newlen, 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> OrdesPop 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 Newlen = (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

fn pop(self) -> (Self::Newlen, T30)

impl<T> OrdesPop for [T; 30]

type Newlen = [T; 29]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 9]

type Newlen = [T; 8]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 16]

type Newlen = [T; 15]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

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

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

type Output = T9

fn pop(self) -> (Self::Newlen, T9)

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

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

type Output = T13

fn pop(self) -> (Self::Newlen, T13)

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> OrdesPop 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 Newlen = (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

fn pop(self) -> (Self::Newlen, T29)

impl<T> OrdesPop for [T; 17]

type Newlen = [T; 16]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 10]

type Newlen = [T; 9]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 23]

type Newlen = [T; 22]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 20]

type Newlen = [T; 19]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 2]

type Newlen = [T; 1]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 15]

type Newlen = [T; 14]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

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

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

type Output = T6

fn pop(self) -> (Self::Newlen, T6)

impl<T> OrdesPop for [T; 18]

type Newlen = [T; 17]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

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

type Newlen = (T0, T1)

type Output = T2

fn pop(self) -> (Self::Newlen, T2)

impl<T0> OrdesPop for (T0,)

type Newlen = ()

type Output = T0

fn pop(self) -> (Self::Newlen, T0)

impl<T> OrdesPop for [T; 27]

type Newlen = [T; 26]

type Output = T

fn pop(self) -> (Self::Newlen, 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> OrdesPop 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 Newlen = (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

fn pop(self) -> (Self::Newlen, T24)

impl<T> OrdesPop for [T; 12]

type Newlen = [T; 11]

type Output = T

fn pop(self) -> (Self::Newlen, 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> OrdesPop 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 Newlen = (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

fn pop(self) -> (Self::Newlen, T28)

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

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

type Output = T15

fn pop(self) -> (Self::Newlen, T15)

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

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

type Output = T21

fn pop(self) -> (Self::Newlen, T21)

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

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

type Output = T8

fn pop(self) -> (Self::Newlen, T8)

impl<T> OrdesPop for [T; 13]

type Newlen = [T; 12]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 26]

type Newlen = [T; 25]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

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

type Newlen = T0

type Output = T1

fn pop(self) -> (Self::Newlen, T1)

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> OrdesPop 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 Newlen = (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

fn pop(self) -> (Self::Newlen, T27)

impl<T> OrdesPop for [T; 14]

type Newlen = [T; 13]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

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

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

type Output = T14

fn pop(self) -> (Self::Newlen, T14)

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

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

type Output = T4

fn pop(self) -> (Self::Newlen, T4)

impl<T> OrdesPop for [T; 29]

type Newlen = [T; 28]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 3]

type Newlen = [T; 2]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 28]

type Newlen = [T; 27]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 6]

type Newlen = [T; 5]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

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

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

type Output = T5

fn pop(self) -> (Self::Newlen, T5)

impl<T> OrdesPop for [T; 19]

type Newlen = [T; 18]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

impl<T> OrdesPop for [T; 32]

type Newlen = [T; 31]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

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

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

type Output = T11

fn pop(self) -> (Self::Newlen, T11)

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> OrdesPop 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 Newlen = (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

fn pop(self) -> (Self::Newlen, T31)

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

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

type Output = T10

fn pop(self) -> (Self::Newlen, T10)

impl<T> OrdesPop for [T; 21]

type Newlen = [T; 20]

type Output = T

fn pop(self) -> (Self::Newlen, 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> OrdesPop 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 Newlen = (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

fn pop(self) -> (Self::Newlen, T23)

impl<T> OrdesPop for [T; 31]

type Newlen = [T; 30]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

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

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

type Output = T17

fn pop(self) -> (Self::Newlen, T17)

impl<T> OrdesPop for [T; 4]

type Newlen = [T; 3]

type Output = T

fn pop(self) -> (Self::Newlen, Self::Output)

Implementors