Rust

Rust中的async/.await由编译器实现, 是零开销的.
被async修饰的函数或块返回 =impl Future<Output = T>=.
被async修饰的函数或块在运行时可以通过 Future.await 让出线程, 而不是阻塞线程.

async fn do_foo_and_bar() {
  foo().await;
  bar().await;
}

一个社区异步库, 提供了各种有利于Future使用的函数和宏,
例如 futures::join! (名称来自于Fork-Join模型, 功能相当于JavaScript里的 Promise.all).

async fn do_foo_and_bar_at_same_time {
  let future1 = foo();
  let future2 = bar();
  join!(future1, future2);
}

[dependencies]
rand = { git = "https://github.com/rust-lang-nursery/rand", branch = "next" }

[dependencies.rand]
git = "https://github.com/rust-lang-nursery/rand"
branch = "next"

# 启动ssh-agent, 并执行ssh-agent的返回值:
# SSH_AUTH_SOCK=/tmp/ssh-xxxxx/agent.xxxxxx
# 作用是将sock地址赋值给环境变量SSH_AUTH_SOCK, 以供其他程序访问.
eval `ssh-agent`
# 加载本地的ssh凭证
ssh-add

Rust允许在一个代码块中重复声明变量, 后声明的变量会遮蔽掉先声明的变量.

这同样能用来改变变量的修饰符:

let mut v = Vec::new();
let v = v;
// 反之亦然
let v = Vec::new();
let mut v = v;

变量遮蔽不会导致被遮蔽变量的生命周期提前结束.

const GLOBAL: i32 = 0;

let love = 'c';
let c1 = '\n';
let c2 = '\x7f';
let c3 = '\u{7FFF}';

类型	有符号	无符号
8 bits	i8	u8
16 bits	i16	u16
32 bits	i32	u32
64 bits	i64	u64
128 bits	i128	u128
Pointer size	isize	usize

let var1: i32 = 32;
let var2: i32 = 0xFF;
let var3: i32 = 0o55;
let var4: i32 = 0b1001;
let var5 = 0x_1234_ABCD; // 任意添加_以增强可读性
let var6 = 123usize; // 指定字面量类型
let var7 = 32; // 默认为i32类型
9_i32.pow(3); // 直接在字面量上调用函数

let f1 = 123.0f64;
let f2 = 0.1f64;
let f3 = 0.1f32;
let f4 = 12E+99_f64;
let f5: f64 = 2;

类型	含义
Box<T>	指向类型T的, 独占所有权的, 有权释放内存的指针.
&T	指向类型T的借用指针, 或称引用. 无权释放内存, 无权写数据.
&mut T	&T加上mut修饰符的版本, 有权写数据.
*const T	指向类型T的只读裸指针, 没有生命周期信息, 无权写数据.
*mut T	指向类型T的可读写裸指针, 没有声明周期信息, 有权写数据.
Rc<T>	指向类型T的引用计数指针, 共享所有权, 线程不安全.
Arc<T>	指向类型T的原子型引用技术指针, 共享所有权, 线程安全.
Cow<'a, T>	写时复制(clone-on-write)指针.

let a = (1i32, false);
let b = ("a", (1i32, 2i32));
let c = (0,); // 只有一个元素的元组
let d: () = (); // 空元组(unit, 单元类型), 不占用内存空间
// 通过模式匹配访问元组成员
let p = (1i32, 2i32);
let (a, b) = p;
// 通过索引访问元组成员
let x = p.0
let y = p.1

struct Point {
    x: i32,
    y: 32, // 最后的逗号可以省略, 但出于习惯和版本控制目的, 建议使用
}
fn main() {
    let p = Point { x: 0, y: 0 };
    println!("Point is at {} {}", p.x, p.y);
    // 简写
    let x = 10;
    let y = 20;
    let p = Point { x, y };
    
    // 类似JavaScript的spread语法
    let p = Point { ..p };
    let Point { x: px, y: py } = p;
    let Point { x, y } = p;
}
// 空结构体
struct Foo1;
struct Foo2();
struct Foo3 {}

struct Color(i32, i32, i32);
struct Color {
    0: i32,
    1: i32,
    2: i32,
}
// 用来创造独立的类型
fn main() {
    struct Inches(i32);
    fn f(value: Inches) {}
    let v: i32 = 0;
    f(v); // 编译不通过, 因为Inches和i32不是一个类型, 且Rust不允许隐式类型转换
}

enum Number {
    Int(i32),
    Float(f32),
}
fn read_num(num: &Number) {
    // 枚举用于模式匹配
    match num {
        &Number::Int(value) => println!("Integer {}", value),
        &Number::Float(value) => println!("Float {}", value),
    }
}
fn main() {
    let n: Number = Number::Int(10);
    read_num(&n);
}

let xs: [i32; 5] = [1, 2, 3, 4, 5];
let xs: [i32; 500] = [0; 500]; // 批量初始化
// 多维数组 
let xs: [[i32; 2]; 3] = [[0, 0], [0, 0], [0, 0]];

for (index, value) in v.iter().enumerate() {
    ...
}

let r = 1..10; // Range<i32>, [1, 10)
let r = 1i32..10;
// 等同于
let r = Range { start: 1, end: 10 };
// 用于数组切片
let arr: [i32; 5] = [1, 2, 3, 4, 5];
&arr[..]
&arr[2..];
&arr[..2];
// 左闭右闭区间
start..=end // std::ops::RangeInclusive
// 右闭区间(左边在有符号时为负无穷, 无符号时为0)
..=end // std::ops::RangeToInclusive

// 由于字符串使用了utf-8变长编码, 字符所处的内存位置不能直接得到.
// Rust里按索引取字符必须这样写:
s.chars().nth(n);

String 和 &str 的不同之处在于, String 是一种有所有权的类型, 因此 String 可以改变内存值.
String 可以扩容, 其内部类似于 Vec<u8> 类型.

let mut s = String::from("Hello");
s.push(' ');
s.push_str("World.");

if n < 0 {
    ...
} else if n > 0 {
    ...
} else {
    ...
}
// 模式匹配解构赋值
if let Some(x) = optVal {
   ...
}

enum Direction {
    East, West, South, North
}
fn print(x: Direction) {
    match x {
        Direction::East => { ... }
        Direction::West => { ... }
        Direction::South => { ... }
        Direction::North => { ... }
    }
}

match x {
    i if i > 5 => ...,
    i if i <= 5 => ...,
    _ => unreachable!(), // 由于编译器不懂得数学运算, 因此需要手动提示编译器
}
match x {
    ref r => ..., // 用ref关键字表示匹配的是引用而不是值, 从而避免所有权转移
}

与其他语言不同, 语句块在Rust里是一个较为常用的功能:
由于Rust独特的变量所有权机制, 有时候需要使用语句块来控制变量的生存周期.

let x: i32 = {
    println("Hello");
    1 + 2
}

loop {
    continue;
    break;
}
// 带有label的循环
'a: loop {
    'b: loop {
        break 'a;
        continue 'a;
    }
}

fn add((x, y): (i32, i32)) -> i32 {
    x + y
}

let add = |a: i32, b: i32| -> i32 { return a + b; };
let add = |a, b| { return a + b; };
let add = |a, b| { a + b };
let add = |a, b| a + b;
// Fn是一种trait, 用来表示闭包的类型, 此外还有FnMut, FnOnce
// Fn(i32) -> i32是专门为闭包设计的语法糖, 实际上是Fn<i32, i32>
fn make_adder(x: i32) -> Box<Fn(i32) -> i32> {
    // 当闭包的生命周期超出被捕捉变量的生命周期时, 需要用move关键字将所有权转移.
    Box::new(move |y| x + y)
}

// Rust可以在trait里直接编写实现.
trait Shape {
    fn area(&self) -> f64;
}
trait Round {
    fn get_radius(&self) -> f64;
}
struct Circle {
    radius: f64,
}
// 为Cirlce实现Shape特质
impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}
// 也可以直接针对类型添加方法
impl Circle {
    fn get_radius(&self) -> f64 { self.radius }
}
// 也可以为Shape实现Round特质(为特质实现特质)
impl Shape for dyn Round {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.get_radius() * self.get_radius()
    }
}
// 当一个类型满足多个trait, 且具有相同方法签名的多个同名方法时, 必须手动指定trait:
<Cook>::start(&me);
<Chef as Wash>::start(&me);

self是trait方法支持的第一个变量名, 其类型为Self.
只有当self作为第一个变量名时, 才能使用 =Type.FunctionName()= 调用函数.
Type.FunctionName() 是 <Type>::FunctionName(&Name) 的语法糖.

// 不使用语法糖
trait T {
    fn method1(self: Self);
    fn method2(self: &Self);
    fn method3(self: &mut Self);
}
// 使用语法糖时, 可以省略Self类型.
trait T {
    fn method1(self);
    fn method2(&self);
    fn method3(&mut self);
}

第一个函数的变量名不是self时, 函数只能通过 Type::FunctionName() 的形式调用.

struct T(i32);
impl T {
    fn func(this: &Self) {
        println!("value {}", this.0);
    }
}
fn main() {
    let x = T(42);
    T::func(&x);
}

为结构体添加多个特质需要编写很多impl代码块, 为了简化这一过程, Rust提供了一个名为derive的attribute.

注: 只有支持自动derive的trait才可以用derive.

#[derive(Copy, Clone, Default, Debug, Hash, PartialEq, Eq, PartialOrd, Ord]
struct Foo {
    data: i32
}
// 相当于
impl Copy for Foo { ... }
impl Clone for Foo { ... }
impl Default for Foo { ... }
impl Debug for Foo { ... }
impl Hash for Foo { ... }
impl PartialEq for Foo { ... }
...

	move	copy	borrow	mut borrow
类型较小时的性能	低	高	低	低
类型较大时的性能	高	低	高	高
反直觉	是	否	否	否
可变	是	是	否	是

// 函数
fn select<'a>(arg1: &'a i32, arg2: &'a i32) -> &'a i32 {
    if *arg1 > *arg2 { arg1 } else { arg2 }
}
// 类型
struct Test<'a> {
    member: &'a str
}
impl<'t> Test<'t> {
    fn test<'a>(&self, s: &'a str) {}
}