Trait Splittable17 

pub trait Splittable17<'a, SplitType = ()> {
    type A: 'a;
    type MutA: 'a;
    type B: 'a;
    type MutB: 'a;
    type C: 'a;
    type MutC: 'a;
    type D: 'a;
    type MutD: 'a;
    type E: 'a;
    type MutE: 'a;
    type F: 'a;
    type MutF: 'a;
    type G: 'a;
    type MutG: 'a;
    type H: 'a;
    type MutH: 'a;
    type I: 'a;
    type MutI: 'a;
    type J: 'a;
    type MutJ: 'a;
    type K: 'a;
    type MutK: 'a;
    type L: 'a;
    type MutL: 'a;
    type M: 'a;
    type MutM: 'a;
    type N: 'a;
    type MutN: 'a;
    type O: 'a;
    type MutO: 'a;
    type P: 'a;
    type MutP: 'a;
    type Q: 'a;
    type MutQ: 'a;

    // Required methods
    fn split17(
        &'a self,
    ) -> (Self::A, Self::B, Self::C, Self::D, Self::E, Self::F, Self::G, Self::H, Self::I, Self::J, Self::K, Self::L, Self::M, Self::N, Self::O, Self::P, Self::Q);
    fn split17_mut(
        &'a mut self,
    ) -> (Self::MutA, Self::MutB, Self::MutC, Self::MutD, Self::MutE, Self::MutF, Self::MutG, Self::MutH, Self::MutI, Self::MutJ, Self::MutK, Self::MutL, Self::MutM, Self::MutN, Self::MutO, Self::MutP, Self::MutQ);
}

A type which can be split into disjoint references. SplitType allows a type to be split multiple

Required Associated Types

type A: 'a

type MutA: 'a

type B: 'a

type MutB: 'a

type C: 'a

type MutC: 'a

type D: 'a

type MutD: 'a

type E: 'a

type MutE: 'a

type F: 'a

type MutF: 'a

type G: 'a

type MutG: 'a

type H: 'a

type MutH: 'a

type I: 'a

type MutI: 'a

type J: 'a

type MutJ: 'a

type K: 'a

type MutK: 'a

type L: 'a

type MutL: 'a

type M: 'a

type MutM: 'a

type N: 'a

type MutN: 'a

type O: 'a

type MutO: 'a

type P: 'a

type MutP: 'a

type Q: 'a

type MutQ: 'a

Required Methods

fn split17( &'a self, ) -> (Self::A, Self::B, Self::C, Self::D, Self::E, Self::F, Self::G, Self::H, Self::I, Self::J, Self::K, Self::L, Self::M, Self::N, Self::O, Self::P, Self::Q)

fn split17_mut( &'a mut self, ) -> (Self::MutA, Self::MutB, Self::MutC, Self::MutD, Self::MutE, Self::MutF, Self::MutG, Self::MutH, Self::MutI, Self::MutJ, Self::MutK, Self::MutL, Self::MutM, Self::MutN, Self::MutO, Self::MutP, Self::MutQ)

Implementors

impl<'a, SplitType, T: Splittable18<'a, SplitType>> Splittable17<'a, SplitType> for T

type A = <T as Splittable18<'a, SplitType>>::A

type B = <T as Splittable18<'a, SplitType>>::B

type C = <T as Splittable18<'a, SplitType>>::C

type D = <T as Splittable18<'a, SplitType>>::D

type E = <T as Splittable18<'a, SplitType>>::E

type F = <T as Splittable18<'a, SplitType>>::F

type G = <T as Splittable18<'a, SplitType>>::G

type H = <T as Splittable18<'a, SplitType>>::H

type I = <T as Splittable18<'a, SplitType>>::I

type J = <T as Splittable18<'a, SplitType>>::J

type K = <T as Splittable18<'a, SplitType>>::K

type L = <T as Splittable18<'a, SplitType>>::L

type M = <T as Splittable18<'a, SplitType>>::M

type N = <T as Splittable18<'a, SplitType>>::N

type O = <T as Splittable18<'a, SplitType>>::O

type P = <T as Splittable18<'a, SplitType>>::P

type Q = <T as Splittable18<'a, SplitType>>::Q

type MutA = <T as Splittable18<'a, SplitType>>::MutA

type MutB = <T as Splittable18<'a, SplitType>>::MutB

type MutC = <T as Splittable18<'a, SplitType>>::MutC

type MutD = <T as Splittable18<'a, SplitType>>::MutD

type MutE = <T as Splittable18<'a, SplitType>>::MutE

type MutF = <T as Splittable18<'a, SplitType>>::MutF

type MutG = <T as Splittable18<'a, SplitType>>::MutG

type MutH = <T as Splittable18<'a, SplitType>>::MutH

type MutI = <T as Splittable18<'a, SplitType>>::MutI

type MutJ = <T as Splittable18<'a, SplitType>>::MutJ

type MutK = <T as Splittable18<'a, SplitType>>::MutK

type MutL = <T as Splittable18<'a, SplitType>>::MutL

type MutM = <T as Splittable18<'a, SplitType>>::MutM

type MutN = <T as Splittable18<'a, SplitType>>::MutN

type MutO = <T as Splittable18<'a, SplitType>>::MutO

type MutP = <T as Splittable18<'a, SplitType>>::MutP

type MutQ = <T as Splittable18<'a, SplitType>>::MutQ