mismatched types expected enum Result<_, Box<(dyn StdError + 'static)>> found enum Result<_, anyhow::Error>

[hahazexia]

What does this mean? In the setup function, there is an error.

use ?to coerce and return an appropriateErr, and wrap the resulting value in Okso the expression remains of typeResult: Ok(, ?)rustc[E0308](https://doc.rust-lang.org/error-index.html#E0308) lib.rs(21, 13): original diagnostic mismatched types expected enum Result<, Box<(dyn StdError + 'static)>>found enumResult<, anyhow::Error>rustc[Click for full compiler diagnostic](rust-analyzer-diagnostics-view:/diagnostic%20message%20[2]?2#file:///Users/hahazexia/Desktop/xia/code/comic-dl-tauri/src-tauri/src/lib.rs) lib.rs(21, 13): use ?to coerce and return an appropriateErr, and wrap the resulting value in Okso the expression remains of typeResult: Ok(, ?)``

tauri::Builder::default()
        .setup(|app| {
            if let Err(e) = create_cache_dir() {
                app.emit("err-msg", format!("create cache dir failed!"))
                    .unwrap();
            }
            Ok(())
        })
        .plugin(tauri_plugin_opener::init())
        .invoke_handler(tauri::generate_handler![add, add_new_task])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");

[evanwmart]

So the error type given doesn't match the error type that is received from your create_cache_dir()

It expects to see a type:
Result<(), Box<dyn std::error::Error>>
but gets:
Result<(), anyhow::Error>

I think this is basically saying to try something like:

tauri::Builder::default()
    .setup(|app| {
        create_cache_dir().map_err(|e| {
            app.emit("err-msg", format!("create cache dir failed!"))
                .unwrap();
            e.into() // nifty way to convert the error type into Box<dyn std::error::Error>
        })?;
        Ok(())
    })
    .plugin(tauri_plugin_opener::init())
    .invoke_handler(tauri::generate_handler![add, add_new_task])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");

This is just wrapping your original error type (the type that was not expected) in a new error type format that is acceptable to be received. The ? is just checking if anything breaks and exits if it detects something wrong, if not then it gets passed along. Ok(()) is just there to indicate everything went fine (the rust equivalent of "lgtm").

P.S. nice luffy profile pic, love one piece

[hahazexia]

It's really excellent. You fixed my issue. Then I asked GPT about how to solve the e.into() problem. Now my code runs fine.

the ErrorMsg struct is like this below:

#[derive(Debug)]
#[allow(dead_code)]
pub struct ErrorMsg {
    msg: String,
}

#[warn(dead_code)]
impl ErrorMsg {
    pub fn new(msg: &str) -> ErrorMsg {
        ErrorMsg {
            msg: msg.to_string(),
        }
    }

    pub fn to_string(&self) -> String {
        self.msg.clone()
    }
}

impl fmt::Display for ErrorMsg {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.msg)
    }
}

Then GPT tells me to add a line like this:

impl std::error::Error for ErrorMsg {}

This will fix required for ErrorMsgto implementInto<_>rustcClick for full compiler diagnostic

Finally the code like this:

tauri::Builder::default()
        .setup(|app| {
            if let Err(e) = init_log() {
                error!("init log error: {}", e);
                app.emit("err-msg", format!("init log failed!")).unwrap();
            };
            create_cache_dir().map_err(|e| {
                error!("create cache dir failed: {}", e.to_string());
                app.emit("err-msg", format!("create cache dir failed!"))
                    .unwrap();
                <ErrorMsg as Into<Box<dyn Error>>>::into(e)
            })?;
            Ok(())
        })

There are so many keywords and symbols in the Rust language. Sometimes, I really don't know what they mean, and it's like magic. Since I'm still a learner, thanks for your help.

[hahazexia]

I've just found out if I add this:

impl std::error::Error for ErrorMsg {}

then there is no need to add into to convert the error type. The code can run normally with the previous writing method.😂😂😂😂😂

.setup(|app| {
            if let Err(e) = init_log() {
                error!("init log error: {}", e);
                app.emit("err-msg", format!("init log failed!")).unwrap();
            };
            if let Err(e) = create_cache_dir() {
                error!("create cache dir failed: {}", e.to_string());
                app.emit("err-msg", format!("create cache dir failed!"))
                    .unwrap();
            };
            // create_cache_dir().map_err(|e| {
            //     error!("create cache dir failed: {}", e.to_string());
            //     app.emit("err-msg", format!("create cache dir failed!"))
            //         .unwrap();
            //     <ErrorMsg as Into<Box<dyn Error>>>::into(e)
            // })?;
            Ok(())
        })