Rust chaining Results (Combinators)

Question

I've been following a Rust tutorial where two versions of a function are purported to generate the same results:

Version 1:

pub fn get_transactions(fname:&str) -> Result<Vec<Transaction>,String> {
    let s = match std::fs::read_to_string(fname){
        Ok(v)=>v,
        Err(e)=> return Err(e.to_string()),
    };
    let t:Vec<Transaction> = match serde_json::from_str(&s) {
        Ok(v)=>v,
        Err(e)=> return Err(e.to_string()),
    };
    Ok(t)
}

Version 2:

fn get_transactions_b(fname:&str) -> Result<Vec<Transaction>,String> {
    std::fs::read_to_string(fname)
    .map_err(|e| e.to_string())
    .and_then(|ld| serde_json::from_str(&ld) )
    .map_err(|e| e.to_string())
}

---

However, I get the following message for version 2:

mismatched types

expected struct std::string::String, found struct serde_json::error::Error

note: expected enum std::result::Result<_, std::string::String> found enum std::result::Result<_, serde_json::error::Error>

help: try using a variant of the expected enum: _::_serde::export::Ok(serde_json::from_str(&ld)),

---

which I been unable to make head or tail out of:

• Hovering over ld closure argument |ld| in VS Code it says it's of type std::string::String

• Hovering over the ld in the from_str(&ld) I get the message.

• Now I understand a Result is comprised of an Ok and an Err, but I thought the combinator chaining would have worked.

• The compiler suggested fix doesn't work either.

  • (or make sense): What is the _::_ all about?
  • Why would the Ok not be inside the from_str?

• What would you have to do to make version 2 work?

Here's the Result with the methods for combinators in the Rust docs.

---

Cargo.toml

[dependencies]
serde = "1.0.115"
serde_derive = "1.0.115"
serde_json = "1.0.57"

---

• cargo 1.45.1
• rustc 1.45.2

Gangplank

Results need to have same Error type to combine them. For your problem you need to remove the first map_err(|e| e.to_string()), it changes the type of Error as a result you cannot serde_json::from_str(&ld) inside and_then because their Error type doesn't match. – Cioffred

The two commands 1) reading the file and 2) converting its content to JSON have their own individual errors. So will one map_err suffice? – Gangplank

Nope if error types are different you need to make it same then you should move the second map_err like this and_then(|ld| serde_json::from_str(&ld).map_err(|e| e.to_string()); . With this way both will have the same error type, – Cioffred

That doesn't work either.: expected struct std::io::Error, found struct serde_json::error::Error (I thought whole purpose of combinators was to be able to chain) – Gangplank

Nope for this case you shouldn't remove the first, just move the second one, please check: play.rust-lang.org/… – Cioffred

Ah.. got you. That makes sense now. The error should be within. – Gangplank

@ÖmerErden If you want to post that as an answer, I'll accept it . Thanks. – Gangplank

It is ok, you can accept current answer if it also solves the problem. – Cioffred

Answer 1

The problem comes from the and_then call.

You are not allowed to change the error type when calling and_then. So your function there should return a Result<Vec<Transaction>, String>. However, the error type returned by serde_json::from_str is a serde_json::error::Error.

You can fix it like this:

std::fs::read_to_string(fname)
    .map_err(|e| e.to_string())
    .and_then(|ld| serde_json::from_str(&ld).map_err(|e| e.to_string()))

Notice the call to map_err is now inside the function passed to and_then.

Lenorelenox