Trait Splittable7 

pub trait Splittable7<'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;

    // Required methods
    fn split7(
        &'a self,
    ) -> (Self::A, Self::B, Self::C, Self::D, Self::E, Self::F, Self::G);
    fn split7_mut(
        &'a mut self,
    ) -> (Self::MutA, Self::MutB, Self::MutC, Self::MutD, Self::MutE, Self::MutF, Self::MutG);
}

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

Required Methods

fn split7( &'a self, ) -> (Self::A, Self::B, Self::C, Self::D, Self::E, Self::F, Self::G)

fn split7_mut( &'a mut self, ) -> (Self::MutA, Self::MutB, Self::MutC, Self::MutD, Self::MutE, Self::MutF, Self::MutG)

Implementors

impl<'a, SplitType, T: Splittable8<'a, SplitType>> Splittable7<'a, SplitType> for T

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

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

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

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

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

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

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

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

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

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

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

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

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

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