Rust 错误
2022/8/6 23:25:06
本文主要是介绍Rust 错误，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
一个简单的需求：读入一个目录内的所有文本文件，每个文件的格式都是每一行定义一个二维点，例如x=1,y=2；获取所有点的一个列表。这里不使用serde或者现成的parser库，这么简单的格式直接手写就行了
没有错误处理
先来一个糙快猛的版本。其中用了一个nightly feature str_split_once，不过这不重要
#![feature(str_split_once)]
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
#[derive(Debug)]
struct Directory(Vec<(&'static str, &'static str)>);
fn parse_file(text: &str) -> Vec<Point> {
let mut points = Vec::new();
for line in text.lines() {
let mut x = None;
let mut y = None;
for field in line.split(',') {
let (k, v) = field.split_once('=').unwrap(); // todo
match k.trim() {
"x" => { x = Some(v.trim().parse().unwrap()); }, // todo
"y" => { y = Some(v.trim().parse().unwrap()); }, // todo
_ => {}, // todo
}
}
points.push(Point { x: x.unwrap(), y: y.unwrap() }); // todo
}
points
}
fn main() {
let d = Directory(vec![
("file1", "x=3,y=4\nx=1,y=2")
]);
for (filename, text) in &d.0 {
println!("{} {:?}", filename, parse_file(text));
}
}
标准的错误处理
上面的代码里留下了5个todo。想成为一段健壮的程序，它们全部都要处理。这里使用了thiserror库，要换成snafu或者手写也是完全没问题的。代码行数一下就翻倍了，不过看起来是那么的正确
#![feature(str_split_once)]
use std::num::ParseIntError;
use thiserror::Error;
use fehler::{throws, throw};
use self::ParseFileError::*;
#[derive(Error, Debug)]
enum ParseFileError {
#[error("no equal sign found: `{field}` in line `{line}`")]
NoEqualSign { field: String, line: String },
#[error("parse x as i32 failed: `{field}` in line `{line}`")]
XParseFailed { source: ParseIntError, field: String, line: String },
#[error("parse y as i32 failed: `{field}` in line `{line}`")]
YParseFailed { source: ParseIntError, field: String, line: String },
#[error("unknown key: `{field}` in line `{line}`")]
UnknownField { field: String, line: String},
#[error("x not found: `{line}`")]
XNotFound { line: String },
#[error("y not found: `{line}`")]
YNotFound { line: String },
}
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
#[derive(Debug)]
struct Directory(Vec<(&'static str, &'static str)>);
#[throws(ParseFileError)]
fn parse_file(text: &str) -> Vec<Point> {
let mut points = Vec::new();
for line in text.lines() {
let mut x = None;
let mut y = None;
for field in line.split(',') {
let (k, v) = field.split_once('=').ok_or_else(|| NoEqualSign {
field: field.into(),
line: line.into(),
})?;
match k.trim() {
"x" => { x = Some(v.trim().parse().map_err(|e| {
XParseFailed {
source: e,
field: field.into(),
line: line.into(),
}
})?); },
"y" => { y = Some(v.trim().parse().map_err(|e| {
YParseFailed {
source: e,
field: field.into(),
line: line.into(),
}
})?); },
_ => {
throw!(UnknownField {
field: field.into(),
line: line.into(),
})
},
}
}
points.push(Point {
x: x.ok_or_else(|| XNotFound { line: line.into() })?,
y: y.ok_or_else(|| YNotFound { line: line.into() })?,
});
}
points
}
fn main() {
let d = Directory(vec![
("file1", "x=3,y=4\nx=1,y=2")
]);
for (filename, text) in &d.0 {
println!("{} {:?}", filename, parse_file(text));
}
}
同时返回多个错误
需求方说，你的程序的错误报告做得非常好，不过如果能够同时报告所有错误，那就完美了。于是我们又给ParseFileError加上了List的variant：
#![feature(str_split_once)]
use std::num::ParseIntError;
use thiserror::Error;
use fehler::{throws, throw};
use self::ParseFileError::*;
#[derive(Error, Debug)]
enum ParseFileError {
#[error("no equal sign found: `{field}` in line `{line}`")]
NoEqualSign { field: String, line: String },
#[error("parse x as i32 failed: `{field}` in line `{line}`")]
XParseFailed { source: ParseIntError, field: String, line: String },
#[error("parse y as i32 failed: `{field}` in line `{line}`")]
YParseFailed { source: ParseIntError, field: String, line: String },
#[error("unknown key: `{field}` in line `{line}`")]
UnknownField { field: String, line: String},
#[error("x not found: `{line}`")]
XNotFound { line: String },
#[error("y not found: `{line}`")]
YNotFound { line: String },
#[error("multiple errors")]
List(Vec<ParseFileError>),
}
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
#[derive(Debug)]
struct Directory(Vec<(&'static str, &'static str)>);
#[throws(ParseFileError)]
fn parse_file(text: &str) -> Vec<Point> {
let mut points = Vec::new();
let mut error_list = Vec::new();
for line in text.lines() {
let mut line_error_list = Vec::new();
let mut x = None;
let mut y = None;
for field in line.split(',') {
let (k, v) = match field.split_once('=') {
Some((k, v)) => (k, v),
None => {
line_error_list.push(NoEqualSign {
field: field.into(),
line: line.into(),
});
continue; // 后面的解析都没有意义了，直接continue。如果parse_line是一个单独的函数，这里相当于无视收集错误可以直接用?返回。懒得展示了……
}
};
match k.trim() {
"x" => {
// 写起来会很麻烦……
match v.trim().parse() {
Ok(xx) => x = Some(xx),
Err(e) => {
line_error_list.push(XParseFailed {
source: e,
field: field.into(),
line: line.into(),
});
},
}
},
"y" => {
// 或者可以这样“简洁”地写
y = v.trim().parse().map_err(|e| {
line_error_list.push(YParseFailed {
source: e,
field: field.into(),
line: line.into(),
});
() // 可省略
}).ok();
},
_ => {
line_error_list.push(UnknownField {
field: field.into(),
line: line.into(),
});
},
}
}
// 可能需求会是如果此行没有找到等号，就不用报告找不到x/y的错误了
// 或者如果解析x时出错，也不用报告找不到x的错误
// 这里就不处理那么多了……
if x.is_none() {
line_error_list.push(XNotFound {
line: line.into(),
});
}
if y.is_none() {
line_error_list.push(YNotFound {
line: line.into(),
});
}
if line_error_list.is_empty() {
points.push(Point {
x: x.unwrap(),
y: y.unwrap(),
});
} else {
error_list.extend(line_error_list);
}
}
if error_list.is_empty() {
points
} else {
throw!(List(error_list));
}
}
fn main() {
let d = Directory(vec![
("file1", "x=3,y=4t\nx=1,y=2,z=3")
]);
for (filename, text) in &d.0 {
println!("{} {:?}", filename, parse_file(text));
}
}
支持警告
甲方爸爸又来了，先是惯例地夸赞了一番，然后说，某些数据里除了x、y之外，还可能有z、w等等字段，它们直接忽略即可，就不用报错了。不过呢，如果能够输出一句警告，说明哪个文件的哪一行有这些字段，那就能让这个完美的工具更完美了。
@@ -3,7 +3,7 @@
use std::num::ParseIntError;
use thiserror::Error;
-use fehler::{throws, throw};
+use w_result::WResult;
use self::ParseFileError::*;
@@ -35,10 +35,10 @@ struct Point {
#[derive(Debug)]
struct Directory(Vec<(&'static str, &'static str)>);
-#[throws(ParseFileError)]
-fn parse_file(text: &str) -> Vec<Point> {
+fn parse_file(text: &str) -> WResult<Vec<Point>, ParseFileError, ParseFileError> {
let mut points = Vec::new();
let mut error_list = Vec::new();
+ let mut warning_list = Vec::new();
for line in text.lines() {
let mut line_error_list = Vec::new();
let mut x = None;
@@ -80,7 +80,7 @@ fn parse_file(text: &str) -> Vec<Point> {
}).ok();
},
_ => {
- line_error_list.push(UnknownField {
+ warning_list.push(UnknownField {
field: field.into(),
line: line.into(),
});
@@ -113,18 +113,18 @@ fn parse_file(text: &str) -> Vec<Point> {
}
if error_list.is_empty() {
- points
+ WResult::WOk(points, warning_list)
} else {
- throw!(List(error_list));
+ WResult::WErr(List(error_list))
}
}
这次的改动比较小，主要就是引入WResult。继放弃?之后，fehler也被放弃了。
MyResult
现在的代码已经非常别扭了。如果一开始就知道有这些需求，应该怎么设计呢？我们已经用过了标准库里的Result，第三方的WResult，试试自己定义的MyResult。下面是经过了几次整理的最终代码，自我感觉思路应该是对了。命名等比较随意就不要追究了。
#![feature(str_split_once)]
#![feature(try_trait)]
#[macro_use] extern crate shrinkwraprs;
use std::num::ParseIntError;
use std::fmt::{self, Debug};
use std::error::Error as _;
use std::ops::Try;
use thiserror::Error;
use self::ParseLineError::*;
use self::MyResult::{MyOk, MyErr};
use self::MyError::{Collected, Fatal};
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
#[derive(Debug)]
struct Directory(Vec<(&'static str, &'static str)>);
#[derive(Debug, Shrinkwrap)]
#[shrinkwrap(mutable)]
struct Warnings<E>(Vec<E>);
impl<E> Warnings<E> {
fn new() -> Self {
Self(Vec::new())
}
}
impl<E: Debug> From<Warnings<E>> for MyError<E> {
fn from(warn: Warnings<E>) -> Self {
Collected(warn.0)
}
}
#[derive(Debug, Error)]
enum MyError<E: Debug> {
Collected(Vec<E>),
Fatal(E),
}
impl<E: Debug> fmt::Display for MyError<E> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:?}", self)
}
}
#[must_use]
#[derive(Debug)]
enum MyResult<T, E: Debug> {
MyOk {
ok: T,
warn: Warnings<E>,
},
MyErr(MyError<E>),
}
impl<T, E: Debug> Try for MyResult<T, E> {
type Ok = T;
type Error = E;
fn into_result(self) -> Result<T, E> {
unimplemented!()
}
fn from_ok(v: T) -> Self {
MyOk {
ok: v,
warn: Warnings::new(),
}
}
fn from_error(v: E) -> Self {
MyErr(Fatal(v))
}
}
impl<T, E: Debug> MyResult<T, E> {
fn drain_warning(self, f: &dyn Fn(E)) -> MyResult<T, E> {
match self {
MyOk {ok, mut warn} => {
for w in warn.drain(..) {
f(w);
}
MyOk {
ok,
warn: Warnings::new(),
}
},
MyErr(e) => MyErr(e),
}
}
}
#[derive(Error, Debug)]
enum ParseLineError {
#[error("no equal sign found: `{field}`")]
NoEqualSign { field: String },
#[error("parse x as i32 failed: `{field}`")]
XParseFailed { source: ParseIntError, field: String },
#[error("parse y as i32 failed: `{field}`")]
YParseFailed { source: ParseIntError, field: String },
#[error("unknown key: `{field}`")]
UnknownField { field: String},
#[error("x not found")]
XNotFound,
#[error("y not found")]
YNotFound,
}
fn ok_wrapping<T, E: Debug>(ok: impl FnOnce() -> T, warning_list: Warnings<E>, error_list: Vec<E>) -> MyResult<T, E> {
if error_list.is_empty() {
MyOk {
ok: ok(),
warn: warning_list,
}
} else {
MyErr(Collected(error_list))
}
}
fn parse_line(line: &str) -> MyResult<Point, ParseLineError> {
let mut warning_list = Warnings::new();
let mut error_list = Vec::new();
let mut x = None;
let mut y = None;
for field in line.split(',') {
let (k, v) = match field.split_once('=') {
Some((k, v)) => (k, v),
None => {
return MyErr(Fatal(NoEqualSign {
field: field.into(),
})); // 为MyResult实现了Try，也可以使用?：Err(NoEqualSign { field: field.into(), })?
}
};
match k.trim() {
"x" => {
// 写起来会很麻烦……
match v.trim().parse() {
Ok(xx) => x = Some(xx),
Err(e) => {
error_list.push(XParseFailed {
source: e,
field: field.into(),
});
},
}
},
"y" => {
// 或者可以这样“简洁”地写
y = v.trim().parse().map_err(|e| {
error_list.push(YParseFailed {
source: e,
field: field.into(),
});
() // 可省略
}).ok();
},
_ => {
warning_list.push(UnknownField {
field: field.into(),
});
},
}
}
// 可能需求会是如果此行没有找到等号，就不用报告找不到x/y的错误了
// 或者如果解析x时出错，也不用报告找不到x的错误
// 这里就不处理那么多了……
if x.is_none() {
error_list.push(XNotFound);
}
if y.is_none() {
error_list.push(YNotFound);
}
ok_wrapping(|| Point {
x: x.unwrap(),
y: y.unwrap(),
}, warning_list, error_list)
}
#[derive(Error, Debug)]
enum ParseFileError {
#[error("parse line failed: `{line}`")]
Line {line: String, source: MyError<ParseLineError>},
}
fn parse_file(text: &str) -> MyResult<Vec<Point>, ParseFileError> {
let mut points = Vec::new();
let mut warning_list = Warnings::new();
let mut error_list = Vec::new();
for line in text.lines() {
match parse_line(line) {
MyOk { ok, warn } => {
points.push(ok);
if !warn.is_empty() {
warning_list.push(ParseFileError::Line {
line: line.into(),
source: warn.into(),
});
}
},
MyErr(e) => {
error_list.push(ParseFileError::Line {
line: line.into(),
source: e,
});
}
}
}
ok_wrapping(|| points, warning_list, error_list)
}
#[derive(Error, Debug)]
enum ParseDirectoryError {
#[error("parse file failed: `{file}`")]
File {file: String, source: MyError<ParseFileError>},
}
fn parse_directory(directory: &Directory) -> MyResult<Vec<Point>, ParseDirectoryError> {
let mut points = Vec::new();
let mut warning_list = Warnings::new();
let mut error_list = Vec::new();
for (filename, text) in &directory.0 {
match parse_file(text) {
MyOk { ok, warn } => {
points.extend(ok);
if !warn.is_empty() {
warning_list.push(ParseDirectoryError::File {
file: (*filename).into(),
source: warn.into(),
});
}
},
MyErr(e) => {
error_list.push(ParseDirectoryError::File {
file: (*filename).into(),
source: e,
});
}
}
}
ok_wrapping(|| points, warning_list, error_list)
}
fn main() {
let d = Directory(vec![
("file1", "x=3,y=4\nx=1,y=2,z=3")
]);
let r = parse_directory(&d).drain_warning(&|e| {
println!("{}", e);
if let Some(s) = e.source() {
println!("caused by: {}", s);
}
});
println!("{:?}", r);
}
- 确实每个函数都应该有一个错误类型，甚至可以有多个，例如ParseLineError可以再抽一个ParseFieldError出来，反复出现的field字段就是征兆
- 错误的来源可以是多个，最终是树状结构。正如rfc2965里说的那样（RustConf 2020的报告里也提到了）：(Pain points) (The
Errortrait) can only represent singly-linked lists for chains of errors。现在的状态Error Reporter并不能太好地工作 - 函数独立地决定某个错误是Error还是Warning，但调用者可以把自己对应的错误放到自己的error_list或warning_list里，甚至直接丢弃。例如需求可能是，file1可以有xy之外的字段不用管，其它文件则需要警告。比起把额外的信息传入parse_line函数，在parse_directory里处理UnknownField会更清晰
- Warning的类型和Error一致，不要再单独弄个枚举。如果参考log的术语，似乎还应该有info/debug/trace等等，但我暂时认为它们不需要返回给调用者
- 如果Rust支持匿名枚举，也许不需要特意定义MyError了
错误处理真是太累了……总之暂时先用这个思路试试看效果如何。当然绝大部分情况下我肯定都会偷懒，但至少需要返回错误列表时我会统一使用MyResult而不是一会Vec<Result<()>>一会Vec<Error>了
转自:
作者:
juu wiio https://zhuanlan.zhihu.com/p/234820782
这篇关于Rust 错误的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-23Springboot应用的多环境打包入门
- 2024-11-23Springboot应用的生产发布入门教程
- 2024-11-23Python编程入门指南
- 2024-11-23Java创业入门：从零开始的编程之旅
- 2024-11-23Java创业入门：新手必读的Java编程与创业指南
- 2024-11-23Java对接阿里云智能语音服务入门详解
- 2024-11-23Java对接阿里云智能语音服务入门教程
- 2024-11-23JAVA对接阿里云智能语音服务入门教程
- 2024-11-23Java副业入门：初学者的简单教程
- 2024-11-23JAVA副业入门：初学者的实战指南
