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

object_rainbow/impls/
tuple.rs
