Rust

本篇文章记录一下Rust的入门学习过程，主要是一些基础的语法和一些常用的库的使用，以及一些常见的问题的解决方法。其实本来就想开始入门了，但是这学期教授们不知道怎么的，不约而同把作业量提到了往年的两倍，所以春假才有时间搞这个。

长期规划

因为今年实习被分配写rust，所以打算下一个项目用rust写一个kv数据库，类似于Leveldb那样。模仿一下前人的GitHub。但是在此之前，得先了解rust的基本语法和一些常用的知识。

基础语法

这个给我的感觉就是C++，golang和Ocaml揉碎了成一团之后的产物。当我看到let，match和option的时候我就知道为啥我被组长挑来写rust了哈哈哈。但是其中还是有很多imperative language feature的。虽然我目前还是不是很能体会为什么很多设计者试图在rust中追求functional language的feature，但是这种设计确实将rust的入门门槛和可用性降低了很多。我还记得当时有人评价Ocaml说，Once it compiles, it will never crash。在写代码的时候严格约束确实是一件好事。

基本语法

变量

首先所有的变量分为可变和不可变两种，可以和Ocaml一样用let声明，但是不同的是，rust的let是一个表达式，而不是一个语句。所以可以这样写：

let x = 5;
let y = {
    let x_squared = x * x;
    x_squared * x_squared
};

这句话的等价于：

int x = 5;
int x_squared = x * x;
int y = x_squared * x_squared;

和Ocaml的

let x = 5 in
let x_squared = x * x in
let y = x_squared * x_squared in
y

这种写法是一样的。这种写法的好处是可以在let中定义一些临时变量，而不用担心变量名的冲突，非常方便。

可变vs不可变

rust中的变量分为可变和不可变两种，不可变的变量在定义之后就不能再次赋值，而可变的变量可以在任何地方被赋值。默认情况下，变量是不可变的，如果想要定义一个可变的变量，需要在let前面加上mut关键字。比如：

let mut x = 5;
x = 6; // OK
let y = 5;
y = 6; // Error

数据类型

跳过基础类型，我们来看复合类型吧。

首先是arr和vec，这两个都是数组，但是vec是可变的，arr是在编译期确定的大小，有点类似于std::array和std::vector，但是vec的实现是unsafe的，但是显然也没法被低成本替换。

let a = [1, 2, 3, 4, 5];
let mut v = vec![1, 2, 3, 4, 5];
v.push(6); // OK
println!("{:?}", v); //1 2 3 4 5 6
println!("{:?}", a); //1 2 3 4 5

那么我们怎么访问数组中的元素呢？因为rust是strongly typed，所以我们需要指定下标中元素的类型。

在cpp中，我们可以使用int作为subscript，但是这里可能要改一下

int a[30];
for (int i = 0; i < 30; i++) {
    a[i] = i;
}

在rust中，我们需要使用usize作为subscript，这个类型是一个unsigned int，所以我们这样写会哟对岸问题

let mut a = [0,1,2,3,4,5];
for i in 0..3 {
    v[i] = i; //error
}

这里会报错，因为usize是一个unsigned int,但是for循环中的i是一个signed int，所以会报错。所以我们需要这样写：

for i in 0..3 {
    v[i as usize] = i; //OK
}

虽然没cpp自由，但是在大型项目中，这种类型检查还是很有必要的。把时间花在写起来能跑的代码上总比花时间在debug上好。

如果我们需要对一个array的某一个范围进行排序，我们可以这样写：

let mut a = [5, 4, 3, 2, 1];
a[1..4].sort();
println!("{:?}", a); //5 2 3 4 1

或者获取mutable slice

let mut a = [5, 4, 3, 2, 1];
let b = &mut a[1..4];
b.sort();
println!("{:?}", a); //5 2 3 4 1

我们可以自定义比较符号

let mut a = [5, 4, 3, 2, 1];
a[1..4].sort_by(|a, b| b.cmp(a));
println!("{:?}", a); //5 4 3 2 1

或者自定义比较函数

let mut a = [5, 4, 3, 2, 1];
a[1..4].sort_by(|a, b| b.partial_cmp(a).unwrap());
println!("{:?}", a); //5 4 3 2 1

Match关键字

match关键字是rust中的一个非常重要的关键字，它可以用来匹配一个值的类型，然后执行相应的代码。比如：

这个和Ocaml里面的match关键字是一样的，但是rust的match更加高级，因为加入了一些imperative language的内容，所以肯定有所改变

常用的match就不说了，比如高级if

fn work(x: i32) -> Option<i32> {
    if x < 0 {
        None
    } else {
        Some(x)
    }
}

fn main() {
    let x = 5;
    match work(x) {
        Some(y) => println!("x is {}", y),
        None => println!("x is negative"),
    }
}

range match

fn main() {
    let x = 5;
    match x {
        1 => println!("one"),
        2 | 3 | 5 | 7 | 11 => println!("x is a prime"),
        13..=19 => println!("x is a teen"),
        _ => println!("x is something else"),
    }
}

然后就是function match

fn test() -> i32 {
    5
}

fn main() {
    match test() {
        0 => println!("zero"),
        n @ 1..=12 => println!("n is {}", n),
        n @ 13..=19 => println!("n is a teen"),
        _ => println!("n is something else"),
    }
}

这里的n是把test()这么一个暂时的结果绑定到了n上，使得我们可以在后面的代码中使用n。

Struct

rust的struct就是golang和cpp中的struct，但是rust中的struct是可以有方法的。但是不得不说，这点很像golang。在golang里面，我们一般是有一个类的interface，然后会有一个XXImpl类去实现抽象方法和多态，但是在rust里面，这么多并不是选择题，而是必须的。比如我定义一个foo的struct，那么我就必须要实现一个foo的方法，否则就会报错。这样的好处是，我们可以在编译期就发现一些错误，而不是在运行期。

struct Foo {
    x: i32,
}

impl Foo {
    fn new(x: i32) -> Foo {
        Foo { x }
    }

    fn foo(&self) {
        println!("x is {}", self.x);
    }
}

fn main() {
    let f = Foo::new(5);
    f.foo(); //5
}

这点不得不说真的非常像golang，也不知道是golang借鉴了rust还是rust借鉴了golang。

然后我们可以来写一道简单的算法题，比如最大子段和

fn main() {
    let cin = stdin();
    let mut line = String::new();
    cin.lock().read_line(&mut line).unwrap();
    let n: i32 = line.trim().parse().unwrap();
    cin.lock().read_line(&mut line).unwrap();
    let mut a:Vec<i32> = line.trim().split_whitespace().map(|x| x.parse().unwrap()).collect();
    let mut ans:i32 = 0;
    let mut cur:i32 = a[0];
    let mut prev:i32 = 0;
    for i in 1..n {
        cur = max(prev, 0) + a[i as usize];
        ans = max(ans, cur);
        prev = cur;
    }
    println!("{}", ans);

}

这个我们实际上是要用buffered reader来读取，但是这里为了方便，就直接用了cin了。

Trait

Trait是rust中的一个非常重要的概念，它是一种抽象的接口，比如我们可以定义一个trait，然后让struct去实现这个trait，这样的话，我们就可以在函数中传入这个trait，而不是具体的struct，这样的话，我们就可以在函数中使用这个trait的方法，而不是具体的struct的方法。这样的话，我们就可以在函数中使用多态了。

trait Foo {
    fn foo(&self);
}

struct Bar {
    x: i32,
}

impl Foo for Bar {
    fn foo(&self) {
        println!("x is {}", self.x);
    }
}

fn test<T: Foo>(t: T) {
    t.foo();
}

fn main() {
    let b = Bar { x: 5 };
    test(b);
}

这是一种非常强大的工具。我们具有了C++ programmer所有的工具和能力，去构造更多的，更高效的程序。