error[E0277]: ? couldn't convert the error to *, when the error is already the same type but in a different module scope

[alerque]

I have a fairly convoluted crate that gets used is several different contexts (compiled to WASM, into a Lua module, into a Python module, etc.). I'm trying to refactor it a bit to avoid panics that can cross those boundaries ... because duh! However the resulting error handling using Snafu is giving me conniptions. The actual code in context is here, but I've gotten as far as distilling it down to a similar set of scopes and trait implementations in MWE that can be run with rust-script from a single file:

#!/usr/bin/env rust-script

//! ```cargo
//! [dependencies]
//! snafu = "0.8"
//! strum_macros = "0.27"
//! ```

mod othertypes {
    use snafu::prelude::*;
    use std::convert::{Infallible, TryFrom};
    use std::str::FromStr;
    use strum_macros::Display;

    #[derive(Snafu)]
    pub enum ColorError {
        #[snafu(display("failed to to parse '{input}'"))]
        UnknownColor { input: String },
    }

    impl std::fmt::Debug for ColorError {
        fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
            std::fmt::Display::fmt(self, fmt)
        }
    }

    impl From<Infallible> for ColorError {
        fn from(_: Infallible) -> Self {
            unreachable!("Infallible errors should never occure")
        }
    }

    pub type Result<T, E = ColorError> = std::result::Result<T, E>;

    #[derive(Debug, Display, Clone, Copy)]
    pub enum Color {
        Red,
        Green,
    }

    impl FromStr for Color {
        type Err = ColorError;
        fn from_str(s: &str) -> Result<Self> {
            Ok(match s {
                "red" => Color::Red,
                "green" => Color::Green,
                input => UnknownColorSnafu { input }.fail()?,
            })
        }
    }

    impl TryFrom<&str> for Color {
        type Error = ColorError;
        fn try_from(s: &str) -> Result<Self> {
            Self::from_str(s)
        }
    }
}

use othertypes::{Color, Result};

fn takes_a_try(input: impl TryInto<Color>) -> Result<String> {
    let color: Color = input.try_into()?;
    Ok(color.to_string())
}

fn main() -> Result<()> {
    let inputs = ["red", "green", "blue"];
    for input in &inputs {
        let color = takes_a_try(*input)?;
        println!("Success: parsed '{input}' -> {color}");
    }
    Ok(())
}

The result I get throws these errors:

$ rust-script snafu-wazu.rs
error[E0277]: `?` couldn't convert the error to `ColorError`
  --> /home/caleb/scratch/snafu-wazu.rs:63:40
   |
62 | fn takes_a_try(input: impl TryInto<Color>) -> Result<String> {
   |                                               -------------- expected `ColorError` because of this
63 |     let color: Color = input.try_into()?;
   |                              ----------^ the trait `From<<impl TryInto<Color> as TryInto<Color>>::Error>` is not implemented for `ColorError`
   |                              |
   |                              this can't be annotated with `?` because it has type `Result<_, <impl TryInto<Color> as TryInto<Color>>::Error>`
   |
note: `ColorError` needs to implement `From<<impl TryInto<Color> as TryInto<Color>>::Error>`
  --> /home/caleb/scratch/snafu-wazu.rs:16:5
   |
16 |     pub enum ColorError {
   |     ^^^^^^^^^^^^^^^^^^^
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait

For more information about this error, try `rustc --explain E0277`.
error: could not compile `snafu-wazu_b0c5d36811b0565c3d2fece2` (bin "snafu-wazu_b0c5d36811b0565c3d2fece2") due to 1 previous error

For the life of me I can't figure out why the ? operator is having trouble converting error types given that everything here is already the same error type. I was unable to replicate this error without the extra layers of complexity caused by having the error types and other things in a different module scope than the functions running them.

I did figure out ways to work around this, mostly by using .map_err() to flatten the error and re-create it, but its a mess and I'd like to clean it up and keep it simple. Why isn't this error type propagating?

[shepmaster]

Further minimized:

use snafu::prelude::*;
use std::convert::TryFrom;

#[derive(Debug, Snafu)]
pub enum ColorError {
    UnknownColor { input: String },
}

pub type Result<T, E = ColorError> = std::result::Result<T, E>;

#[derive(Debug, Clone, Copy)]
pub struct Color;

impl TryFrom<&str> for Color {
    type Error = ColorError;

    fn try_from(_: &str) -> Result<Self> {
        Ok(Color)
    }
}

fn takes_a_try(input: impl TryInto<Color>) -> Result<()> {
    let color: Color = input.try_into()?;
    Ok(())
}

fn main() -> Result<()> {
    Ok(())
}

error[E0277]: `?` couldn't convert the error to `ColorError`
  --> src/main.rs:23:40
   |
22 | fn takes_a_try(input: impl TryInto<Color>) -> Result<()> {
   |                                               ---------- expected `ColorError` because of this
23 |     let color: Color = input.try_into()?;
   |                              ----------^ the trait `From<<impl TryInto<Color> as TryInto<Color>>::Error>` is not implemented for `ColorError`
   |                              |
   |                              this can't be annotated with `?` because it has type `Result<_, <impl TryInto<Color> as TryInto<Color>>::Error>`
   |
note: `ColorError` needs to implement `From<<impl TryInto<Color> as TryInto<Color>>::Error>`
  --> src/main.rs:5:1
   |
 5 | pub enum ColorError {
   | ^^^^^^^^^^^^^^^^^^^
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait

---

given that everything here is already the same error type

This is not guaranteed. For example, one could add

impl TryFrom<bool> for Color {
    type Error = String;

    fn try_from(_: bool) -> Result<Self, Self::Error> {
        Ok(Color)
    }
}

Your argument requires that something is convertible to a Color, but makes no requirements on the error type. You need to change the function signature to do so:

fn takes_a_try(input: impl TryInto<Color, Error = ColorError>) -> Result<()> {

Note that nothing here is SNAFU-specific.

[alerque]

Note that nothing here is SNAFU-specific.

Fair enough. Thanks for the pointers. I did think it might be Snafu specific in that their are extra structs being created and the derive macros even can be used to specific different scopes and I expected the solution to come from that quarter.

given that everything here is already the same error type

This is not guaranteed. For example, one could add

impl TryFrom for Color {
type Error = String;

But I didn't. I could add a lot of things that would break this, but I kind of expected the compiler to error based on the code I asked it to compile, not some theoretical other code I could add later.

(Yes I'm still a little confused on this point.)

Your argument requires that something is convertible to a Color, but makes no requirements on the error type. You need to change the function signature to do so:

fn takes_a_try(input: impl TryInto<Color, Error = ColorError>) -> Result<()> {

Aah yes. I should have mentioned I actually found that as a potential work around when I was coming up with this MWE. Unfortunately I also discarded it as impractical since specifying the error type for input traits makes the function much less flexible than I need it to be.

Armed with your redirection back to that point, I hacked on it some more and I think I came up with something that actually covers my use case, which includes functioning for for infalliable types. It does involve a bit of shenanigans casting Infallible into an error and specifying error traits, but it can be done. For anybody else that lands here later facing a similar conundrum, here is the MWE above with the relevant features added:

#!/usr/bin/env rust-script

//! ```cargo
//! [dependencies]
//! snafu = "0.8"
//! ```

use snafu::prelude::*;
use std::convert::TryFrom;

#[derive(Debug, Snafu)]
pub enum ColorError {
    UnknownColor {},
}

impl From<std::convert::Infallible> for ColorError {
    fn from(_: std::convert::Infallible) -> Self {
        unreachable!("If you got here, the universe is inside out.")
    }
}

pub type Result<T, E = ColorError> = std::result::Result<T, E>;

pub struct Color;

impl TryFrom<&str> for Color {
    type Error = ColorError;

    fn try_from(_: &str) -> Result<Self> {
        Ok(Self)
    }
}

fn takes_a_try<T>(input: T) -> Result<()>
where
    T: TryInto<Color>,
    ColorError: From<T::Error>,
{
    let _: Color = input.try_into()?;
    Ok(())
}

fn main() {
    let _ = takes_a_try("");
    let _ = takes_a_try(Color);
}

[shepmaster]

But I didn't. I could add a lot of things that would break this, but I kind of expected the compiler to error based on the code I asked it to compile, not some theoretical other code I could add later.

Generally that's not the way Rust works. For example, this generic function is "fine" because it's never misused, but the compiler will error regardless:

fn add<T>(a: T) {
    a + a
}

fn main() {
    add(1u8);
}

Additionally, it's not restricted to what you do. For example, someone could implement the trait in a crate that calls your code:

use library::Color;

struct PrettyColor;

impl TryFrom<PrettyColor> for Color {
    type Error = String;

    fn try_from(_: PrettyColor) -> Result<Self, Self::Error> {
        Ok(Color)
    }
}

fn main() {
    library::takes_a_try(PrettyColor);
}

[shepmaster]

since specifying the error type for input traits makes the function much less flexible than I need it to be.

I don't follow this statement. You started out by stating that you expect that everything will be using the same error type, so you already have accepted that inflexibility. Changing the argument type would only reflect your expectations.

However, looking at your example, you definitely don't want everything to be the same error type — sometimes you want an error type of Infallible and sometimes you want ColorError.