关于Rust的两个小发现

写代码过程中的两个关于 Rust 的小发现，可能对我是发现，但对大家已经是耳熟能详的了，不过还是要记录一下:

如何在 iter tool function 中处理 error

假设有一个整数数组 l, 我们要遍历这个数组，把其中的每个元素都乘以 2，然后把结果收集起来, 但是如果这个数组里面包含负数，则返回一个错误。

以前写类似功能的代码的时候，我一般都这么写:

fn for_loop_double(l: Vec<i32>) -> Result<Vec<i32>, MyError> {
    let mut res = Vec::new();
    for v in l {
        if v < 0 {
            return Err(MyError::NegativeError);
        }
        res.push(v * 2);
    }
    Ok(res)
}

你说为什么不用 iter().map()? 我也想用，但是传到 map()里的是个 closure， 你是无法在 closure 里控制 caller function 直接 return 的。其实我也一直觉得 Rust 应该不至于这么弱，这种问题如果没有一个好的解决方案，实在是愧对最受喜爱的语言的名号。于是就有了今天的这个发现, 先贴代码

fn iter_double(l: Vec<i32>) -> Result<Vec<i32>, MyError> {
    l.into_iter()
        .map(|v| {
            if v < 0 {
                return Err(MyError::NegativeError);
            }
            Ok(v * 2)
        })
        .collect()
}

我一直认为像上面这样用 collect()得到的结果应该是Vec<Result<i32, MyError>>, 今天实在是受不了各种 for 了(顺便说一句，这也是我从 go 叛逃到 rust 的原因), 上网搜解决方案。结果不出意料的找到了。捎带人家还简单解释了一下(原链接)

#[derive(Debug)]
struct Item;
type Id = String;

fn find(id: &Id) -> Result<Item, String> {
    Err(format!("Not found: {:?}", id))
}

fn main() {
    let s = |s: &str| s.to_string();
    let ids = vec![s("1"), s("2"), s("3")];

    let items: Result<Vec<_>, _> = ids.iter().map(find).collect();
    println!("Result: {:?}", items);
}

Result implements FromIterator, so you can move the Result outside and iterators will take care of the rest (including stopping iteration if an error is found).

原来 rust 的 iterator 还有遇到 error 自动终止这功能。但是如果我不希望遇到 error 终止，并且想把 error 放到结果里面怎么办？真正令我觉得 rust 这最受欢迎奖名副其实的时刻来了。先看代码:

fn iter_err_double(l: Vec<i32>) -> Vec<Result<i32, MyError>> {
    l.into_iter()
        .map(|v| {
            if v < 0 {
                return Err(MyError::NegativeError);
            }
            Ok(v * 2)
        })
        .collect()
}

这跟iter_double()完全一样，唯一的差别就是返回值从Result<Vec<i32>, MyError>换成了Vec<Result<i32>, MyError>。

测试一下:

    fn it_works() {
        assert_eq!(
            iter_err_double(vec![1, 2, -1, 4]),
            vec![Ok(2), Ok(4), Err(MyError::NegativeError), Ok(8)]
        );
    }

居然通过了…
是我浅薄了…
从今往后不管 go 添不添泛型，rust 反正是一定会待在我的工具包里了。

关于变量的初始化

大家都知道，在 rust 里没有 null，没有未初始化的默认值, 总之你说这地方有一个杯子，那这个地方就一定得有一个杯子，杯子的大小颜色当场就得确认，没有什么杯子还在路上我们先占下这个地方一会儿拿过来放这的说法。但是今天写东西的时候无意间试了一下只声明不初始化，居然成功了(当然这都是表面现象，实际还是要初始化，各位看官别看到这直接关了浏览器出门宣扬错误理论去。 在 rust 里(除了 unsafe 部分), 就是没有未初始化的变量, 这点毋庸置疑)。

fn chain_iter(l1: Option<Vec<i32>>, l2: Option<Vec<i32>>) -> Vec<i32> {
	// 声明，但不赋值, 可以通过测试
    let iter: Box<dyn Iterator<Item = i32>>;
    if let Some(l1) = l1 {
        if let Some(l2) = l2 {
            iter = Box::new(l1.into_iter().chain(l2));
        } else {
            iter = Box::new(l1.into_iter());
        }
    } else {
        if let Some(l2) = l2 {
            iter = Box::new(l2.into_iter());
        } else {
            return vec![];
        }
    }
    iter.collect()
}

这个其实以前在别人的代码里面见到不少，但是自己一直不怎么用。实际上iter也是必须初始化的， 只不过rust的编译器看我老老实实的在随后的代码中初始化了，所以放了我一马。我们对代码稍加改动，编译器会立刻报错.

fn chain_iter(l1: Option<Vec<i32>>, l2: Option<Vec<i32>>) -> Vec<i32> {
    let iter: Box<dyn Iterator<Item = i32>>;
    if let Some(l1) = l1 {
        if let Some(l2) = l2 {
            iter = Box::new(l1.into_iter().chain(l2));
        } else {
            iter = Box::new(l1.into_iter());
        }
    } else {
        if let Some(l2) = l2 {
            iter = Box::new(l2.into_iter());
        }
    }
    iter.collect()
}

报错如下:

use of possibly-uninitialized variable: iter
use of possibly-uninitialized iterrustcE0381

告诉你用了可能未初始化的变量

变量的初始化只要在变量使用之前做就可以了。但是没事别间隔的太远，否则对后期的代码维护会是不小的包袱。关键是维护代码的那个人很可能就是你自己。

行了，写累了，今天写到这，总的来说，我越来越喜欢rust了，那种前一段时间被骗上贼船的感觉在一点点的消散。不知道那些为rust投票的同行们是不是也是走过这一遭才按下投票键的。