( 0000 0000 ) [ 00 00 00 00 00 00 ]
( 0000 0001 ) [ 00 00 00 00 00 00 ]
( 0000 0011 ) [ 00 00 00 00 00 00 ]
( 0000 0011 ) [ 06 00 00 00 00 00 ]
( 0000 0011 ) [ 00 00 00 00 00 00 ]
( 0000 0011 ) [ 19 00 00 00 00 00 ]
( 0000 0011 ) [ 00 00 00 00 00 00 ]
( 0000 0010 ) [ 00 00 00 00 00 00 ]
( 0000 0000 ) [ 00 00 00 00 00 00 ]

For instance, the orphan rule is *absolutely* a problem. It affects ecosystem scaling in multiple ways. It means that if you have a library A providing a trait and a library B providing a type, either A has to add optional support for B or B has to add optional support for A, or someone has to hack around that with a newtype wrapper. Usually, whichever library is less popular ends up adding optional support for the more popular library. This is, for instance, one reason why it's *really really hard* to write a replacement for serde: you'd have to get every crate currently providing optional serde support to provide optional support for your library as well.

In other ecosystems, you'd either add quick-and-dirty support in your application, or you'd write (and perhaps publish) an A-B crate that implements support for using A and B together. This should be possible in Rust.

There are a few potential language solutions to that. The simplest, which would likely be fairly easy and would help many applications, would be "there can only be one implementation of a trait for a type", giving a compiler error if there's more than one.

enum AHelper<T: A> {
    B(B<T>)
}