How is there a conflicting implementation of `From` when using a generic type?

by

The problem here is someone may implement Storage so that the From impl you have written overlaps with the impl in the standard library of impl<T> From<T> for T (that is, anything can be converted to itself).

Specifically,

struct Tricky;

impl Storage for Tricky {
    type Error = MyError<Tricky>;
}

(The set-up here means this doesn’t actually compile—MyError<Tricky> is infinitely large—but that error is unrelated to the reasoning about impls/coherence/overlap, and indeed small changes to MyError can make it compile without changing the fundamental problem, e.g. adding a Box like StorageProblem(Box<S::Error>),.)

If we substitute Tricky in place of S in your impl, we get:

impl From<MyError<Tricky>> for MyError<Tricky> {
    ...
}

This impl exactly matches the self-conversion one with T == MyError<Tricky>, and hence the compiler wouldn’t know which one to choose. Instead of making an arbitrary/random choice, the Rust compiler avoids situations like this, and thus the original code must be rejected due to this risk.

This coherence restriction can definitely be annoying, and is one of reasons that specialisation is a much-anticipated feature: essentially allows manually instructing the compiler how to handle overlap… at least, one of the extensions to the current restricted form allows that.

More Related Contents:

  1. Traits and Rust
  2. Why do try!() and ? not compile when used in a function that doesn’t return Option or Result?
  3. Returning a closure from a function
  4. What is this question mark operator about?
  5. Situations where Cell or RefCell is the best choice
  6. Cannot infer an appropriate lifetime for autoref due to conflicting requirements
  7. How do I borrow a reference to what is inside an Option?
  8. What is lifetime elision in very simple terms?
  9. Why does this read input before printing?
  10. How to create a String directly?
  11. How to create an in-memory object that can be used as a Reader, Writer, or Seek in Rust?
  12. What’s the Rust idiom to define a field pointing to a C opaque pointer?
  13. Can’t borrow mutably within two different closures in the same scope
  14. What is the syntax to match on a reference to an enum?
  15. How can I implement Rust’s Copy trait?
  16. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  17. Why can’t I return an &str value generated from a String?
  18. Is there another option to share an Arc in multiple closures besides cloning it before each closure?
  19. How to implement a custom ‘fmt::Debug’ trait?
  20. How do I pass a closure through raw pointers as an argument to a C function?
  21. What is the prelude?
  22. How to embed resources in Rust executable?
  23. How do I use a crate from another crate without explicitly defining a new dependency in my project?
  24. How do I specify that a struct field must implement a trait?
  25. How do I print an integer in binary with leading zeros?
  26. How does Rust’s type inference work across multiple statements?
  27. Why does Valgrind not detect a memory leak in a Rust program using nightly 1.29.0?
  28. What is the null pointer optimization in Rust?
  29. Is there any way to restrict a generic type to one of several types?
  30. How to pass rustc flags to cargo?

Leave a Comment