Trait grafix_toolbox::lib::tuple::TupleSwizzle4

source ·
pub trait TupleSwizzle4<A: Copy, B: Copy, C: Copy, D: Copy>: Sized {
Show 681 methods    // Required method
    fn s(self) -> (A, B, C, D);

    // Provided methods
    fn x(self) -> A { ... }
    fn y(self) -> B { ... }
    fn z(self) -> C { ... }
    fn w(self) -> D { ... }
    fn xx(self) -> (A, A) { ... }
    fn xy(self) -> (A, B) { ... }
    fn xz(self) -> (A, C) { ... }
    fn xw(self) -> (A, D) { ... }
    fn yx(self) -> (B, A) { ... }
    fn yy(self) -> (B, B) { ... }
    fn yz(self) -> (B, C) { ... }
    fn yw(self) -> (B, D) { ... }
    fn zx(self) -> (C, A) { ... }
    fn zy(self) -> (C, B) { ... }
    fn zz(self) -> (C, C) { ... }
    fn zw(self) -> (C, D) { ... }
    fn wx(self) -> (D, A) { ... }
    fn wy(self) -> (D, B) { ... }
    fn wz(self) -> (D, C) { ... }
    fn ww(self) -> (D, D) { ... }
    fn xxx(self) -> (A, A, A) { ... }
    fn xxy(self) -> (A, A, B) { ... }
    fn xxz(self) -> (A, A, C) { ... }
    fn xxw(self) -> (A, A, D) { ... }
    fn xyx(self) -> (A, B, A) { ... }
    fn xyy(self) -> (A, B, B) { ... }
    fn xyz(self) -> (A, B, C) { ... }
    fn xyw(self) -> (A, B, D) { ... }
    fn xzx(self) -> (A, C, A) { ... }
    fn xzy(self) -> (A, C, B) { ... }
    fn xzz(self) -> (A, C, C) { ... }
    fn xzw(self) -> (A, C, D) { ... }
    fn xwx(self) -> (A, D, A) { ... }
    fn xwy(self) -> (A, D, B) { ... }
    fn xwz(self) -> (A, D, C) { ... }
    fn xww(self) -> (A, D, D) { ... }
    fn yxx(self) -> (B, A, A) { ... }
    fn yxy(self) -> (B, A, B) { ... }
    fn yxz(self) -> (B, A, C) { ... }
    fn yxw(self) -> (B, A, D) { ... }
    fn yyx(self) -> (B, B, A) { ... }
    fn yyy(self) -> (B, B, B) { ... }
    fn yyz(self) -> (B, B, C) { ... }
    fn yyw(self) -> (B, B, D) { ... }
    fn yzx(self) -> (B, C, A) { ... }
    fn yzy(self) -> (B, C, B) { ... }
    fn yzz(self) -> (B, C, C) { ... }
    fn yzw(self) -> (B, C, D) { ... }
    fn ywx(self) -> (B, D, A) { ... }
    fn ywy(self) -> (B, D, B) { ... }
    fn ywz(self) -> (B, D, C) { ... }
    fn yww(self) -> (B, D, D) { ... }
    fn zxx(self) -> (C, A, A) { ... }
    fn zxy(self) -> (C, A, B) { ... }
    fn zxz(self) -> (C, A, C) { ... }
    fn zxw(self) -> (C, A, D) { ... }
    fn zyx(self) -> (C, B, A) { ... }
    fn zyy(self) -> (C, B, B) { ... }
    fn zyz(self) -> (C, B, C) { ... }
    fn zyw(self) -> (C, B, D) { ... }
    fn zzx(self) -> (C, C, A) { ... }
    fn zzy(self) -> (C, C, B) { ... }
    fn zzz(self) -> (C, C, C) { ... }
    fn zzw(self) -> (C, C, D) { ... }
    fn zwx(self) -> (C, D, A) { ... }
    fn zwy(self) -> (C, D, B) { ... }
    fn zwz(self) -> (C, D, C) { ... }
    fn zww(self) -> (C, D, D) { ... }
    fn wxx(self) -> (D, A, A) { ... }
    fn wxy(self) -> (D, A, B) { ... }
    fn wxz(self) -> (D, A, C) { ... }
    fn wxw(self) -> (D, A, D) { ... }
    fn wyx(self) -> (D, B, A) { ... }
    fn wyy(self) -> (D, B, B) { ... }
    fn wyz(self) -> (D, B, C) { ... }
    fn wyw(self) -> (D, B, D) { ... }
    fn wzx(self) -> (D, C, A) { ... }
    fn wzy(self) -> (D, C, B) { ... }
    fn wzz(self) -> (D, C, C) { ... }
    fn wzw(self) -> (D, C, D) { ... }
    fn wwx(self) -> (D, D, A) { ... }
    fn wwy(self) -> (D, D, B) { ... }
    fn wwz(self) -> (D, D, C) { ... }
    fn www(self) -> (D, D, D) { ... }
    fn xxxx(self) -> (A, A, A, A) { ... }
    fn xxxy(self) -> (A, A, A, B) { ... }
    fn xxxz(self) -> (A, A, A, C) { ... }
    fn xxxw(self) -> (A, A, A, D) { ... }
    fn xxyx(self) -> (A, A, B, A) { ... }
    fn xxyy(self) -> (A, A, B, B) { ... }
    fn xxyz(self) -> (A, A, B, C) { ... }
    fn xxyw(self) -> (A, A, B, D) { ... }
    fn xxzx(self) -> (A, A, C, A) { ... }
    fn xxzy(self) -> (A, A, C, B) { ... }
    fn xxzz(self) -> (A, A, C, C) { ... }
    fn xxzw(self) -> (A, A, C, D) { ... }
    fn xxwx(self) -> (A, A, D, A) { ... }
    fn xxwy(self) -> (A, A, D, B) { ... }
    fn xxwz(self) -> (A, A, D, C) { ... }
    fn xxww(self) -> (A, A, D, D) { ... }
    fn xyxx(self) -> (A, B, A, A) { ... }
    fn xyxy(self) -> (A, B, A, B) { ... }
    fn xyxz(self) -> (A, B, A, C) { ... }
    fn xyxw(self) -> (A, B, A, D) { ... }
    fn xyyx(self) -> (A, B, B, A) { ... }
    fn xyyy(self) -> (A, B, B, B) { ... }
    fn xyyz(self) -> (A, B, B, C) { ... }
    fn xyyw(self) -> (A, B, B, D) { ... }
    fn xyzx(self) -> (A, B, C, A) { ... }
    fn xyzy(self) -> (A, B, C, B) { ... }
    fn xyzz(self) -> (A, B, C, C) { ... }
    fn xyzw(self) -> (A, B, C, D) { ... }
    fn xywx(self) -> (A, B, D, A) { ... }
    fn xywy(self) -> (A, B, D, B) { ... }
    fn xywz(self) -> (A, B, D, C) { ... }
    fn xyww(self) -> (A, B, D, D) { ... }
    fn xzxx(self) -> (A, C, A, A) { ... }
    fn xzxy(self) -> (A, C, A, B) { ... }
    fn xzxz(self) -> (A, C, A, C) { ... }
    fn xzxw(self) -> (A, C, A, D) { ... }
    fn xzyx(self) -> (A, C, B, A) { ... }
    fn xzyy(self) -> (A, C, B, B) { ... }
    fn xzyz(self) -> (A, C, B, C) { ... }
    fn xzyw(self) -> (A, C, B, D) { ... }
    fn xzzx(self) -> (A, C, C, A) { ... }
    fn xzzy(self) -> (A, C, C, B) { ... }
    fn xzzz(self) -> (A, C, C, C) { ... }
    fn xzzw(self) -> (A, C, C, D) { ... }
    fn xzwx(self) -> (A, C, D, A) { ... }
    fn xzwy(self) -> (A, C, D, B) { ... }
    fn xzwz(self) -> (A, C, D, C) { ... }
    fn xzww(self) -> (A, C, D, D) { ... }
    fn xwxx(self) -> (A, D, A, A) { ... }
    fn xwxy(self) -> (A, D, A, B) { ... }
    fn xwxz(self) -> (A, D, A, C) { ... }
    fn xwxw(self) -> (A, D, A, D) { ... }
    fn xwyx(self) -> (A, D, B, A) { ... }
    fn xwyy(self) -> (A, D, B, B) { ... }
    fn xwyz(self) -> (A, D, B, C) { ... }
    fn xwyw(self) -> (A, D, B, D) { ... }
    fn xwzx(self) -> (A, D, C, A) { ... }
    fn xwzy(self) -> (A, D, C, B) { ... }
    fn xwzz(self) -> (A, D, C, C) { ... }
    fn xwzw(self) -> (A, D, C, D) { ... }
    fn xwwx(self) -> (A, D, D, A) { ... }
    fn xwwy(self) -> (A, D, D, B) { ... }
    fn xwwz(self) -> (A, D, D, C) { ... }
    fn xwww(self) -> (A, D, D, D) { ... }
    fn yxxx(self) -> (B, A, A, A) { ... }
    fn yxxy(self) -> (B, A, A, B) { ... }
    fn yxxz(self) -> (B, A, A, C) { ... }
    fn yxxw(self) -> (B, A, A, D) { ... }
    fn yxyx(self) -> (B, A, B, A) { ... }
    fn yxyy(self) -> (B, A, B, B) { ... }
    fn yxyz(self) -> (B, A, B, C) { ... }
    fn yxyw(self) -> (B, A, B, D) { ... }
    fn yxzx(self) -> (B, A, C, A) { ... }
    fn yxzy(self) -> (B, A, C, B) { ... }
    fn yxzz(self) -> (B, A, C, C) { ... }
    fn yxzw(self) -> (B, A, C, D) { ... }
    fn yxwx(self) -> (B, A, D, A) { ... }
    fn yxwy(self) -> (B, A, D, B) { ... }
    fn yxwz(self) -> (B, A, D, C) { ... }
    fn yxww(self) -> (B, A, D, D) { ... }
    fn yyxx(self) -> (B, B, A, A) { ... }
    fn yyxy(self) -> (B, B, A, B) { ... }
    fn yyxz(self) -> (B, B, A, C) { ... }
    fn yyxw(self) -> (B, B, A, D) { ... }
    fn yyyx(self) -> (B, B, B, A) { ... }
    fn yyyy(self) -> (B, B, B, B) { ... }
    fn yyyz(self) -> (B, B, B, C) { ... }
    fn yyyw(self) -> (B, B, B, D) { ... }
    fn yyzx(self) -> (B, B, C, A) { ... }
    fn yyzy(self) -> (B, B, C, B) { ... }
    fn yyzz(self) -> (B, B, C, C) { ... }
    fn yyzw(self) -> (B, B, C, D) { ... }
    fn yywx(self) -> (B, B, D, A) { ... }
    fn yywy(self) -> (B, B, D, B) { ... }
    fn yywz(self) -> (B, B, D, C) { ... }
    fn yyww(self) -> (B, B, D, D) { ... }
    fn yzxx(self) -> (B, C, A, A) { ... }
    fn yzxy(self) -> (B, C, A, B) { ... }
    fn yzxz(self) -> (B, C, A, C) { ... }
    fn yzxw(self) -> (B, C, A, D) { ... }
    fn yzyx(self) -> (B, C, B, A) { ... }
    fn yzyy(self) -> (B, C, B, B) { ... }
    fn yzyz(self) -> (B, C, B, C) { ... }
    fn yzyw(self) -> (B, C, B, D) { ... }
    fn yzzx(self) -> (B, C, C, A) { ... }
    fn yzzy(self) -> (B, C, C, B) { ... }
    fn yzzz(self) -> (B, C, C, C) { ... }
    fn yzzw(self) -> (B, C, C, D) { ... }
    fn yzwx(self) -> (B, C, D, A) { ... }
    fn yzwy(self) -> (B, C, D, B) { ... }
    fn yzwz(self) -> (B, C, D, C) { ... }
    fn yzww(self) -> (B, C, D, D) { ... }
    fn ywxx(self) -> (B, D, A, A) { ... }
    fn ywxy(self) -> (B, D, A, B) { ... }
    fn ywxz(self) -> (B, D, A, C) { ... }
    fn ywxw(self) -> (B, D, A, D) { ... }
    fn ywyx(self) -> (B, D, B, A) { ... }
    fn ywyy(self) -> (B, D, B, B) { ... }
    fn ywyz(self) -> (B, D, B, C) { ... }
    fn ywyw(self) -> (B, D, B, D) { ... }
    fn ywzx(self) -> (B, D, C, A) { ... }
    fn ywzy(self) -> (B, D, C, B) { ... }
    fn ywzz(self) -> (B, D, C, C) { ... }
    fn ywzw(self) -> (B, D, C, D) { ... }
    fn ywwx(self) -> (B, D, D, A) { ... }
    fn ywwy(self) -> (B, D, D, B) { ... }
    fn ywwz(self) -> (B, D, D, C) { ... }
    fn ywww(self) -> (B, D, D, D) { ... }
    fn zxxx(self) -> (C, A, A, A) { ... }
    fn zxxy(self) -> (C, A, A, B) { ... }
    fn zxxz(self) -> (C, A, A, C) { ... }
    fn zxxw(self) -> (C, A, A, D) { ... }
    fn zxyx(self) -> (C, A, B, A) { ... }
    fn zxyy(self) -> (C, A, B, B) { ... }
    fn zxyz(self) -> (C, A, B, C) { ... }
    fn zxyw(self) -> (C, A, B, D) { ... }
    fn zxzx(self) -> (C, A, C, A) { ... }
    fn zxzy(self) -> (C, A, C, B) { ... }
    fn zxzz(self) -> (C, A, C, C) { ... }
    fn zxzw(self) -> (C, A, C, D) { ... }
    fn zxwx(self) -> (C, A, D, A) { ... }
    fn zxwy(self) -> (C, A, D, B) { ... }
    fn zxwz(self) -> (C, A, D, C) { ... }
    fn zxww(self) -> (C, A, D, D) { ... }
    fn zyxx(self) -> (C, B, A, A) { ... }
    fn zyxy(self) -> (C, B, A, B) { ... }
    fn zyxz(self) -> (C, B, A, C) { ... }
    fn zyxw(self) -> (C, B, A, D) { ... }
    fn zyyx(self) -> (C, B, B, A) { ... }
    fn zyyy(self) -> (C, B, B, B) { ... }
    fn zyyz(self) -> (C, B, B, C) { ... }
    fn zyyw(self) -> (C, B, B, D) { ... }
    fn zyzx(self) -> (C, B, C, A) { ... }
    fn zyzy(self) -> (C, B, C, B) { ... }
    fn zyzz(self) -> (C, B, C, C) { ... }
    fn zyzw(self) -> (C, B, C, D) { ... }
    fn zywx(self) -> (C, B, D, A) { ... }
    fn zywy(self) -> (C, B, D, B) { ... }
    fn zywz(self) -> (C, B, D, C) { ... }
    fn zyww(self) -> (C, B, D, D) { ... }
    fn zzxx(self) -> (C, C, A, A) { ... }
    fn zzxy(self) -> (C, C, A, B) { ... }
    fn zzxz(self) -> (C, C, A, C) { ... }
    fn zzxw(self) -> (C, C, A, D) { ... }
    fn zzyx(self) -> (C, C, B, A) { ... }
    fn zzyy(self) -> (C, C, B, B) { ... }
    fn zzyz(self) -> (C, C, B, C) { ... }
    fn zzyw(self) -> (C, C, B, D) { ... }
    fn zzzx(self) -> (C, C, C, A) { ... }
    fn zzzy(self) -> (C, C, C, B) { ... }
    fn zzzz(self) -> (C, C, C, C) { ... }
    fn zzzw(self) -> (C, C, C, D) { ... }
    fn zzwx(self) -> (C, C, D, A) { ... }
    fn zzwy(self) -> (C, C, D, B) { ... }
    fn zzwz(self) -> (C, C, D, C) { ... }
    fn zzww(self) -> (C, C, D, D) { ... }
    fn zwxx(self) -> (C, D, A, A) { ... }
    fn zwxy(self) -> (C, D, A, B) { ... }
    fn zwxz(self) -> (C, D, A, C) { ... }
    fn zwxw(self) -> (C, D, A, D) { ... }
    fn zwyx(self) -> (C, D, B, A) { ... }
    fn zwyy(self) -> (C, D, B, B) { ... }
    fn zwyz(self) -> (C, D, B, C) { ... }
    fn zwyw(self) -> (C, D, B, D) { ... }
    fn zwzx(self) -> (C, D, C, A) { ... }
    fn zwzy(self) -> (C, D, C, B) { ... }
    fn zwzz(self) -> (C, D, C, C) { ... }
    fn zwzw(self) -> (C, D, C, D) { ... }
    fn zwwx(self) -> (C, D, D, A) { ... }
    fn zwwy(self) -> (C, D, D, B) { ... }
    fn zwwz(self) -> (C, D, D, C) { ... }
    fn zwww(self) -> (C, D, D, D) { ... }
    fn wxxx(self) -> (D, A, A, A) { ... }
    fn wxxy(self) -> (D, A, A, B) { ... }
    fn wxxz(self) -> (D, A, A, C) { ... }
    fn wxxw(self) -> (D, A, A, D) { ... }
    fn wxyx(self) -> (D, A, B, A) { ... }
    fn wxyy(self) -> (D, A, B, B) { ... }
    fn wxyz(self) -> (D, A, B, C) { ... }
    fn wxyw(self) -> (D, A, B, D) { ... }
    fn wxzx(self) -> (D, A, C, A) { ... }
    fn wxzy(self) -> (D, A, C, B) { ... }
    fn wxzz(self) -> (D, A, C, C) { ... }
    fn wxzw(self) -> (D, A, C, D) { ... }
    fn wxwx(self) -> (D, A, D, A) { ... }
    fn wxwy(self) -> (D, A, D, B) { ... }
    fn wxwz(self) -> (D, A, D, C) { ... }
    fn wxww(self) -> (D, A, D, D) { ... }
    fn wyxx(self) -> (D, B, A, A) { ... }
    fn wyxy(self) -> (D, B, A, B) { ... }
    fn wyxz(self) -> (D, B, A, C) { ... }
    fn wyxw(self) -> (D, B, A, D) { ... }
    fn wyyx(self) -> (D, B, B, A) { ... }
    fn wyyy(self) -> (D, B, B, B) { ... }
    fn wyyz(self) -> (D, B, B, C) { ... }
    fn wyyw(self) -> (D, B, B, D) { ... }
    fn wyzx(self) -> (D, B, C, A) { ... }
    fn wyzy(self) -> (D, B, C, B) { ... }
    fn wyzz(self) -> (D, B, C, C) { ... }
    fn wyzw(self) -> (D, B, C, D) { ... }
    fn wywx(self) -> (D, B, D, A) { ... }
    fn wywy(self) -> (D, B, D, B) { ... }
    fn wywz(self) -> (D, B, D, C) { ... }
    fn wyww(self) -> (D, B, D, D) { ... }
    fn wzxx(self) -> (D, C, A, A) { ... }
    fn wzxy(self) -> (D, C, A, B) { ... }
    fn wzxz(self) -> (D, C, A, C) { ... }
    fn wzxw(self) -> (D, C, A, D) { ... }
    fn wzyx(self) -> (D, C, B, A) { ... }
    fn wzyy(self) -> (D, C, B, B) { ... }
    fn wzyz(self) -> (D, C, B, C) { ... }
    fn wzyw(self) -> (D, C, B, D) { ... }
    fn wzzx(self) -> (D, C, C, A) { ... }
    fn wzzy(self) -> (D, C, C, B) { ... }
    fn wzzz(self) -> (D, C, C, C) { ... }
    fn wzzw(self) -> (D, C, C, D) { ... }
    fn wzwx(self) -> (D, C, D, A) { ... }
    fn wzwy(self) -> (D, C, D, B) { ... }
    fn wzwz(self) -> (D, C, D, C) { ... }
    fn wzww(self) -> (D, C, D, D) { ... }
    fn wwxx(self) -> (D, D, A, A) { ... }
    fn wwxy(self) -> (D, D, A, B) { ... }
    fn wwxz(self) -> (D, D, A, C) { ... }
    fn wwxw(self) -> (D, D, A, D) { ... }
    fn wwyx(self) -> (D, D, B, A) { ... }
    fn wwyy(self) -> (D, D, B, B) { ... }
    fn wwyz(self) -> (D, D, B, C) { ... }
    fn wwyw(self) -> (D, D, B, D) { ... }
    fn wwzx(self) -> (D, D, C, A) { ... }
    fn wwzy(self) -> (D, D, C, B) { ... }
    fn wwzz(self) -> (D, D, C, C) { ... }
    fn wwzw(self) -> (D, D, C, D) { ... }
    fn wwwx(self) -> (D, D, D, A) { ... }
    fn wwwy(self) -> (D, D, D, B) { ... }
    fn wwwz(self) -> (D, D, D, C) { ... }
    fn wwww(self) -> (D, D, D, D) { ... }
    fn r(self) -> A { ... }
    fn g(self) -> B { ... }
    fn b(self) -> C { ... }
    fn a(self) -> D { ... }
    fn rr(self) -> (A, A) { ... }
    fn rg(self) -> (A, B) { ... }
    fn rb(self) -> (A, C) { ... }
    fn ra(self) -> (A, D) { ... }
    fn gr(self) -> (B, A) { ... }
    fn gg(self) -> (B, B) { ... }
    fn gb(self) -> (B, C) { ... }
    fn ga(self) -> (B, D) { ... }
    fn br(self) -> (C, A) { ... }
    fn bg(self) -> (C, B) { ... }
    fn bb(self) -> (C, C) { ... }
    fn ba(self) -> (C, D) { ... }
    fn ar(self) -> (D, A) { ... }
    fn ag(self) -> (D, B) { ... }
    fn ab(self) -> (D, C) { ... }
    fn aa(self) -> (D, D) { ... }
    fn rrr(self) -> (A, A, A) { ... }
    fn rrg(self) -> (A, A, B) { ... }
    fn rrb(self) -> (A, A, C) { ... }
    fn rra(self) -> (A, A, D) { ... }
    fn rgr(self) -> (A, B, A) { ... }
    fn rgg(self) -> (A, B, B) { ... }
    fn rgb(self) -> (A, B, C) { ... }
    fn rga(self) -> (A, B, D) { ... }
    fn rbr(self) -> (A, C, A) { ... }
    fn rbg(self) -> (A, C, B) { ... }
    fn rbb(self) -> (A, C, C) { ... }
    fn rba(self) -> (A, C, D) { ... }
    fn rar(self) -> (A, D, A) { ... }
    fn rag(self) -> (A, D, B) { ... }
    fn rab(self) -> (A, D, C) { ... }
    fn raa(self) -> (A, D, D) { ... }
    fn grr(self) -> (B, A, A) { ... }
    fn grg(self) -> (B, A, B) { ... }
    fn grb(self) -> (B, A, C) { ... }
    fn gra(self) -> (B, A, D) { ... }
    fn ggr(self) -> (B, B, A) { ... }
    fn ggg(self) -> (B, B, B) { ... }
    fn ggb(self) -> (B, B, C) { ... }
    fn gga(self) -> (B, B, D) { ... }
    fn gbr(self) -> (B, C, A) { ... }
    fn gbg(self) -> (B, C, B) { ... }
    fn gbb(self) -> (B, C, C) { ... }
    fn gba(self) -> (B, C, D) { ... }
    fn gar(self) -> (B, D, A) { ... }
    fn gag(self) -> (B, D, B) { ... }
    fn gab(self) -> (B, D, C) { ... }
    fn gaa(self) -> (B, D, D) { ... }
    fn brr(self) -> (C, A, A) { ... }
    fn brg(self) -> (C, A, B) { ... }
    fn brb(self) -> (C, A, C) { ... }
    fn bra(self) -> (C, A, D) { ... }
    fn bgr(self) -> (C, B, A) { ... }
    fn bgg(self) -> (C, B, B) { ... }
    fn bgb(self) -> (C, B, C) { ... }
    fn bga(self) -> (C, B, D) { ... }
    fn bbr(self) -> (C, C, A) { ... }
    fn bbg(self) -> (C, C, B) { ... }
    fn bbb(self) -> (C, C, C) { ... }
    fn bba(self) -> (C, C, D) { ... }
    fn bar(self) -> (C, D, A) { ... }
    fn bag(self) -> (C, D, B) { ... }
    fn bab(self) -> (C, D, C) { ... }
    fn baa(self) -> (C, D, D) { ... }
    fn arr(self) -> (D, A, A) { ... }
    fn arg(self) -> (D, A, B) { ... }
    fn arb(self) -> (D, A, C) { ... }
    fn ara(self) -> (D, A, D) { ... }
    fn agr(self) -> (D, B, A) { ... }
    fn agg(self) -> (D, B, B) { ... }
    fn agb(self) -> (D, B, C) { ... }
    fn aga(self) -> (D, B, D) { ... }
    fn abr(self) -> (D, C, A) { ... }
    fn abg(self) -> (D, C, B) { ... }
    fn abb(self) -> (D, C, C) { ... }
    fn aba(self) -> (D, C, D) { ... }
    fn aar(self) -> (D, D, A) { ... }
    fn aag(self) -> (D, D, B) { ... }
    fn aab(self) -> (D, D, C) { ... }
    fn aaa(self) -> (D, D, D) { ... }
    fn rrrr(self) -> (A, A, A, A) { ... }
    fn rrrg(self) -> (A, A, A, B) { ... }
    fn rrrb(self) -> (A, A, A, C) { ... }
    fn rrra(self) -> (A, A, A, D) { ... }
    fn rrgr(self) -> (A, A, B, A) { ... }
    fn rrgg(self) -> (A, A, B, B) { ... }
    fn rrgb(self) -> (A, A, B, C) { ... }
    fn rrga(self) -> (A, A, B, D) { ... }
    fn rrbr(self) -> (A, A, C, A) { ... }
    fn rrbg(self) -> (A, A, C, B) { ... }
    fn rrbb(self) -> (A, A, C, C) { ... }
    fn rrba(self) -> (A, A, C, D) { ... }
    fn rrar(self) -> (A, A, D, A) { ... }
    fn rrag(self) -> (A, A, D, B) { ... }
    fn rrab(self) -> (A, A, D, C) { ... }
    fn rraa(self) -> (A, A, D, D) { ... }
    fn rgrr(self) -> (A, B, A, A) { ... }
    fn rgrg(self) -> (A, B, A, B) { ... }
    fn rgrb(self) -> (A, B, A, C) { ... }
    fn rgra(self) -> (A, B, A, D) { ... }
    fn rggr(self) -> (A, B, B, A) { ... }
    fn rggg(self) -> (A, B, B, B) { ... }
    fn rggb(self) -> (A, B, B, C) { ... }
    fn rgga(self) -> (A, B, B, D) { ... }
    fn rgbr(self) -> (A, B, C, A) { ... }
    fn rgbg(self) -> (A, B, C, B) { ... }
    fn rgbb(self) -> (A, B, C, C) { ... }
    fn rgba(self) -> (A, B, C, D) { ... }
    fn rgar(self) -> (A, B, D, A) { ... }
    fn rgag(self) -> (A, B, D, B) { ... }
    fn rgab(self) -> (A, B, D, C) { ... }
    fn rgaa(self) -> (A, B, D, D) { ... }
    fn rbrr(self) -> (A, C, A, A) { ... }
    fn rbrg(self) -> (A, C, A, B) { ... }
    fn rbrb(self) -> (A, C, A, C) { ... }
    fn rbra(self) -> (A, C, A, D) { ... }
    fn rbgr(self) -> (A, C, B, A) { ... }
    fn rbgg(self) -> (A, C, B, B) { ... }
    fn rbgb(self) -> (A, C, B, C) { ... }
    fn rbga(self) -> (A, C, B, D) { ... }
    fn rbbr(self) -> (A, C, C, A) { ... }
    fn rbbg(self) -> (A, C, C, B) { ... }
    fn rbbb(self) -> (A, C, C, C) { ... }
    fn rbba(self) -> (A, C, C, D) { ... }
    fn rbar(self) -> (A, C, D, A) { ... }
    fn rbag(self) -> (A, C, D, B) { ... }
    fn rbab(self) -> (A, C, D, C) { ... }
    fn rbaa(self) -> (A, C, D, D) { ... }
    fn rarr(self) -> (A, D, A, A) { ... }
    fn rarg(self) -> (A, D, A, B) { ... }
    fn rarb(self) -> (A, D, A, C) { ... }
    fn rara(self) -> (A, D, A, D) { ... }
    fn ragr(self) -> (A, D, B, A) { ... }
    fn ragg(self) -> (A, D, B, B) { ... }
    fn ragb(self) -> (A, D, B, C) { ... }
    fn raga(self) -> (A, D, B, D) { ... }
    fn rabr(self) -> (A, D, C, A) { ... }
    fn rabg(self) -> (A, D, C, B) { ... }
    fn rabb(self) -> (A, D, C, C) { ... }
    fn raba(self) -> (A, D, C, D) { ... }
    fn raar(self) -> (A, D, D, A) { ... }
    fn raag(self) -> (A, D, D, B) { ... }
    fn raab(self) -> (A, D, D, C) { ... }
    fn raaa(self) -> (A, D, D, D) { ... }
    fn grrr(self) -> (B, A, A, A) { ... }
    fn grrg(self) -> (B, A, A, B) { ... }
    fn grrb(self) -> (B, A, A, C) { ... }
    fn grra(self) -> (B, A, A, D) { ... }
    fn grgr(self) -> (B, A, B, A) { ... }
    fn grgg(self) -> (B, A, B, B) { ... }
    fn grgb(self) -> (B, A, B, C) { ... }
    fn grga(self) -> (B, A, B, D) { ... }
    fn grbr(self) -> (B, A, C, A) { ... }
    fn grbg(self) -> (B, A, C, B) { ... }
    fn grbb(self) -> (B, A, C, C) { ... }
    fn grba(self) -> (B, A, C, D) { ... }
    fn grar(self) -> (B, A, D, A) { ... }
    fn grag(self) -> (B, A, D, B) { ... }
    fn grab(self) -> (B, A, D, C) { ... }
    fn graa(self) -> (B, A, D, D) { ... }
    fn ggrr(self) -> (B, B, A, A) { ... }
    fn ggrg(self) -> (B, B, A, B) { ... }
    fn ggrb(self) -> (B, B, A, C) { ... }
    fn ggra(self) -> (B, B, A, D) { ... }
    fn gggr(self) -> (B, B, B, A) { ... }
    fn gggg(self) -> (B, B, B, B) { ... }
    fn gggb(self) -> (B, B, B, C) { ... }
    fn ggga(self) -> (B, B, B, D) { ... }
    fn ggbr(self) -> (B, B, C, A) { ... }
    fn ggbg(self) -> (B, B, C, B) { ... }
    fn ggbb(self) -> (B, B, C, C) { ... }
    fn ggba(self) -> (B, B, C, D) { ... }
    fn ggar(self) -> (B, B, D, A) { ... }
    fn ggag(self) -> (B, B, D, B) { ... }
    fn ggab(self) -> (B, B, D, C) { ... }
    fn ggaa(self) -> (B, B, D, D) { ... }
    fn gbrr(self) -> (B, C, A, A) { ... }
    fn gbrg(self) -> (B, C, A, B) { ... }
    fn gbrb(self) -> (B, C, A, C) { ... }
    fn gbra(self) -> (B, C, A, D) { ... }
    fn gbgr(self) -> (B, C, B, A) { ... }
    fn gbgg(self) -> (B, C, B, B) { ... }
    fn gbgb(self) -> (B, C, B, C) { ... }
    fn gbga(self) -> (B, C, B, D) { ... }
    fn gbbr(self) -> (B, C, C, A) { ... }
    fn gbbg(self) -> (B, C, C, B) { ... }
    fn gbbb(self) -> (B, C, C, C) { ... }
    fn gbba(self) -> (B, C, C, D) { ... }
    fn gbar(self) -> (B, C, D, A) { ... }
    fn gbag(self) -> (B, C, D, B) { ... }
    fn gbab(self) -> (B, C, D, C) { ... }
    fn gbaa(self) -> (B, C, D, D) { ... }
    fn garr(self) -> (B, D, A, A) { ... }
    fn garg(self) -> (B, D, A, B) { ... }
    fn garb(self) -> (B, D, A, C) { ... }
    fn gara(self) -> (B, D, A, D) { ... }
    fn gagr(self) -> (B, D, B, A) { ... }
    fn gagg(self) -> (B, D, B, B) { ... }
    fn gagb(self) -> (B, D, B, C) { ... }
    fn gaga(self) -> (B, D, B, D) { ... }
    fn gabr(self) -> (B, D, C, A) { ... }
    fn gabg(self) -> (B, D, C, B) { ... }
    fn gabb(self) -> (B, D, C, C) { ... }
    fn gaba(self) -> (B, D, C, D) { ... }
    fn gaar(self) -> (B, D, D, A) { ... }
    fn gaag(self) -> (B, D, D, B) { ... }
    fn gaab(self) -> (B, D, D, C) { ... }
    fn gaaa(self) -> (B, D, D, D) { ... }
    fn brrr(self) -> (C, A, A, A) { ... }
    fn brrg(self) -> (C, A, A, B) { ... }
    fn brrb(self) -> (C, A, A, C) { ... }
    fn brra(self) -> (C, A, A, D) { ... }
    fn brgr(self) -> (C, A, B, A) { ... }
    fn brgg(self) -> (C, A, B, B) { ... }
    fn brgb(self) -> (C, A, B, C) { ... }
    fn brga(self) -> (C, A, B, D) { ... }
    fn brbr(self) -> (C, A, C, A) { ... }
    fn brbg(self) -> (C, A, C, B) { ... }
    fn brbb(self) -> (C, A, C, C) { ... }
    fn brba(self) -> (C, A, C, D) { ... }
    fn brar(self) -> (C, A, D, A) { ... }
    fn brag(self) -> (C, A, D, B) { ... }
    fn brab(self) -> (C, A, D, C) { ... }
    fn braa(self) -> (C, A, D, D) { ... }
    fn bgrr(self) -> (C, B, A, A) { ... }
    fn bgrg(self) -> (C, B, A, B) { ... }
    fn bgrb(self) -> (C, B, A, C) { ... }
    fn bgra(self) -> (C, B, A, D) { ... }
    fn bggr(self) -> (C, B, B, A) { ... }
    fn bggg(self) -> (C, B, B, B) { ... }
    fn bggb(self) -> (C, B, B, C) { ... }
    fn bgga(self) -> (C, B, B, D) { ... }
    fn bgbr(self) -> (C, B, C, A) { ... }
    fn bgbg(self) -> (C, B, C, B) { ... }
    fn bgbb(self) -> (C, B, C, C) { ... }
    fn bgba(self) -> (C, B, C, D) { ... }
    fn bgar(self) -> (C, B, D, A) { ... }
    fn bgag(self) -> (C, B, D, B) { ... }
    fn bgab(self) -> (C, B, D, C) { ... }
    fn bgaa(self) -> (C, B, D, D) { ... }
    fn bbrr(self) -> (C, C, A, A) { ... }
    fn bbrg(self) -> (C, C, A, B) { ... }
    fn bbrb(self) -> (C, C, A, C) { ... }
    fn bbra(self) -> (C, C, A, D) { ... }
    fn bbgr(self) -> (C, C, B, A) { ... }
    fn bbgg(self) -> (C, C, B, B) { ... }
    fn bbgb(self) -> (C, C, B, C) { ... }
    fn bbga(self) -> (C, C, B, D) { ... }
    fn bbbr(self) -> (C, C, C, A) { ... }
    fn bbbg(self) -> (C, C, C, B) { ... }
    fn bbbb(self) -> (C, C, C, C) { ... }
    fn bbba(self) -> (C, C, C, D) { ... }
    fn bbar(self) -> (C, C, D, A) { ... }
    fn bbag(self) -> (C, C, D, B) { ... }
    fn bbab(self) -> (C, C, D, C) { ... }
    fn bbaa(self) -> (C, C, D, D) { ... }
    fn barr(self) -> (C, D, A, A) { ... }
    fn barg(self) -> (C, D, A, B) { ... }
    fn barb(self) -> (C, D, A, C) { ... }
    fn bara(self) -> (C, D, A, D) { ... }
    fn bagr(self) -> (C, D, B, A) { ... }
    fn bagg(self) -> (C, D, B, B) { ... }
    fn bagb(self) -> (C, D, B, C) { ... }
    fn baga(self) -> (C, D, B, D) { ... }
    fn babr(self) -> (C, D, C, A) { ... }
    fn babg(self) -> (C, D, C, B) { ... }
    fn babb(self) -> (C, D, C, C) { ... }
    fn baba(self) -> (C, D, C, D) { ... }
    fn baar(self) -> (C, D, D, A) { ... }
    fn baag(self) -> (C, D, D, B) { ... }
    fn baab(self) -> (C, D, D, C) { ... }
    fn baaa(self) -> (C, D, D, D) { ... }
    fn arrr(self) -> (D, A, A, A) { ... }
    fn arrg(self) -> (D, A, A, B) { ... }
    fn arrb(self) -> (D, A, A, C) { ... }
    fn arra(self) -> (D, A, A, D) { ... }
    fn argr(self) -> (D, A, B, A) { ... }
    fn argg(self) -> (D, A, B, B) { ... }
    fn argb(self) -> (D, A, B, C) { ... }
    fn arga(self) -> (D, A, B, D) { ... }
    fn arbr(self) -> (D, A, C, A) { ... }
    fn arbg(self) -> (D, A, C, B) { ... }
    fn arbb(self) -> (D, A, C, C) { ... }
    fn arba(self) -> (D, A, C, D) { ... }
    fn arar(self) -> (D, A, D, A) { ... }
    fn arag(self) -> (D, A, D, B) { ... }
    fn arab(self) -> (D, A, D, C) { ... }
    fn araa(self) -> (D, A, D, D) { ... }
    fn agrr(self) -> (D, B, A, A) { ... }
    fn agrg(self) -> (D, B, A, B) { ... }
    fn agrb(self) -> (D, B, A, C) { ... }
    fn agra(self) -> (D, B, A, D) { ... }
    fn aggr(self) -> (D, B, B, A) { ... }
    fn aggg(self) -> (D, B, B, B) { ... }
    fn aggb(self) -> (D, B, B, C) { ... }
    fn agga(self) -> (D, B, B, D) { ... }
    fn agbr(self) -> (D, B, C, A) { ... }
    fn agbg(self) -> (D, B, C, B) { ... }
    fn agbb(self) -> (D, B, C, C) { ... }
    fn agba(self) -> (D, B, C, D) { ... }
    fn agar(self) -> (D, B, D, A) { ... }
    fn agag(self) -> (D, B, D, B) { ... }
    fn agab(self) -> (D, B, D, C) { ... }
    fn agaa(self) -> (D, B, D, D) { ... }
    fn abrr(self) -> (D, C, A, A) { ... }
    fn abrg(self) -> (D, C, A, B) { ... }
    fn abrb(self) -> (D, C, A, C) { ... }
    fn abra(self) -> (D, C, A, D) { ... }
    fn abgr(self) -> (D, C, B, A) { ... }
    fn abgg(self) -> (D, C, B, B) { ... }
    fn abgb(self) -> (D, C, B, C) { ... }
    fn abga(self) -> (D, C, B, D) { ... }
    fn abbr(self) -> (D, C, C, A) { ... }
    fn abbg(self) -> (D, C, C, B) { ... }
    fn abbb(self) -> (D, C, C, C) { ... }
    fn abba(self) -> (D, C, C, D) { ... }
    fn abar(self) -> (D, C, D, A) { ... }
    fn abag(self) -> (D, C, D, B) { ... }
    fn abab(self) -> (D, C, D, C) { ... }
    fn abaa(self) -> (D, C, D, D) { ... }
    fn aarr(self) -> (D, D, A, A) { ... }
    fn aarg(self) -> (D, D, A, B) { ... }
    fn aarb(self) -> (D, D, A, C) { ... }
    fn aara(self) -> (D, D, A, D) { ... }
    fn aagr(self) -> (D, D, B, A) { ... }
    fn aagg(self) -> (D, D, B, B) { ... }
    fn aagb(self) -> (D, D, B, C) { ... }
    fn aaga(self) -> (D, D, B, D) { ... }
    fn aabr(self) -> (D, D, C, A) { ... }
    fn aabg(self) -> (D, D, C, B) { ... }
    fn aabb(self) -> (D, D, C, C) { ... }
    fn aaba(self) -> (D, D, C, D) { ... }
    fn aaar(self) -> (D, D, D, A) { ... }
    fn aaag(self) -> (D, D, D, B) { ... }
    fn aaab(self) -> (D, D, D, C) { ... }
    fn aaaa(self) -> (D, D, D, D) { ... }
}
Required Methods§

source
fn s(self) -> (A, B, C, D)

Provided Methods§

source
fn aaaa(self) -> (D, D, D, D)

Object Safety§

This trait is not object safe.
Implementations on Foreign Types§

source §
impl<A: Copy, B: Copy, C: Copy, D: Copy> TupleSwizzle4<A, B, C, D> for (A, B, C, D)

source §
fn s(self) -> (A, B, C, D)

source §
impl<T: Copy> TupleSwizzle4<T, T, T, T> for [T; 4]

source §
Trait grafix_toolbox::lib::tuple::TupleSwizzle4Copy item path

Required Methods§

fn s(self) -> (A, B, C, D)

Provided Methods§

fn x(self) -> A

fn y(self) -> B

fn z(self) -> C

fn w(self) -> D

fn xx(self) -> (A, A)

fn xy(self) -> (A, B)

fn xz(self) -> (A, C)

fn xw(self) -> (A, D)

fn yx(self) -> (B, A)

fn yy(self) -> (B, B)

fn yz(self) -> (B, C)

fn yw(self) -> (B, D)

fn zx(self) -> (C, A)

fn zy(self) -> (C, B)

fn zz(self) -> (C, C)

fn zw(self) -> (C, D)

fn wx(self) -> (D, A)

fn wy(self) -> (D, B)

fn wz(self) -> (D, C)

fn ww(self) -> (D, D)

fn xxx(self) -> (A, A, A)

fn xxy(self) -> (A, A, B)

fn xxz(self) -> (A, A, C)

fn xxw(self) -> (A, A, D)

fn xyx(self) -> (A, B, A)

fn xyy(self) -> (A, B, B)

fn xyz(self) -> (A, B, C)

fn xyw(self) -> (A, B, D)

fn xzx(self) -> (A, C, A)

fn xzy(self) -> (A, C, B)

fn xzz(self) -> (A, C, C)

fn xzw(self) -> (A, C, D)

fn xwx(self) -> (A, D, A)

fn xwy(self) -> (A, D, B)

fn xwz(self) -> (A, D, C)

fn xww(self) -> (A, D, D)

fn yxx(self) -> (B, A, A)

fn yxy(self) -> (B, A, B)

fn yxz(self) -> (B, A, C)

fn yxw(self) -> (B, A, D)

fn yyx(self) -> (B, B, A)

fn yyy(self) -> (B, B, B)

fn yyz(self) -> (B, B, C)

fn yyw(self) -> (B, B, D)

fn yzx(self) -> (B, C, A)

fn yzy(self) -> (B, C, B)

fn yzz(self) -> (B, C, C)

fn yzw(self) -> (B, C, D)

fn ywx(self) -> (B, D, A)

fn ywy(self) -> (B, D, B)

fn ywz(self) -> (B, D, C)

fn yww(self) -> (B, D, D)

fn zxx(self) -> (C, A, A)

fn zxy(self) -> (C, A, B)

fn zxz(self) -> (C, A, C)

fn zxw(self) -> (C, A, D)

fn zyx(self) -> (C, B, A)

fn zyy(self) -> (C, B, B)

fn zyz(self) -> (C, B, C)

fn zyw(self) -> (C, B, D)

fn zzx(self) -> (C, C, A)

fn zzy(self) -> (C, C, B)

fn zzz(self) -> (C, C, C)

fn zzw(self) -> (C, C, D)

fn zwx(self) -> (C, D, A)

fn zwy(self) -> (C, D, B)

fn zwz(self) -> (C, D, C)

fn zww(self) -> (C, D, D)

fn wxx(self) -> (D, A, A)

fn wxy(self) -> (D, A, B)

fn wxz(self) -> (D, A, C)

fn wxw(self) -> (D, A, D)

fn wyx(self) -> (D, B, A)

fn wyy(self) -> (D, B, B)

fn wyz(self) -> (D, B, C)

fn wyw(self) -> (D, B, D)

Trait grafix_toolbox::lib::tuple::TupleSwizzle4
