Rust Question

fn main () {
    let a = (0..255).sum();
    let b = (0..255).sum::<u32>();
    let c: u32 = (0..255).sum();
}

// @ the size for values of type `[u8]` cannot be known at compilation time, the trait `std::marker::Sized` is not implemented for `[u8]`
// const CHARSET: [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
//                 abcdefghijklmnopqrstuvwxyz\
//                 0123456789)(*&^%$#@!~";
const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
                abcdefghijklmnopqrstuvwxyz\
                0123456789)(*&^%$#@!~";

// File::open open file only read mode, so write content will PermissionDenied
// let mut f = std::fs::File::open("foo.txt")
//     .ok()
//     .expect("Couldn’t open foo.txt");
// let buf = b"hello";
// f.write(buf).expect("Couldn’t write to foo.txt"); // thread 'main' panicked at 'Couldn’t write to foo.txt: Os { code: 5, kind: PermissionDenied, message: "拒绝访问。" }'

let mut f = std::fs::OpenOptions::new()
    .read(true)
    .write(true)
    .open("foo.txt")
    .ok()
    .expect("Couldn’t open foo.txt");

let buf = b"hello";
f.write(buf).expect("Couldn’t write to foo.txt");

let mut x = 5;

match x {
    ref mut mr => println!("mut ref {}", mr),
}

#[derive(Clone, Copy)]
struct Point { x: i32, y: i32 }

fn main() {
    let c = 'Q';

    // A `ref` borrow on the left side of an assignment is equivalent to
    // an `&` borrow on the right side.
    let ref ref_c1 = c;
    let ref_c2 = &c;

    println!("ref_c1 equals ref_c2: {}", *ref_c1 == *ref_c2);

    let point = Point { x: 0, y: 0 };

    // `ref` is also valid when destructuring a struct.
    let _copy_of_x = {
        // `ref_to_x` is a reference to the `x` field of `point`.
        let Point { x: ref ref_to_x, y: _ } = point;

        // Return a copy of the `x` field of `point`.
        *ref_to_x
    };

    // A mutable copy of `point`
    let mut mutable_point = point;

    {
        // `ref` can be paired with `mut` to take mutable references.
        let Point { x: _, y: ref mut mut_ref_to_y } = mutable_point;

        // Mutate the `y` field of `mutable_point` via a mutable reference.
        *mut_ref_to_y = 1;
    }

    println!("point is ({}, {})", point.x, point.y);
    println!("mutable_point is ({}, {})", mutable_point.x, mutable_point.y);

    // A mutable tuple that includes a pointer
    let mut mutable_tuple = (Box::new(5u32), 3u32);

    {
        // Destructure `mutable_tuple` to change the value of `last`.
        let (_, ref mut last) = mutable_tuple;
        *last = 2u32;
    }

    println!("tuple is {:?}", mutable_tuple);
}