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

object_rainbow/impls/
tuple.rs
