object_rainbow/impls/
tuple.rs

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

object_rainbow/impls/
tuple.rs
