object_rainbow/impls/
tuple.rs

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

object_rainbow/impls/
tuple.rs
