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

object_rainbow/impls/
tuple.rs
