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

object_rainbow/impls/
tuple.rs
