Rust入门之严谨如你

fn immutable_var() {
    let x = 42;
    x = 65;
}

error[E0384]: cannot assign twice to immutable variable `x`
 --> src\main.rs:7:5
  |
6 |     let x = 42;
  |         -
  |         |
  |         first assignment to `x`
  |         help: make this binding mutable: `mut x`
7 |     x = 65;
  |     ^^^^^^ cannot assign twice to immutable variable

fn only_declare() {
    let x: i32;
    if true {
        x = 42;
    } else {
        ;
    }
    println!("x: {}", x);
}

error[E0381]: borrow of possibly-uninitialized variable: `x`
  --> src\main.rs:20:23
   |
20 |     println!("x: {}", x);
   |                       ^ use of possibly-uninitialized `x`

fn move_var() {
    let x = String::from("42");
    let y = x; //move occurred
    println!("x: {:?}", x);
}

error[E0382]: borrow of moved value: `x`
  --> src\main.rs:29:25
   |
27 |     let x = String::from("42");
   |         - move occurs because `x` has type `std::string::String`, which does not implement the `Copy` trait
28 |     let y = x; //move occurred
   |             - value moved here
29 |     println!("x: {:?}", x);
   |                         ^ value borrowed here after move

fn borrow_var() {
    let v = vec![1, 2, 4];
    immu_borrow(&v);
    println!("v[1]:{}", v[1]);
}

fn immu_borrow(v: &Vec<i32>) {
    v.pop();
}

error[E0596]: cannot borrow `*v` as mutable, as it is behind a `&` reference
  --> src\main.rs:40:5
   |
39 | fn immu_borrow(v: &Vec<i32>) {
   |                   --------- help: consider changing this to be a mutable reference: `&mut std::vec::Vec<i32>`
40 |     v.pop();
   |     ^ `v` is a `&` reference, so the data it refers to cannot be borrowed as mutable

fn mut_borrow_var_twice() {
    let mut v = vec![1, 2, 4];
    let x = &mut v;
    v[1] += 42;
    (*x)[1] += 42;
    println!("v[1]:{}", v[1]);
}

error[E0499]: cannot borrow `v` as mutable more than once at a time
  --> src\main.rs:46:5
   |
45 |     let x = &mut v;
   |             ------ first mutable borrow occurs here
46 |     v[1] += 42;
   |     ^ second mutable borrow occurs here
47 |     (*x)[1] += 42;
   |     ---- first borrow later used here

fn mut_immut_borrow_var() {
    let mut v = vec![1, 2, 4];
    let x = &v;
    v[1] += 42;
    println!("v[1]:{}", x[1]);
}

error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
  --> src\main.rs:54:5
   |
53 |     let x = &v;
   |             -- immutable borrow occurs here
54 |     v[1] += 42;
   |     ^ mutable borrow occurs here
55 |     println!("v[1]:{}", x[1]);
   |                         - immutable borrow later used here

fn two_mut_ref_compile_ok() {
    let mut v = vec![1, 2, 3];
    mut1(&mut v);
    mut2(&mut v);
}

fn mut1(v: &mut Vec<i32>) {
    *v = vec![0];
}

fn mut2(v: &mut Vec<i32>) {
    println!("{}", v[1]);
}

fn dangle_ref() {
    let x: &i32;
    {
        let y = 42;
        x = &y;
    }
    println!("x:{}", x);
}

error[E0597]: `y` does not live long enough
  --> src\main.rs:62:13
   |
62 |         x = &y;
   |             ^^ borrowed value does not live long enough
63 |     }
   |     - `y` dropped here while still borrowed
64 |     println!("x:{}", x);
   |                      - borrow later used here

fn invalid_mem_use() {
    let x = 42 as *mut i32;
    *x = 65;
}

error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
  --> src\main.rs:69:5
   |
69 |     *x = 65;
   |     ^^^^^^^ dereference of raw pointer
   |
   = note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior

enum Option<T> {
  None,
  Some(T),
}

struct A {}
impl A {
    fn f(&self) {}
}
fn safe_null() {
    let x: Option<A> = None;
    match x {
        Some(a) => a.f(),
        None => (),
    }
}