object_rainbow/impls/
tuple.rs

1use typenum::tarr;
2
3use crate::*;
4
5impl<A: ToOutput, B: ToOutput> ToOutput for (A, B) {
6    fn to_output(&self, output: &mut dyn Output) {
7        self.0.to_output(output);
8        self.1.to_output(output);
9    }
10}
11
12impl<Extra: 'static, A: Topological<Extra>, B: Topological<Extra>> Topological<Extra> for (A, B) {
13    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
14        self.0.accept_points(visitor);
15        self.1.accept_points(visitor);
16    }
17}
18
19impl<A: Tagged, B: Tagged> Tagged for (A, B) {
20    const TAGS: Tags = Tags(&[], &[&A::TAGS, &B::TAGS]);
21}
22
23impl<Extra: 'static, A: Inline<Extra>, B: Object<Extra>> Object<Extra> for (A, B) {}
24
25impl<Extra: 'static, A: Inline<Extra>, B: Inline<Extra>> Inline<Extra> for (A, B) {}
26
27impl<A: ReflessInline, B: ReflessObject> ReflessObject for (A, B) {}
28
29impl<A: ReflessInline, B: ReflessInline> ReflessInline for (A, B) {}
30
31impl<A: Size, B: Size> Size for (A, B)
32where
33    tarr![A::Size, B::Size,]: typenum::FoldAdd<Output: Unsigned>,
34{
35    const SIZE: usize = A::SIZE + B::SIZE;
36
37    type Size = <tarr![A::Size, B::Size,] as typenum::FoldAdd>::Output;
38}
39
40impl<II: ParseInput, A: ParseInline<II>, B: Parse<II>> Parse<II> for (A, B) {
41    fn parse(mut input: II) -> crate::Result<Self> {
42        Ok((input.parse_inline()?, input.parse()?))
43    }
44}
45
46impl<II: ParseInput, A: ParseInline<II>, B: ParseInline<II>> ParseInline<II> for (A, B) {
47    fn parse_inline(input: &mut II) -> crate::Result<Self> {
48        Ok((input.parse_inline()?, input.parse_inline()?))
49    }
50}
51
52impl<A: MaybeHasNiche, B: MaybeHasNiche> MaybeHasNiche for (A, B) {
53    type MnArray = tarr![A::MnArray, B::MnArray,];
54}
55
56impl<A: ToOutput, B: ToOutput, C: ToOutput> ToOutput for (A, B, C) {
57    fn to_output(&self, output: &mut dyn Output) {
58        self.0.to_output(output);
59        self.1.to_output(output);
60        self.2.to_output(output);
61    }
62}
63
64impl<Extra: 'static, A: Topological<Extra>, B: Topological<Extra>, C: Topological<Extra>>
65    Topological<Extra> for (A, B, C)
66{
67    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
68        self.0.accept_points(visitor);
69        self.1.accept_points(visitor);
70        self.2.accept_points(visitor);
71    }
72}
73
74impl<A: Tagged, B: Tagged, C: Tagged> Tagged for (A, B, C) {
75    const TAGS: Tags = Tags(&[], &[&A::TAGS, &B::TAGS, &C::TAGS]);
76}
77
78impl<Extra: 'static, A: Inline<Extra>, B: Inline<Extra>, C: Object<Extra>> Object<Extra>
79    for (A, B, C)
80{
81}
82
83impl<Extra: 'static, A: Inline<Extra>, B: Inline<Extra>, C: Inline<Extra>> Inline<Extra>
84    for (A, B, C)
85{
86}
87
88impl<A: ReflessInline, B: ReflessInline, C: ReflessObject> ReflessObject for (A, B, C) {}
89
90impl<A: ReflessInline, B: ReflessInline, C: ReflessInline> ReflessInline for (A, B, C) {}
91
92impl<A: Size, B: Size, C: Size> Size for (A, B, C)
93where
94    tarr![A::Size, B::Size, C::Size,]: typenum::FoldAdd<Output: Unsigned>,
95{
96    const SIZE: usize = A::SIZE + B::SIZE + C::SIZE;
97
98    type Size = <tarr![A::Size, B::Size, C::Size,] as typenum::FoldAdd>::Output;
99}
100
101impl<II: ParseInput, A: ParseInline<II>, B: ParseInline<II>, C: Parse<II>> Parse<II> for (A, B, C) {
102    fn parse(mut input: II) -> crate::Result<Self> {
103        Ok((input.parse_inline()?, input.parse_inline()?, input.parse()?))
104    }
105}
106
107impl<II: ParseInput, A: ParseInline<II>, B: ParseInline<II>, C: ParseInline<II>> ParseInline<II>
108    for (A, B, C)
109{
110    fn parse_inline(input: &mut II) -> crate::Result<Self> {
111        Ok((
112            input.parse_inline()?,
113            input.parse_inline()?,
114            input.parse_inline()?,
115        ))
116    }
117}
118
119impl<A: MaybeHasNiche, B: MaybeHasNiche, C: MaybeHasNiche> MaybeHasNiche for (A, B, C) {
120    type MnArray = tarr![A::MnArray, B::MnArray, C::MnArray,];
121}
122
123impl<A: ToOutput, B: ToOutput, C: ToOutput, D: ToOutput> ToOutput for (A, B, C, D) {
124    fn to_output(&self, output: &mut dyn Output) {
125        self.0.to_output(output);
126        self.1.to_output(output);
127        self.2.to_output(output);
128        self.3.to_output(output);
129    }
130}
131
132impl<
133    Extra: 'static,
134    A: Topological<Extra>,
135    B: Topological<Extra>,
136    C: Topological<Extra>,
137    D: Topological<Extra>,
138> Topological<Extra> for (A, B, C, D)
139{
140    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
141        self.0.accept_points(visitor);
142        self.1.accept_points(visitor);
143        self.2.accept_points(visitor);
144        self.3.accept_points(visitor);
145    }
146}
147
148impl<A: Tagged, B: Tagged, C: Tagged, D: Tagged> Tagged for (A, B, C, D) {
149    const TAGS: Tags = Tags(&[], &[&A::TAGS, &B::TAGS, &C::TAGS, &D::TAGS]);
150}
151
152impl<Extra: 'static, A: Inline<Extra>, B: Inline<Extra>, C: Inline<Extra>, D: Object<Extra>>
153    Object<Extra> for (A, B, C, D)
154{
155}
156
157impl<Extra: 'static, A: Inline<Extra>, B: Inline<Extra>, C: Inline<Extra>, D: Inline<Extra>>
158    Inline<Extra> for (A, B, C, D)
159{
160}
161
162impl<A: ReflessInline, B: ReflessInline, C: ReflessInline, D: ReflessObject> ReflessObject
163    for (A, B, C, D)
164{
165}
166
167impl<A: ReflessInline, B: ReflessInline, C: ReflessInline, D: ReflessInline> ReflessInline
168    for (A, B, C, D)
169{
170}
171
172impl<A: Size, B: Size, C: Size, D: Size> Size for (A, B, C, D)
173where
174    tarr![A::Size, B::Size, C::Size, D::Size,]: typenum::FoldAdd<Output: Unsigned>,
175{
176    const SIZE: usize = A::SIZE + B::SIZE + C::SIZE + D::SIZE;
177
178    type Size = <tarr![A::Size, B::Size, C::Size, D::Size,] as typenum::FoldAdd>::Output;
179}
180
181impl<II: ParseInput, A: ParseInline<II>, B: ParseInline<II>, C: ParseInline<II>, D: Parse<II>>
182    Parse<II> for (A, B, C, D)
183{
184    fn parse(mut input: II) -> crate::Result<Self> {
185        Ok((
186            input.parse_inline()?,
187            input.parse_inline()?,
188            input.parse_inline()?,
189            input.parse()?,
190        ))
191    }
192}
193
194impl<II: ParseInput, A: ParseInline<II>, B: ParseInline<II>, C: ParseInline<II>, D: ParseInline<II>>
195    ParseInline<II> for (A, B, C, D)
196{
197    fn parse_inline(input: &mut II) -> crate::Result<Self> {
198        Ok((
199            input.parse_inline()?,
200            input.parse_inline()?,
201            input.parse_inline()?,
202            input.parse_inline()?,
203        ))
204    }
205}
206
207impl<A: MaybeHasNiche, B: MaybeHasNiche, C: MaybeHasNiche, D: MaybeHasNiche> MaybeHasNiche
208    for (A, B, C, D)
209{
210    type MnArray = tarr![A::MnArray, B::MnArray, C::MnArray, D::MnArray,];
211}
212
213impl<A: ToOutput, B: ToOutput, C: ToOutput, D: ToOutput, E: ToOutput> ToOutput for (A, B, C, D, E) {
214    fn to_output(&self, output: &mut dyn Output) {
215        self.0.to_output(output);
216        self.1.to_output(output);
217        self.2.to_output(output);
218        self.3.to_output(output);
219        self.4.to_output(output);
220    }
221}
222
223impl<
224    Extra: 'static,
225    A: Topological<Extra>,
226    B: Topological<Extra>,
227    C: Topological<Extra>,
228    D: Topological<Extra>,
229    E: Topological<Extra>,
230> Topological<Extra> for (A, B, C, D, E)
231{
232    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
233        self.0.accept_points(visitor);
234        self.1.accept_points(visitor);
235        self.2.accept_points(visitor);
236        self.3.accept_points(visitor);
237        self.4.accept_points(visitor);
238    }
239}
240
241impl<A: Tagged, B: Tagged, C: Tagged, D: Tagged, E: Tagged> Tagged for (A, B, C, D, E) {
242    const TAGS: Tags = Tags(&[], &[&A::TAGS, &B::TAGS, &C::TAGS, &D::TAGS, &E::TAGS]);
243}
244
245impl<
246    Extra: 'static,
247    A: Inline<Extra>,
248    B: Inline<Extra>,
249    C: Inline<Extra>,
250    D: Inline<Extra>,
251    E: Object<Extra>,
252> Object<Extra> for (A, B, C, D, E)
253{
254}
255
256impl<
257    Extra: 'static,
258    A: Inline<Extra>,
259    B: Inline<Extra>,
260    C: Inline<Extra>,
261    D: Inline<Extra>,
262    E: Inline<Extra>,
263> Inline<Extra> for (A, B, C, D, E)
264{
265}
266
267impl<A: ReflessInline, B: ReflessInline, C: ReflessInline, D: ReflessInline, E: ReflessObject>
268    ReflessObject for (A, B, C, D, E)
269{
270}
271
272impl<A: ReflessInline, B: ReflessInline, C: ReflessInline, D: ReflessInline, E: ReflessInline>
273    ReflessInline for (A, B, C, D, E)
274{
275}
276
277impl<A: Size, B: Size, C: Size, D: Size, E: Size> Size for (A, B, C, D, E)
278where
279    tarr![A::Size, B::Size, C::Size, D::Size, E::Size,]: typenum::FoldAdd<Output: Unsigned>,
280{
281    const SIZE: usize = A::SIZE + B::SIZE + C::SIZE + D::SIZE + E::SIZE;
282
283    type Size = <tarr![A::Size, B::Size, C::Size, D::Size, E::Size,] as typenum::FoldAdd>::Output;
284}
285
286impl<
287    II: ParseInput,
288    A: ParseInline<II>,
289    B: ParseInline<II>,
290    C: ParseInline<II>,
291    D: ParseInline<II>,
292    E: Parse<II>,
293> Parse<II> for (A, B, C, D, E)
294{
295    fn parse(mut input: II) -> crate::Result<Self> {
296        Ok((
297            input.parse_inline()?,
298            input.parse_inline()?,
299            input.parse_inline()?,
300            input.parse_inline()?,
301            input.parse()?,
302        ))
303    }
304}
305
306impl<
307    II: ParseInput,
308    A: ParseInline<II>,
309    B: ParseInline<II>,
310    C: ParseInline<II>,
311    D: ParseInline<II>,
312    E: ParseInline<II>,
313> ParseInline<II> for (A, B, C, D, E)
314{
315    fn parse_inline(input: &mut II) -> crate::Result<Self> {
316        Ok((
317            input.parse_inline()?,
318            input.parse_inline()?,
319            input.parse_inline()?,
320            input.parse_inline()?,
321            input.parse_inline()?,
322        ))
323    }
324}
325
326impl<A: MaybeHasNiche, B: MaybeHasNiche, C: MaybeHasNiche, D: MaybeHasNiche, E: MaybeHasNiche>
327    MaybeHasNiche for (A, B, C, D, E)
328{
329    type MnArray = tarr![A::MnArray, B::MnArray, C::MnArray, D::MnArray, E::MnArray,];
330}
331
332impl<A: ToOutput, B: ToOutput, C: ToOutput, D: ToOutput, E: ToOutput, F: ToOutput> ToOutput
333    for (A, B, C, D, E, F)
334{
335    fn to_output(&self, output: &mut dyn Output) {
336        self.0.to_output(output);
337        self.1.to_output(output);
338        self.2.to_output(output);
339        self.3.to_output(output);
340        self.4.to_output(output);
341        self.5.to_output(output);
342    }
343}
344
345impl<
346    Extra: 'static,
347    A: Topological<Extra>,
348    B: Topological<Extra>,
349    C: Topological<Extra>,
350    D: Topological<Extra>,
351    E: Topological<Extra>,
352    F: Topological<Extra>,
353> Topological<Extra> for (A, B, C, D, E, F)
354{
355    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
356        self.0.accept_points(visitor);
357        self.1.accept_points(visitor);
358        self.2.accept_points(visitor);
359        self.3.accept_points(visitor);
360        self.4.accept_points(visitor);
361        self.5.accept_points(visitor);
362    }
363}
364
365impl<A: Tagged, B: Tagged, C: Tagged, D: Tagged, E: Tagged, F: Tagged> Tagged
366    for (A, B, C, D, E, F)
367{
368    const TAGS: Tags = Tags(
369        &[],
370        &[&A::TAGS, &B::TAGS, &C::TAGS, &D::TAGS, &E::TAGS, &F::TAGS],
371    );
372}
373
374impl<
375    Extra: 'static,
376    A: Inline<Extra>,
377    B: Inline<Extra>,
378    C: Inline<Extra>,
379    D: Inline<Extra>,
380    E: Inline<Extra>,
381    F: Object<Extra>,
382> Object<Extra> for (A, B, C, D, E, F)
383{
384}
385
386impl<
387    Extra: 'static,
388    A: Inline<Extra>,
389    B: Inline<Extra>,
390    C: Inline<Extra>,
391    D: Inline<Extra>,
392    E: Inline<Extra>,
393    F: Inline<Extra>,
394> Inline<Extra> for (A, B, C, D, E, F)
395{
396}
397
398impl<
399    A: ReflessInline,
400    B: ReflessInline,
401    C: ReflessInline,
402    D: ReflessInline,
403    E: ReflessInline,
404    F: ReflessObject,
405> ReflessObject for (A, B, C, D, E, F)
406{
407}
408
409impl<
410    A: ReflessInline,
411    B: ReflessInline,
412    C: ReflessInline,
413    D: ReflessInline,
414    E: ReflessInline,
415    F: ReflessInline,
416> ReflessInline for (A, B, C, D, E, F)
417{
418}
419
420impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size> Size for (A, B, C, D, E, F)
421where
422    tarr![A::Size, B::Size, C::Size, D::Size, E::Size, F::Size,]:
423        typenum::FoldAdd<Output: Unsigned>,
424{
425    const SIZE: usize = A::SIZE + B::SIZE + C::SIZE + D::SIZE + E::SIZE + F::SIZE;
426
427    type Size =
428        <tarr![A::Size, B::Size, C::Size, D::Size, E::Size, F::Size,] as typenum::FoldAdd>::Output;
429}
430
431impl<
432    II: ParseInput,
433    A: ParseInline<II>,
434    B: ParseInline<II>,
435    C: ParseInline<II>,
436    D: ParseInline<II>,
437    E: ParseInline<II>,
438    F: Parse<II>,
439> Parse<II> for (A, B, C, D, E, F)
440{
441    fn parse(mut input: II) -> crate::Result<Self> {
442        Ok((
443            input.parse_inline()?,
444            input.parse_inline()?,
445            input.parse_inline()?,
446            input.parse_inline()?,
447            input.parse_inline()?,
448            input.parse()?,
449        ))
450    }
451}
452
453impl<
454    II: ParseInput,
455    A: ParseInline<II>,
456    B: ParseInline<II>,
457    C: ParseInline<II>,
458    D: ParseInline<II>,
459    E: ParseInline<II>,
460    F: ParseInline<II>,
461> ParseInline<II> for (A, B, C, D, E, F)
462{
463    fn parse_inline(input: &mut II) -> crate::Result<Self> {
464        Ok((
465            input.parse_inline()?,
466            input.parse_inline()?,
467            input.parse_inline()?,
468            input.parse_inline()?,
469            input.parse_inline()?,
470            input.parse_inline()?,
471        ))
472    }
473}
474
475impl<
476    A: MaybeHasNiche,
477    B: MaybeHasNiche,
478    C: MaybeHasNiche,
479    D: MaybeHasNiche,
480    E: MaybeHasNiche,
481    F: MaybeHasNiche,
482> MaybeHasNiche for (A, B, C, D, E, F)
483{
484    type MnArray = tarr![
485        A::MnArray,
486        B::MnArray,
487        C::MnArray,
488        D::MnArray,
489        E::MnArray,
490        F::MnArray,
491    ];
492}
493
494impl<A: ToOutput, B: ToOutput, C: ToOutput, D: ToOutput, E: ToOutput, F: ToOutput, G: ToOutput>
495    ToOutput for (A, B, C, D, E, F, G)
496{
497    fn to_output(&self, output: &mut dyn Output) {
498        self.0.to_output(output);
499        self.1.to_output(output);
500        self.2.to_output(output);
501        self.3.to_output(output);
502        self.4.to_output(output);
503        self.5.to_output(output);
504        self.6.to_output(output);
505    }
506}
507
508impl<
509    Extra: 'static,
510    A: Topological<Extra>,
511    B: Topological<Extra>,
512    C: Topological<Extra>,
513    D: Topological<Extra>,
514    E: Topological<Extra>,
515    F: Topological<Extra>,
516    G: Topological<Extra>,
517> Topological<Extra> for (A, B, C, D, E, F, G)
518{
519    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
520        self.0.accept_points(visitor);
521        self.1.accept_points(visitor);
522        self.2.accept_points(visitor);
523        self.3.accept_points(visitor);
524        self.4.accept_points(visitor);
525        self.5.accept_points(visitor);
526        self.6.accept_points(visitor);
527    }
528}
529
530impl<A: Tagged, B: Tagged, C: Tagged, D: Tagged, E: Tagged, F: Tagged, G: Tagged> Tagged
531    for (A, B, C, D, E, F, G)
532{
533    const TAGS: Tags = Tags(
534        &[],
535        &[
536            &A::TAGS,
537            &B::TAGS,
538            &C::TAGS,
539            &D::TAGS,
540            &E::TAGS,
541            &F::TAGS,
542            &G::TAGS,
543        ],
544    );
545}
546
547impl<
548    Extra: 'static,
549    A: Inline<Extra>,
550    B: Inline<Extra>,
551    C: Inline<Extra>,
552    D: Inline<Extra>,
553    E: Inline<Extra>,
554    F: Inline<Extra>,
555    G: Object<Extra>,
556> Object<Extra> for (A, B, C, D, E, F, G)
557{
558}
559
560impl<
561    Extra: 'static,
562    A: Inline<Extra>,
563    B: Inline<Extra>,
564    C: Inline<Extra>,
565    D: Inline<Extra>,
566    E: Inline<Extra>,
567    F: Inline<Extra>,
568    G: Inline<Extra>,
569> Inline<Extra> for (A, B, C, D, E, F, G)
570{
571}
572
573impl<
574    A: ReflessInline,
575    B: ReflessInline,
576    C: ReflessInline,
577    D: ReflessInline,
578    E: ReflessInline,
579    F: ReflessInline,
580    G: ReflessObject,
581> ReflessObject for (A, B, C, D, E, F, G)
582{
583}
584
585impl<
586    A: ReflessInline,
587    B: ReflessInline,
588    C: ReflessInline,
589    D: ReflessInline,
590    E: ReflessInline,
591    F: ReflessInline,
592    G: ReflessInline,
593> ReflessInline for (A, B, C, D, E, F, G)
594{
595}
596
597impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size, G: Size> Size for (A, B, C, D, E, F, G)
598where
599    tarr![
600        A::Size,
601        B::Size,
602        C::Size,
603        D::Size,
604        E::Size,
605        F::Size,
606        G::Size,
607    ]: typenum::FoldAdd<Output: Unsigned>,
608{
609    const SIZE: usize = A::SIZE + B::SIZE + C::SIZE + D::SIZE + E::SIZE + F::SIZE + G::SIZE;
610
611    type Size = <tarr![
612        A::Size,
613        B::Size,
614        C::Size,
615        D::Size,
616        E::Size,
617        F::Size,
618        G::Size,
619    ] as typenum::FoldAdd>::Output;
620}
621
622impl<
623    II: ParseInput,
624    A: ParseInline<II>,
625    B: ParseInline<II>,
626    C: ParseInline<II>,
627    D: ParseInline<II>,
628    E: ParseInline<II>,
629    F: ParseInline<II>,
630    G: Parse<II>,
631> Parse<II> for (A, B, C, D, E, F, G)
632{
633    fn parse(mut input: II) -> crate::Result<Self> {
634        Ok((
635            input.parse_inline()?,
636            input.parse_inline()?,
637            input.parse_inline()?,
638            input.parse_inline()?,
639            input.parse_inline()?,
640            input.parse_inline()?,
641            input.parse()?,
642        ))
643    }
644}
645
646impl<
647    II: ParseInput,
648    A: ParseInline<II>,
649    B: ParseInline<II>,
650    C: ParseInline<II>,
651    D: ParseInline<II>,
652    E: ParseInline<II>,
653    F: ParseInline<II>,
654    G: ParseInline<II>,
655> ParseInline<II> for (A, B, C, D, E, F, G)
656{
657    fn parse_inline(input: &mut II) -> crate::Result<Self> {
658        Ok((
659            input.parse_inline()?,
660            input.parse_inline()?,
661            input.parse_inline()?,
662            input.parse_inline()?,
663            input.parse_inline()?,
664            input.parse_inline()?,
665            input.parse_inline()?,
666        ))
667    }
668}
669
670impl<
671    A: MaybeHasNiche,
672    B: MaybeHasNiche,
673    C: MaybeHasNiche,
674    D: MaybeHasNiche,
675    E: MaybeHasNiche,
676    F: MaybeHasNiche,
677    G: MaybeHasNiche,
678> MaybeHasNiche for (A, B, C, D, E, F, G)
679{
680    type MnArray = tarr![
681        A::MnArray,
682        B::MnArray,
683        C::MnArray,
684        D::MnArray,
685        E::MnArray,
686        F::MnArray,
687        G::MnArray,
688    ];
689}
690
691impl<
692    A: ToOutput,
693    B: ToOutput,
694    C: ToOutput,
695    D: ToOutput,
696    E: ToOutput,
697    F: ToOutput,
698    G: ToOutput,
699    H: ToOutput,
700> ToOutput for (A, B, C, D, E, F, G, H)
701{
702    fn to_output(&self, output: &mut dyn Output) {
703        self.0.to_output(output);
704        self.1.to_output(output);
705        self.2.to_output(output);
706        self.3.to_output(output);
707        self.4.to_output(output);
708        self.5.to_output(output);
709        self.6.to_output(output);
710        self.7.to_output(output);
711    }
712}
713
714impl<
715    Extra: 'static,
716    A: Topological<Extra>,
717    B: Topological<Extra>,
718    C: Topological<Extra>,
719    D: Topological<Extra>,
720    E: Topological<Extra>,
721    F: Topological<Extra>,
722    G: Topological<Extra>,
723    H: Topological<Extra>,
724> Topological<Extra> for (A, B, C, D, E, F, G, H)
725{
726    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
727        self.0.accept_points(visitor);
728        self.1.accept_points(visitor);
729        self.2.accept_points(visitor);
730        self.3.accept_points(visitor);
731        self.4.accept_points(visitor);
732        self.5.accept_points(visitor);
733        self.6.accept_points(visitor);
734        self.7.accept_points(visitor);
735    }
736}
737
738impl<A: Tagged, B: Tagged, C: Tagged, D: Tagged, E: Tagged, F: Tagged, G: Tagged, H: Tagged> Tagged
739    for (A, B, C, D, E, F, G, H)
740{
741    const TAGS: Tags = Tags(
742        &[],
743        &[
744            &A::TAGS,
745            &B::TAGS,
746            &C::TAGS,
747            &D::TAGS,
748            &E::TAGS,
749            &F::TAGS,
750            &G::TAGS,
751            &H::TAGS,
752        ],
753    );
754}
755
756impl<
757    Extra: 'static,
758    A: Inline<Extra>,
759    B: Inline<Extra>,
760    C: Inline<Extra>,
761    D: Inline<Extra>,
762    E: Inline<Extra>,
763    F: Inline<Extra>,
764    G: Inline<Extra>,
765    H: Object<Extra>,
766> Object<Extra> for (A, B, C, D, E, F, G, H)
767{
768}
769
770impl<
771    Extra: 'static,
772    A: Inline<Extra>,
773    B: Inline<Extra>,
774    C: Inline<Extra>,
775    D: Inline<Extra>,
776    E: Inline<Extra>,
777    F: Inline<Extra>,
778    G: Inline<Extra>,
779    H: Inline<Extra>,
780> Inline<Extra> for (A, B, C, D, E, F, G, H)
781{
782}
783
784impl<
785    A: ReflessInline,
786    B: ReflessInline,
787    C: ReflessInline,
788    D: ReflessInline,
789    E: ReflessInline,
790    F: ReflessInline,
791    G: ReflessInline,
792    H: ReflessObject,
793> ReflessObject for (A, B, C, D, E, F, G, H)
794{
795}
796
797impl<
798    A: ReflessInline,
799    B: ReflessInline,
800    C: ReflessInline,
801    D: ReflessInline,
802    E: ReflessInline,
803    F: ReflessInline,
804    G: ReflessInline,
805    H: ReflessInline,
806> ReflessInline for (A, B, C, D, E, F, G, H)
807{
808}
809
810impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size, G: Size, H: Size> Size
811    for (A, B, C, D, E, F, G, H)
812where
813    tarr![
814        A::Size,
815        B::Size,
816        C::Size,
817        D::Size,
818        E::Size,
819        F::Size,
820        G::Size,
821        H::Size,
822    ]: typenum::FoldAdd<Output: Unsigned>,
823{
824    const SIZE: usize =
825        A::SIZE + B::SIZE + C::SIZE + D::SIZE + E::SIZE + F::SIZE + G::SIZE + H::SIZE;
826
827    type Size = <tarr![
828        A::Size,
829        B::Size,
830        C::Size,
831        D::Size,
832        E::Size,
833        F::Size,
834        G::Size,
835        H::Size,
836    ] as typenum::FoldAdd>::Output;
837}
838
839impl<
840    II: ParseInput,
841    A: ParseInline<II>,
842    B: ParseInline<II>,
843    C: ParseInline<II>,
844    D: ParseInline<II>,
845    E: ParseInline<II>,
846    F: ParseInline<II>,
847    G: ParseInline<II>,
848    H: Parse<II>,
849> Parse<II> for (A, B, C, D, E, F, G, H)
850{
851    fn parse(mut input: II) -> crate::Result<Self> {
852        Ok((
853            input.parse_inline()?,
854            input.parse_inline()?,
855            input.parse_inline()?,
856            input.parse_inline()?,
857            input.parse_inline()?,
858            input.parse_inline()?,
859            input.parse_inline()?,
860            input.parse()?,
861        ))
862    }
863}
864
865impl<
866    II: ParseInput,
867    A: ParseInline<II>,
868    B: ParseInline<II>,
869    C: ParseInline<II>,
870    D: ParseInline<II>,
871    E: ParseInline<II>,
872    F: ParseInline<II>,
873    G: ParseInline<II>,
874    H: ParseInline<II>,
875> ParseInline<II> for (A, B, C, D, E, F, G, H)
876{
877    fn parse_inline(input: &mut II) -> crate::Result<Self> {
878        Ok((
879            input.parse_inline()?,
880            input.parse_inline()?,
881            input.parse_inline()?,
882            input.parse_inline()?,
883            input.parse_inline()?,
884            input.parse_inline()?,
885            input.parse_inline()?,
886            input.parse_inline()?,
887        ))
888    }
889}
890
891impl<
892    A: MaybeHasNiche,
893    B: MaybeHasNiche,
894    C: MaybeHasNiche,
895    D: MaybeHasNiche,
896    E: MaybeHasNiche,
897    F: MaybeHasNiche,
898    G: MaybeHasNiche,
899    H: MaybeHasNiche,
900> MaybeHasNiche for (A, B, C, D, E, F, G, H)
901{
902    type MnArray = tarr![
903        A::MnArray,
904        B::MnArray,
905        C::MnArray,
906        D::MnArray,
907        E::MnArray,
908        F::MnArray,
909        G::MnArray,
910        H::MnArray,
911    ];
912}
913
914impl<
915    A: ToOutput,
916    B: ToOutput,
917    C: ToOutput,
918    D: ToOutput,
919    E: ToOutput,
920    F: ToOutput,
921    G: ToOutput,
922    H: ToOutput,
923    I: ToOutput,
924> ToOutput for (A, B, C, D, E, F, G, H, I)
925{
926    fn to_output(&self, output: &mut dyn Output) {
927        self.0.to_output(output);
928        self.1.to_output(output);
929        self.2.to_output(output);
930        self.3.to_output(output);
931        self.4.to_output(output);
932        self.5.to_output(output);
933        self.6.to_output(output);
934        self.7.to_output(output);
935        self.8.to_output(output);
936    }
937}
938
939impl<
940    Extra: 'static,
941    A: Topological<Extra>,
942    B: Topological<Extra>,
943    C: Topological<Extra>,
944    D: Topological<Extra>,
945    E: Topological<Extra>,
946    F: Topological<Extra>,
947    G: Topological<Extra>,
948    H: Topological<Extra>,
949    I: Topological<Extra>,
950> Topological<Extra> for (A, B, C, D, E, F, G, H, I)
951{
952    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
953        self.0.accept_points(visitor);
954        self.1.accept_points(visitor);
955        self.2.accept_points(visitor);
956        self.3.accept_points(visitor);
957        self.4.accept_points(visitor);
958        self.5.accept_points(visitor);
959        self.6.accept_points(visitor);
960        self.7.accept_points(visitor);
961        self.8.accept_points(visitor);
962    }
963}
964
965impl<
966    A: Tagged,
967    B: Tagged,
968    C: Tagged,
969    D: Tagged,
970    E: Tagged,
971    F: Tagged,
972    G: Tagged,
973    H: Tagged,
974    I: Tagged,
975> Tagged for (A, B, C, D, E, F, G, H, I)
976{
977    const TAGS: Tags = Tags(
978        &[],
979        &[
980            &A::TAGS,
981            &B::TAGS,
982            &C::TAGS,
983            &D::TAGS,
984            &E::TAGS,
985            &F::TAGS,
986            &G::TAGS,
987            &H::TAGS,
988            &I::TAGS,
989        ],
990    );
991}
992
993impl<
994    Extra: 'static,
995    A: Inline<Extra>,
996    B: Inline<Extra>,
997    C: Inline<Extra>,
998    D: Inline<Extra>,
999    E: Inline<Extra>,
1000    F: Inline<Extra>,
1001    G: Inline<Extra>,
1002    H: Inline<Extra>,
1003    I: Object<Extra>,
1004> Object<Extra> for (A, B, C, D, E, F, G, H, I)
1005{
1006}
1007
1008impl<
1009    Extra: 'static,
1010    A: Inline<Extra>,
1011    B: Inline<Extra>,
1012    C: Inline<Extra>,
1013    D: Inline<Extra>,
1014    E: Inline<Extra>,
1015    F: Inline<Extra>,
1016    G: Inline<Extra>,
1017    H: Inline<Extra>,
1018    I: Inline<Extra>,
1019> Inline<Extra> for (A, B, C, D, E, F, G, H, I)
1020{
1021}
1022
1023impl<
1024    A: ReflessInline,
1025    B: ReflessInline,
1026    C: ReflessInline,
1027    D: ReflessInline,
1028    E: ReflessInline,
1029    F: ReflessInline,
1030    G: ReflessInline,
1031    H: ReflessInline,
1032    I: ReflessObject,
1033> ReflessObject for (A, B, C, D, E, F, G, H, I)
1034{
1035}
1036
1037impl<
1038    A: ReflessInline,
1039    B: ReflessInline,
1040    C: ReflessInline,
1041    D: ReflessInline,
1042    E: ReflessInline,
1043    F: ReflessInline,
1044    G: ReflessInline,
1045    H: ReflessInline,
1046    I: ReflessInline,
1047> ReflessInline for (A, B, C, D, E, F, G, H, I)
1048{
1049}
1050
1051impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size, G: Size, H: Size, I: Size> Size
1052    for (A, B, C, D, E, F, G, H, I)
1053where
1054    tarr![
1055        A::Size,
1056        B::Size,
1057        C::Size,
1058        D::Size,
1059        E::Size,
1060        F::Size,
1061        G::Size,
1062        H::Size,
1063        I::Size,
1064    ]: typenum::FoldAdd<Output: Unsigned>,
1065{
1066    const SIZE: usize =
1067        A::SIZE + B::SIZE + C::SIZE + D::SIZE + E::SIZE + F::SIZE + G::SIZE + H::SIZE + I::SIZE;
1068
1069    type Size = <tarr![
1070        A::Size,
1071        B::Size,
1072        C::Size,
1073        D::Size,
1074        E::Size,
1075        F::Size,
1076        G::Size,
1077        H::Size,
1078        I::Size,
1079    ] as typenum::FoldAdd>::Output;
1080}
1081
1082impl<
1083    II: ParseInput,
1084    A: ParseInline<II>,
1085    B: ParseInline<II>,
1086    C: ParseInline<II>,
1087    D: ParseInline<II>,
1088    E: ParseInline<II>,
1089    F: ParseInline<II>,
1090    G: ParseInline<II>,
1091    H: ParseInline<II>,
1092    I: Parse<II>,
1093> Parse<II> for (A, B, C, D, E, F, G, H, I)
1094{
1095    fn parse(mut input: II) -> crate::Result<Self> {
1096        Ok((
1097            input.parse_inline()?,
1098            input.parse_inline()?,
1099            input.parse_inline()?,
1100            input.parse_inline()?,
1101            input.parse_inline()?,
1102            input.parse_inline()?,
1103            input.parse_inline()?,
1104            input.parse_inline()?,
1105            input.parse()?,
1106        ))
1107    }
1108}
1109
1110impl<
1111    II: ParseInput,
1112    A: ParseInline<II>,
1113    B: ParseInline<II>,
1114    C: ParseInline<II>,
1115    D: ParseInline<II>,
1116    E: ParseInline<II>,
1117    F: ParseInline<II>,
1118    G: ParseInline<II>,
1119    H: ParseInline<II>,
1120    I: ParseInline<II>,
1121> ParseInline<II> for (A, B, C, D, E, F, G, H, I)
1122{
1123    fn parse_inline(input: &mut II) -> crate::Result<Self> {
1124        Ok((
1125            input.parse_inline()?,
1126            input.parse_inline()?,
1127            input.parse_inline()?,
1128            input.parse_inline()?,
1129            input.parse_inline()?,
1130            input.parse_inline()?,
1131            input.parse_inline()?,
1132            input.parse_inline()?,
1133            input.parse_inline()?,
1134        ))
1135    }
1136}
1137
1138impl<
1139    A: MaybeHasNiche,
1140    B: MaybeHasNiche,
1141    C: MaybeHasNiche,
1142    D: MaybeHasNiche,
1143    E: MaybeHasNiche,
1144    F: MaybeHasNiche,
1145    G: MaybeHasNiche,
1146    H: MaybeHasNiche,
1147    I: MaybeHasNiche,
1148> MaybeHasNiche for (A, B, C, D, E, F, G, H, I)
1149{
1150    type MnArray = tarr![
1151        A::MnArray,
1152        B::MnArray,
1153        C::MnArray,
1154        D::MnArray,
1155        E::MnArray,
1156        F::MnArray,
1157        G::MnArray,
1158        H::MnArray,
1159        I::MnArray,
1160    ];
1161}
1162
1163impl<
1164    A: ToOutput,
1165    B: ToOutput,
1166    C: ToOutput,
1167    D: ToOutput,
1168    E: ToOutput,
1169    F: ToOutput,
1170    G: ToOutput,
1171    H: ToOutput,
1172    I: ToOutput,
1173    J: ToOutput,
1174> ToOutput for (A, B, C, D, E, F, G, H, I, J)
1175{
1176    fn to_output(&self, output: &mut dyn Output) {
1177        self.0.to_output(output);
1178        self.1.to_output(output);
1179        self.2.to_output(output);
1180        self.3.to_output(output);
1181        self.4.to_output(output);
1182        self.5.to_output(output);
1183        self.6.to_output(output);
1184        self.7.to_output(output);
1185        self.8.to_output(output);
1186        self.9.to_output(output);
1187    }
1188}
1189
1190impl<
1191    Extra: 'static,
1192    A: Topological<Extra>,
1193    B: Topological<Extra>,
1194    C: Topological<Extra>,
1195    D: Topological<Extra>,
1196    E: Topological<Extra>,
1197    F: Topological<Extra>,
1198    G: Topological<Extra>,
1199    H: Topological<Extra>,
1200    I: Topological<Extra>,
1201    J: Topological<Extra>,
1202> Topological<Extra> for (A, B, C, D, E, F, G, H, I, J)
1203{
1204    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
1205        self.0.accept_points(visitor);
1206        self.1.accept_points(visitor);
1207        self.2.accept_points(visitor);
1208        self.3.accept_points(visitor);
1209        self.4.accept_points(visitor);
1210        self.5.accept_points(visitor);
1211        self.6.accept_points(visitor);
1212        self.7.accept_points(visitor);
1213        self.8.accept_points(visitor);
1214        self.9.accept_points(visitor);
1215    }
1216}
1217
1218impl<
1219    A: Tagged,
1220    B: Tagged,
1221    C: Tagged,
1222    D: Tagged,
1223    E: Tagged,
1224    F: Tagged,
1225    G: Tagged,
1226    H: Tagged,
1227    I: Tagged,
1228    J: Tagged,
1229> Tagged for (A, B, C, D, E, F, G, H, I, J)
1230{
1231    const TAGS: Tags = Tags(
1232        &[],
1233        &[
1234            &A::TAGS,
1235            &B::TAGS,
1236            &C::TAGS,
1237            &D::TAGS,
1238            &E::TAGS,
1239            &F::TAGS,
1240            &G::TAGS,
1241            &H::TAGS,
1242            &I::TAGS,
1243            &J::TAGS,
1244        ],
1245    );
1246}
1247
1248impl<
1249    Extra: 'static,
1250    A: Inline<Extra>,
1251    B: Inline<Extra>,
1252    C: Inline<Extra>,
1253    D: Inline<Extra>,
1254    E: Inline<Extra>,
1255    F: Inline<Extra>,
1256    G: Inline<Extra>,
1257    H: Inline<Extra>,
1258    I: Inline<Extra>,
1259    J: Object<Extra>,
1260> Object<Extra> for (A, B, C, D, E, F, G, H, I, J)
1261{
1262}
1263
1264impl<
1265    Extra: 'static,
1266    A: Inline<Extra>,
1267    B: Inline<Extra>,
1268    C: Inline<Extra>,
1269    D: Inline<Extra>,
1270    E: Inline<Extra>,
1271    F: Inline<Extra>,
1272    G: Inline<Extra>,
1273    H: Inline<Extra>,
1274    I: Inline<Extra>,
1275    J: Inline<Extra>,
1276> Inline<Extra> for (A, B, C, D, E, F, G, H, I, J)
1277{
1278}
1279
1280impl<
1281    A: ReflessInline,
1282    B: ReflessInline,
1283    C: ReflessInline,
1284    D: ReflessInline,
1285    E: ReflessInline,
1286    F: ReflessInline,
1287    G: ReflessInline,
1288    H: ReflessInline,
1289    I: ReflessInline,
1290    J: ReflessObject,
1291> ReflessObject for (A, B, C, D, E, F, G, H, I, J)
1292{
1293}
1294
1295impl<
1296    A: ReflessInline,
1297    B: ReflessInline,
1298    C: ReflessInline,
1299    D: ReflessInline,
1300    E: ReflessInline,
1301    F: ReflessInline,
1302    G: ReflessInline,
1303    H: ReflessInline,
1304    I: ReflessInline,
1305    J: ReflessInline,
1306> ReflessInline for (A, B, C, D, E, F, G, H, I, J)
1307{
1308}
1309
1310impl<A: Size, B: Size, C: Size, D: Size, E: Size, F: Size, G: Size, H: Size, I: Size, J: Size> Size
1311    for (A, B, C, D, E, F, G, H, I, J)
1312where
1313    tarr![
1314        A::Size,
1315        B::Size,
1316        C::Size,
1317        D::Size,
1318        E::Size,
1319        F::Size,
1320        G::Size,
1321        H::Size,
1322        I::Size,
1323        J::Size,
1324    ]: typenum::FoldAdd<Output: Unsigned>,
1325{
1326    const SIZE: usize = A::SIZE
1327        + B::SIZE
1328        + C::SIZE
1329        + D::SIZE
1330        + E::SIZE
1331        + F::SIZE
1332        + G::SIZE
1333        + H::SIZE
1334        + I::SIZE
1335        + J::SIZE;
1336
1337    type Size = <tarr![
1338        A::Size,
1339        B::Size,
1340        C::Size,
1341        D::Size,
1342        E::Size,
1343        F::Size,
1344        G::Size,
1345        H::Size,
1346        I::Size,
1347        J::Size,
1348    ] as typenum::FoldAdd>::Output;
1349}
1350
1351impl<
1352    II: ParseInput,
1353    A: ParseInline<II>,
1354    B: ParseInline<II>,
1355    C: ParseInline<II>,
1356    D: ParseInline<II>,
1357    E: ParseInline<II>,
1358    F: ParseInline<II>,
1359    G: ParseInline<II>,
1360    H: ParseInline<II>,
1361    I: ParseInline<II>,
1362    J: Parse<II>,
1363> Parse<II> for (A, B, C, D, E, F, G, H, I, J)
1364{
1365    fn parse(mut input: II) -> crate::Result<Self> {
1366        Ok((
1367            input.parse_inline()?,
1368            input.parse_inline()?,
1369            input.parse_inline()?,
1370            input.parse_inline()?,
1371            input.parse_inline()?,
1372            input.parse_inline()?,
1373            input.parse_inline()?,
1374            input.parse_inline()?,
1375            input.parse_inline()?,
1376            input.parse()?,
1377        ))
1378    }
1379}
1380
1381impl<
1382    II: ParseInput,
1383    A: ParseInline<II>,
1384    B: ParseInline<II>,
1385    C: ParseInline<II>,
1386    D: ParseInline<II>,
1387    E: ParseInline<II>,
1388    F: ParseInline<II>,
1389    G: ParseInline<II>,
1390    H: ParseInline<II>,
1391    I: ParseInline<II>,
1392    J: ParseInline<II>,
1393> ParseInline<II> for (A, B, C, D, E, F, G, H, I, J)
1394{
1395    fn parse_inline(input: &mut II) -> crate::Result<Self> {
1396        Ok((
1397            input.parse_inline()?,
1398            input.parse_inline()?,
1399            input.parse_inline()?,
1400            input.parse_inline()?,
1401            input.parse_inline()?,
1402            input.parse_inline()?,
1403            input.parse_inline()?,
1404            input.parse_inline()?,
1405            input.parse_inline()?,
1406            input.parse_inline()?,
1407        ))
1408    }
1409}
1410
1411impl<
1412    A: MaybeHasNiche,
1413    B: MaybeHasNiche,
1414    C: MaybeHasNiche,
1415    D: MaybeHasNiche,
1416    E: MaybeHasNiche,
1417    F: MaybeHasNiche,
1418    G: MaybeHasNiche,
1419    H: MaybeHasNiche,
1420    I: MaybeHasNiche,
1421    J: MaybeHasNiche,
1422> MaybeHasNiche for (A, B, C, D, E, F, G, H, I, J)
1423{
1424    type MnArray = tarr![
1425        A::MnArray,
1426        B::MnArray,
1427        C::MnArray,
1428        D::MnArray,
1429        E::MnArray,
1430        F::MnArray,
1431        G::MnArray,
1432        H::MnArray,
1433        I::MnArray,
1434        J::MnArray,
1435    ];
1436}
1437
1438impl<
1439    A: ToOutput,
1440    B: ToOutput,
1441    C: ToOutput,
1442    D: ToOutput,
1443    E: ToOutput,
1444    F: ToOutput,
1445    G: ToOutput,
1446    H: ToOutput,
1447    I: ToOutput,
1448    J: ToOutput,
1449    K: ToOutput,
1450> ToOutput for (A, B, C, D, E, F, G, H, I, J, K)
1451{
1452    fn to_output(&self, output: &mut dyn Output) {
1453        self.0.to_output(output);
1454        self.1.to_output(output);
1455        self.2.to_output(output);
1456        self.3.to_output(output);
1457        self.4.to_output(output);
1458        self.5.to_output(output);
1459        self.6.to_output(output);
1460        self.7.to_output(output);
1461        self.8.to_output(output);
1462        self.9.to_output(output);
1463        self.10.to_output(output);
1464    }
1465}
1466
1467impl<
1468    Extra: 'static,
1469    A: Topological<Extra>,
1470    B: Topological<Extra>,
1471    C: Topological<Extra>,
1472    D: Topological<Extra>,
1473    E: Topological<Extra>,
1474    F: Topological<Extra>,
1475    G: Topological<Extra>,
1476    H: Topological<Extra>,
1477    I: Topological<Extra>,
1478    J: Topological<Extra>,
1479    K: Topological<Extra>,
1480> Topological<Extra> for (A, B, C, D, E, F, G, H, I, J, K)
1481{
1482    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
1483        self.0.accept_points(visitor);
1484        self.1.accept_points(visitor);
1485        self.2.accept_points(visitor);
1486        self.3.accept_points(visitor);
1487        self.4.accept_points(visitor);
1488        self.5.accept_points(visitor);
1489        self.6.accept_points(visitor);
1490        self.7.accept_points(visitor);
1491        self.8.accept_points(visitor);
1492        self.9.accept_points(visitor);
1493        self.10.accept_points(visitor);
1494    }
1495}
1496
1497impl<
1498    A: Tagged,
1499    B: Tagged,
1500    C: Tagged,
1501    D: Tagged,
1502    E: Tagged,
1503    F: Tagged,
1504    G: Tagged,
1505    H: Tagged,
1506    I: Tagged,
1507    J: Tagged,
1508    K: Tagged,
1509> Tagged for (A, B, C, D, E, F, G, H, I, J, K)
1510{
1511    const TAGS: Tags = Tags(
1512        &[],
1513        &[
1514            &A::TAGS,
1515            &B::TAGS,
1516            &C::TAGS,
1517            &D::TAGS,
1518            &E::TAGS,
1519            &F::TAGS,
1520            &G::TAGS,
1521            &H::TAGS,
1522            &I::TAGS,
1523            &J::TAGS,
1524            &K::TAGS,
1525        ],
1526    );
1527}
1528
1529impl<
1530    Extra: 'static,
1531    A: Inline<Extra>,
1532    B: Inline<Extra>,
1533    C: Inline<Extra>,
1534    D: Inline<Extra>,
1535    E: Inline<Extra>,
1536    F: Inline<Extra>,
1537    G: Inline<Extra>,
1538    H: Inline<Extra>,
1539    I: Inline<Extra>,
1540    J: Inline<Extra>,
1541    K: Object<Extra>,
1542> Object<Extra> for (A, B, C, D, E, F, G, H, I, J, K)
1543{
1544}
1545
1546impl<
1547    Extra: 'static,
1548    A: Inline<Extra>,
1549    B: Inline<Extra>,
1550    C: Inline<Extra>,
1551    D: Inline<Extra>,
1552    E: Inline<Extra>,
1553    F: Inline<Extra>,
1554    G: Inline<Extra>,
1555    H: Inline<Extra>,
1556    I: Inline<Extra>,
1557    J: Inline<Extra>,
1558    K: Inline<Extra>,
1559> Inline<Extra> for (A, B, C, D, E, F, G, H, I, J, K)
1560{
1561}
1562
1563impl<
1564    A: ReflessInline,
1565    B: ReflessInline,
1566    C: ReflessInline,
1567    D: ReflessInline,
1568    E: ReflessInline,
1569    F: ReflessInline,
1570    G: ReflessInline,
1571    H: ReflessInline,
1572    I: ReflessInline,
1573    J: ReflessInline,
1574    K: ReflessObject,
1575> ReflessObject for (A, B, C, D, E, F, G, H, I, J, K)
1576{
1577}
1578
1579impl<
1580    A: ReflessInline,
1581    B: ReflessInline,
1582    C: ReflessInline,
1583    D: ReflessInline,
1584    E: ReflessInline,
1585    F: ReflessInline,
1586    G: ReflessInline,
1587    H: ReflessInline,
1588    I: ReflessInline,
1589    J: ReflessInline,
1590    K: ReflessInline,
1591> ReflessInline for (A, B, C, D, E, F, G, H, I, J, K)
1592{
1593}
1594
1595impl<
1596    A: Size,
1597    B: Size,
1598    C: Size,
1599    D: Size,
1600    E: Size,
1601    F: Size,
1602    G: Size,
1603    H: Size,
1604    I: Size,
1605    J: Size,
1606    K: Size,
1607> Size for (A, B, C, D, E, F, G, H, I, J, K)
1608where
1609    tarr![
1610        A::Size,
1611        B::Size,
1612        C::Size,
1613        D::Size,
1614        E::Size,
1615        F::Size,
1616        G::Size,
1617        H::Size,
1618        I::Size,
1619        J::Size,
1620        K::Size,
1621    ]: typenum::FoldAdd<Output: Unsigned>,
1622{
1623    const SIZE: usize = A::SIZE
1624        + B::SIZE
1625        + C::SIZE
1626        + D::SIZE
1627        + E::SIZE
1628        + F::SIZE
1629        + G::SIZE
1630        + H::SIZE
1631        + I::SIZE
1632        + J::SIZE
1633        + K::SIZE;
1634
1635    type Size = <tarr![
1636        A::Size,
1637        B::Size,
1638        C::Size,
1639        D::Size,
1640        E::Size,
1641        F::Size,
1642        G::Size,
1643        H::Size,
1644        I::Size,
1645        J::Size,
1646        K::Size,
1647    ] as typenum::FoldAdd>::Output;
1648}
1649
1650impl<
1651    II: ParseInput,
1652    A: ParseInline<II>,
1653    B: ParseInline<II>,
1654    C: ParseInline<II>,
1655    D: ParseInline<II>,
1656    E: ParseInline<II>,
1657    F: ParseInline<II>,
1658    G: ParseInline<II>,
1659    H: ParseInline<II>,
1660    I: ParseInline<II>,
1661    J: ParseInline<II>,
1662    K: Parse<II>,
1663> Parse<II> for (A, B, C, D, E, F, G, H, I, J, K)
1664{
1665    fn parse(mut input: II) -> crate::Result<Self> {
1666        Ok((
1667            input.parse_inline()?,
1668            input.parse_inline()?,
1669            input.parse_inline()?,
1670            input.parse_inline()?,
1671            input.parse_inline()?,
1672            input.parse_inline()?,
1673            input.parse_inline()?,
1674            input.parse_inline()?,
1675            input.parse_inline()?,
1676            input.parse_inline()?,
1677            input.parse()?,
1678        ))
1679    }
1680}
1681
1682impl<
1683    II: ParseInput,
1684    A: ParseInline<II>,
1685    B: ParseInline<II>,
1686    C: ParseInline<II>,
1687    D: ParseInline<II>,
1688    E: ParseInline<II>,
1689    F: ParseInline<II>,
1690    G: ParseInline<II>,
1691    H: ParseInline<II>,
1692    I: ParseInline<II>,
1693    J: ParseInline<II>,
1694    K: ParseInline<II>,
1695> ParseInline<II> for (A, B, C, D, E, F, G, H, I, J, K)
1696{
1697    fn parse_inline(input: &mut II) -> crate::Result<Self> {
1698        Ok((
1699            input.parse_inline()?,
1700            input.parse_inline()?,
1701            input.parse_inline()?,
1702            input.parse_inline()?,
1703            input.parse_inline()?,
1704            input.parse_inline()?,
1705            input.parse_inline()?,
1706            input.parse_inline()?,
1707            input.parse_inline()?,
1708            input.parse_inline()?,
1709            input.parse_inline()?,
1710        ))
1711    }
1712}
1713
1714impl<
1715    A: MaybeHasNiche,
1716    B: MaybeHasNiche,
1717    C: MaybeHasNiche,
1718    D: MaybeHasNiche,
1719    E: MaybeHasNiche,
1720    F: MaybeHasNiche,
1721    G: MaybeHasNiche,
1722    H: MaybeHasNiche,
1723    I: MaybeHasNiche,
1724    J: MaybeHasNiche,
1725    K: MaybeHasNiche,
1726> MaybeHasNiche for (A, B, C, D, E, F, G, H, I, J, K)
1727{
1728    type MnArray = tarr![
1729        A::MnArray,
1730        B::MnArray,
1731        C::MnArray,
1732        D::MnArray,
1733        E::MnArray,
1734        F::MnArray,
1735        G::MnArray,
1736        H::MnArray,
1737        I::MnArray,
1738        J::MnArray,
1739        K::MnArray,
1740    ];
1741}
1742
1743impl<
1744    A: ToOutput,
1745    B: ToOutput,
1746    C: ToOutput,
1747    D: ToOutput,
1748    E: ToOutput,
1749    F: ToOutput,
1750    G: ToOutput,
1751    H: ToOutput,
1752    I: ToOutput,
1753    J: ToOutput,
1754    K: ToOutput,
1755    L: ToOutput,
1756> ToOutput for (A, B, C, D, E, F, G, H, I, J, K, L)
1757{
1758    fn to_output(&self, output: &mut dyn Output) {
1759        self.0.to_output(output);
1760        self.1.to_output(output);
1761        self.2.to_output(output);
1762        self.3.to_output(output);
1763        self.4.to_output(output);
1764        self.5.to_output(output);
1765        self.6.to_output(output);
1766        self.7.to_output(output);
1767        self.8.to_output(output);
1768        self.9.to_output(output);
1769        self.10.to_output(output);
1770        self.11.to_output(output);
1771    }
1772}
1773
1774impl<
1775    Extra: 'static,
1776    A: Topological<Extra>,
1777    B: Topological<Extra>,
1778    C: Topological<Extra>,
1779    D: Topological<Extra>,
1780    E: Topological<Extra>,
1781    F: Topological<Extra>,
1782    G: Topological<Extra>,
1783    H: Topological<Extra>,
1784    I: Topological<Extra>,
1785    J: Topological<Extra>,
1786    K: Topological<Extra>,
1787    L: Topological<Extra>,
1788> Topological<Extra> for (A, B, C, D, E, F, G, H, I, J, K, L)
1789{
1790    fn accept_points(&self, visitor: &mut impl PointVisitor<Extra>) {
1791        self.0.accept_points(visitor);
1792        self.1.accept_points(visitor);
1793        self.2.accept_points(visitor);
1794        self.3.accept_points(visitor);
1795        self.4.accept_points(visitor);
1796        self.5.accept_points(visitor);
1797        self.6.accept_points(visitor);
1798        self.7.accept_points(visitor);
1799        self.8.accept_points(visitor);
1800        self.9.accept_points(visitor);
1801        self.10.accept_points(visitor);
1802        self.11.accept_points(visitor);
1803    }
1804}
1805
1806impl<
1807    A: Tagged,
1808    B: Tagged,
1809    C: Tagged,
1810    D: Tagged,
1811    E: Tagged,
1812    F: Tagged,
1813    G: Tagged,
1814    H: Tagged,
1815    I: Tagged,
1816    J: Tagged,
1817    K: Tagged,
1818    L: Tagged,
1819> Tagged for (A, B, C, D, E, F, G, H, I, J, K, L)
1820{
1821    const TAGS: Tags = Tags(
1822        &[],
1823        &[
1824            &A::TAGS,
1825            &B::TAGS,
1826            &C::TAGS,
1827            &D::TAGS,
1828            &E::TAGS,
1829            &F::TAGS,
1830            &G::TAGS,
1831            &H::TAGS,
1832            &I::TAGS,
1833            &J::TAGS,
1834            &K::TAGS,
1835            &L::TAGS,
1836        ],
1837    );
1838}
1839
1840impl<
1841    Extra: 'static,
1842    A: Inline<Extra>,
1843    B: Inline<Extra>,
1844    C: Inline<Extra>,
1845    D: Inline<Extra>,
1846    E: Inline<Extra>,
1847    F: Inline<Extra>,
1848    G: Inline<Extra>,
1849    H: Inline<Extra>,
1850    I: Inline<Extra>,
1851    J: Inline<Extra>,
1852    K: Inline<Extra>,
1853    L: Object<Extra>,
1854> Object<Extra> for (A, B, C, D, E, F, G, H, I, J, K, L)
1855{
1856}
1857
1858impl<
1859    Extra: 'static,
1860    A: Inline<Extra>,
1861    B: Inline<Extra>,
1862    C: Inline<Extra>,
1863    D: Inline<Extra>,
1864    E: Inline<Extra>,
1865    F: Inline<Extra>,
1866    G: Inline<Extra>,
1867    H: Inline<Extra>,
1868    I: Inline<Extra>,
1869    J: Inline<Extra>,
1870    K: Inline<Extra>,
1871    L: Inline<Extra>,
1872> Inline<Extra> for (A, B, C, D, E, F, G, H, I, J, K, L)
1873{
1874}
1875
1876impl<
1877    A: ReflessInline,
1878    B: ReflessInline,
1879    C: ReflessInline,
1880    D: ReflessInline,
1881    E: ReflessInline,
1882    F: ReflessInline,
1883    G: ReflessInline,
1884    H: ReflessInline,
1885    I: ReflessInline,
1886    J: ReflessInline,
1887    K: ReflessInline,
1888    L: ReflessObject,
1889> ReflessObject for (A, B, C, D, E, F, G, H, I, J, K, L)
1890{
1891}
1892
1893impl<
1894    A: ReflessInline,
1895    B: ReflessInline,
1896    C: ReflessInline,
1897    D: ReflessInline,
1898    E: ReflessInline,
1899    F: ReflessInline,
1900    G: ReflessInline,
1901    H: ReflessInline,
1902    I: ReflessInline,
1903    J: ReflessInline,
1904    K: ReflessInline,
1905    L: ReflessInline,
1906> ReflessInline for (A, B, C, D, E, F, G, H, I, J, K, L)
1907{
1908}
1909
1910impl<
1911    A: Size,
1912    B: Size,
1913    C: Size,
1914    D: Size,
1915    E: Size,
1916    F: Size,
1917    G: Size,
1918    H: Size,
1919    I: Size,
1920    J: Size,
1921    K: Size,
1922    L: Size,
1923> Size for (A, B, C, D, E, F, G, H, I, J, K, L)
1924where
1925    tarr![
1926        A::Size,
1927        B::Size,
1928        C::Size,
1929        D::Size,
1930        E::Size,
1931        F::Size,
1932        G::Size,
1933        H::Size,
1934        I::Size,
1935        J::Size,
1936        K::Size,
1937        L::Size,
1938    ]: typenum::FoldAdd<Output: Unsigned>,
1939{
1940    const SIZE: usize = A::SIZE
1941        + B::SIZE
1942        + C::SIZE
1943        + D::SIZE
1944        + E::SIZE
1945        + F::SIZE
1946        + G::SIZE
1947        + H::SIZE
1948        + I::SIZE
1949        + J::SIZE
1950        + K::SIZE
1951        + L::SIZE;
1952
1953    type Size = <tarr![
1954        A::Size,
1955        B::Size,
1956        C::Size,
1957        D::Size,
1958        E::Size,
1959        F::Size,
1960        G::Size,
1961        H::Size,
1962        I::Size,
1963        J::Size,
1964        K::Size,
1965        L::Size,
1966    ] as typenum::FoldAdd>::Output;
1967}
1968
1969impl<
1970    II: ParseInput,
1971    A: ParseInline<II>,
1972    B: ParseInline<II>,
1973    C: ParseInline<II>,
1974    D: ParseInline<II>,
1975    E: ParseInline<II>,
1976    F: ParseInline<II>,
1977    G: ParseInline<II>,
1978    H: ParseInline<II>,
1979    I: ParseInline<II>,
1980    J: ParseInline<II>,
1981    K: ParseInline<II>,
1982    L: Parse<II>,
1983> Parse<II> for (A, B, C, D, E, F, G, H, I, J, K, L)
1984{
1985    fn parse(mut input: II) -> crate::Result<Self> {
1986        Ok((
1987            input.parse_inline()?,
1988            input.parse_inline()?,
1989            input.parse_inline()?,
1990            input.parse_inline()?,
1991            input.parse_inline()?,
1992            input.parse_inline()?,
1993            input.parse_inline()?,
1994            input.parse_inline()?,
1995            input.parse_inline()?,
1996            input.parse_inline()?,
1997            input.parse_inline()?,
1998            input.parse()?,
1999        ))
2000    }
2001}
2002
2003impl<
2004    II: ParseInput,
2005    A: ParseInline<II>,
2006    B: ParseInline<II>,
2007    C: ParseInline<II>,
2008    D: ParseInline<II>,
2009    E: ParseInline<II>,
2010    F: ParseInline<II>,
2011    G: ParseInline<II>,
2012    H: ParseInline<II>,
2013    I: ParseInline<II>,
2014    J: ParseInline<II>,
2015    K: ParseInline<II>,
2016    L: ParseInline<II>,
2017> ParseInline<II> for (A, B, C, D, E, F, G, H, I, J, K, L)
2018{
2019    fn parse_inline(input: &mut II) -> crate::Result<Self> {
2020        Ok((
2021            input.parse_inline()?,
2022            input.parse_inline()?,
2023            input.parse_inline()?,
2024            input.parse_inline()?,
2025            input.parse_inline()?,
2026            input.parse_inline()?,
2027            input.parse_inline()?,
2028            input.parse_inline()?,
2029            input.parse_inline()?,
2030            input.parse_inline()?,
2031            input.parse_inline()?,
2032            input.parse_inline()?,
2033        ))
2034    }
2035}
2036
2037impl<
2038    A: MaybeHasNiche,
2039    B: MaybeHasNiche,
2040    C: MaybeHasNiche,
2041    D: MaybeHasNiche,
2042    E: MaybeHasNiche,
2043    F: MaybeHasNiche,
2044    G: MaybeHasNiche,
2045    H: MaybeHasNiche,
2046    I: MaybeHasNiche,
2047    J: MaybeHasNiche,
2048    K: MaybeHasNiche,
2049    L: MaybeHasNiche,
2050> MaybeHasNiche for (A, B, C, D, E, F, G, H, I, J, K, L)
2051{
2052    type MnArray = tarr![
2053        A::MnArray,
2054        B::MnArray,
2055        C::MnArray,
2056        D::MnArray,
2057        E::MnArray,
2058        F::MnArray,
2059        G::MnArray,
2060        H::MnArray,
2061        I::MnArray,
2062        J::MnArray,
2063        K::MnArray,
2064        L::MnArray,
2065    ];
2066}
object_rainbow/impls/tuple.rs

object_rainbow/impls/
tuple.rs
