匹配结果类型时提前退出

Question

我有一个带有Result 类型参数的方法。我非常喜欢链接，所以我在参数上使用and_then。在某些时候，我想有条件地从and_then 内部返回整个方法（因此有机会可以调用另一个and_then 方法）：

enum Good {
    Ok,
    Good,
    VeryGood,
}
enum Pizza {
    Tomato,
    Pineapple,
}
enum Burger {
    Cow,
}

enum Food {
    Pizza(Pizza),
    Burger(Burger),
}

fn main() {}

fn s(r: Result<Good, ()>) -> Result<Food, ()> {
    r.and_then(|o| {
        match o {
            // Should be called in the next and_then block
            Good::Ok => Ok(Pizza::Tomato),
            // Should be called in the next and_then block
            Good::Good => Ok(Pizza::Pineapple),
            Good::VeryGood => {
                // I am done. Don't call the next and_then block, but rather return the whole value to the caller.
                return Ok(Food::Burger(Burger::Cow));
            }
        }
    })
    .and_then(|p: Pizza| {
        // At this point, the closure input value should be pizza, because that's the only returned value
        Ok(Food::Pizza(p))
    })
}

Playground

我得到各种编译器错误：

error[E0308]: mismatched types
  --> src/main.rs:30:27
   |
30 |                 return Ok(Food::Burger(Burger::Cow));
   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `Pizza`, found enum `Food`
   |
   = note: expected type `Pizza`
              found type `Food`

我希望有办法让它编译。我可以分解该方法并摆脱and_then，但也许有and_then 的方法。

在我的真实代码中，我有更多 and_then 将类型映射到其他类型、错误映射等，所以这是我面临的问题的简化再现路径。

这是我的代码库中复制粘贴的代码，显示了多个 and_then。我将来自外部库的错误映射到我自己的错误类型中，因此如果有错误可以自动返回。我想继续更改从and_then 获得的类型，这样我最终可以获得User 类型（尽管它目前不起作用）。一种选择是不链接块并创建单独的值，但我希望我可以直接将值返回给闭包内的调用者。

db_session
    .query_with_values(query, values)
    .map_err(|e| {
        error!("{:?}", e);
        TechnicalServerError::SERVER_RETRY
    })
    .and_then(|f| {
        f.get_body().map_err(|e| {
            error!("{:?}", e);
            TechnicalServerError::SERVER_RETRY
        })
    })
    .and_then(|b| b.into_rows().ok_or(TechnicalServerError::SERVER_RETRY))
    .and_then(|mut c| {
        if let Some(row) = c.pop() {
            User::try_from_row(row).map_err(|e| {
                error!("{:?}", e);
                TechnicalServerError::SERVER_INVALID
            })
        } else {
            return Ok(Login::Other(LoginResult::UNKNOWN_USER));
        }
    })
    .and_then(|u| {
        // 'u' should be of type 'user' at this point
        // some user code here...
    })

Answer 1

查看您编辑的示例，我创建了一个approximate example：

// ...
    .and_then(|b| b.into_rows().ok_or(TechnicalServerError::SERVER_RETRY))
    .and_then(|mut c| {
        if let Some(row) = c.pop() {
            User::try_from_row(row).map_err(|e| {
                error!("{:?}", e);
                TechnicalServerError::SERVER_INVALID
            })
        } else {
            return Ok(Login::Other(LoginResult::UNKNOWN_USER))
        }
    }).and_then(|u| {
        // 'u' should be of type 'user' at this point
        // some user code here...

我认为对于and_then 的作用存在基本的误解。

• and_then 采用Result<T, E>，以及将T 转换为Result<U, E> 的函数（即FnOnce(T) -> Result<U, E>。当您想同时操作Ok(val) 和Error 时使用此函数，例如你想改变重新映射错误并做一些值处理。

• map 采用Result<T, E> 和一个将T 转换为另一个值U（即FnOnce(T) -> U）的函数。当您想更改 Ok(val) 而不影响 Error 部分时，请使用此选项。

你说你想改变用户，这可能是这样的：

db_session
    .query_with_values(true)
    .map_err(|e| {
        println!("{:?}", e);
        MyError::ServerRetry
    })
    .and_then(|f| f.get_body(true).map_err(|e2|{
        println!("{:?}", e2);
        MyError::ServerRetry
    }))
    .and_then(|b| b.into_rows(true).ok_or(MyError::ServerRetry))
    .and_then(|mut c|{
        if let Some(row) = c.pop() {
            User::from_row(row).map_err(|e3| {
                println!("{:?}", e3);
                MyError::ServerRetry
            })
        } else {
            return Ok(User{ name: "X".to_string()})
        }
    })
    .map(|mut user| {
        user.name = "CHANGED".to_string();
        user
    });

Rust playground.

但是，正如您所见，查询的值将始终为Result<User, Error>，直接对该值进行操作的唯一方法是unwrap，但如果遇到错误则会出现恐慌。或者，您可以使用if let 来获取值而不会惊慌。

Answer 2

不是一个干净的。换成? 怎么样？

fn s(r: Result<Good, ()>) -> Result<Food, ()> {
    let p = match r? {
        // Should be called in the next and_then block
        Good::Ok => Pizza::Tomato,
        // Should be called in the next and_then block
        Good::Good => Pizza::Pineapple,
        Good::VeryGood => {
            return Ok(Food::Burger(Burger::Cow));
        },
    };

    Ok(Food::Pizza(p))
}