An incoherent Rust

Coherence & Orphan Rules

• Many see coherence and the orphan rule as foundational to Rust’s ecosystem quality.
• Benefits cited: almost no “can’t use these two crates together” situations, fewer surprising breakages when dependencies update, and cleaner dependency graphs that help compile times.
• The main downside: you often can’t implement a trait for a type you don’t own, blocking ad‑hoc integration between independent crates.

Serde and Ecosystem Lock‑In

• Serialization is the canonical pain point: if a type only implements serde, it’s hard to use it with an alternative like a hypothetical nextserde.
• This creates ecosystem lock‑in: new serialization libraries must convince every upstream crate to add support.
• Newtypes and “view types” are a common workaround, but many find the constant wrapping/unwrapping noisy and unclear.

Workarounds, Alternatives, and Escape Hatches

• Newtypes, wrapper references, and helper attributes can usually work around orphan limitations, but get messy when foreign types are nested deeply.
• Some propose named impls, scoped imports of implementations, or separating “defining an impl” from “choosing the default impl” so users can override locally.
• Macro‑based libraries (e.g., for reflection or “context generics”) attempt to sidestep coherence from user space; others are wary of the added complexity.
• A few argue for a compiler flag or patched compiler that relaxes the orphan rule, treating conflicts as a social rather than technical problem.

Comparisons to Other Languages

• Scala and Haskell are cited as having more flexible or “incoherent” typeclass/implicit systems, with social resolution of conflicts; some claim this works well enough in practice.
• Go is said to “sidestep” the issue with structural interfaces but also lacks equivalent power.
• C#, Java, C++, Zig, OCaml functors, and Julia are mentioned to illustrate other trade‑offs around extension, reflection, and complexity.

Complexity, Evolution, and Impact

• Several participants worry about Rust’s growing conceptual load (GATs, async, proposed coherence relaxations) and fear a Scala‑like complexity ceiling.
• Others note that many past proposals ended up as usability improvements by lifting restrictions rather than adding visible complexity.
• Consensus in the thread: coherence problems are very real for library authors and foundational crates, but mostly invisible to day‑to‑day application developers today.