[−][src]Trait tuple_swizzle::swizzle::TupleSwizzle4

pub trait TupleSwizzle4<A, B, C, D> {
    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

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)

Loading content...

Implementations on Foreign Types

impl<A: Copy, B: Copy, C: Copy, D: Copy> TupleSwizzle4<A, B, C, D> for (A, B, C, D)[src]

Loading content...

Implementors

Loading content...