Dive into Rust

Variable Shadowing

 1let mut guess = String::new();
 2
 3io::stdin().read_line(&mut guess)
 4    .expect("Failed to read line");
 5
 6let guess: u32 = guess.trim().parse()
 7    .expect("Please type a number!");
 8
 9const CONSTANT: &str = "a constant expression, not the result of a function call computed at runtime";
10let immutable_variable: &str = "variables are immutable by default";
11let mut mutable_variable: u32 = 0;
12let immutable_variable: &str = "shadowing the previous immutable_variable, which is bad";
13let immutable_variable: u32 = 1;

Data Types

Scalar Types

• Integer: i8, i16, i32, i64, i128, isize and their unsigned counterpart u8, ..., usize. isize is i32 on 32 bit systems and i64 on 64 bit systems. Integer types default to i32. Compiling in debug mode will check for integer overflows. Relying on integer overflow’s wrapping behavior is considered an error, use the Wrapping type instead.
• Floats: f32 and f64.
• Boolean: bool (values: true and false).
• Character: char (Unicode Scalar Value).

Compound Types

• Tuple: tuple index must be written as a decimal literal, e.g. (0, 1, 2).1.
• Array: can be considered as a tuple whose elements all have the same type. Index out of bounds is a runtime error though.

Control Flow

Condition must be a bool. Nice!

Enum

Rust's enum is actually a tagged union.

Generics

Rust monomorphizes code that is using generics at compile time.

Traits

Rust's traits is similar to interface in other languages.

Memory Management

Rust does not use GC or RC. For values on the heap, it only allow one variable "own" a value at a time. Assignment, passing a value to function and returning a value move the "ownership". Also, Rust allows multiple immutable pointers (&) but only one mutable pointer (&mut), and restricts mixing immutable and mutable pointers to the same target. The basic idea is to keep the number of reference to a value to one, to make memory management easier for the compiler.

1let s1 = String::from("A long long string");
2let s2 = s1 + ".";

Conceptually s2 can be considered as a newly constructed immutable variable, but since the ownership moves from s1 to s2, and s1 becomes invalid afterwards, the compiler just need to appends "." to the end of the value, which is efficient.

Smart pointers can be used for reference counting. Smart pointers are structs satisfying Deref and Drop traits.

1enum List {
2    Cons(i32, Box<List>),
3    Nil,
4}

In the above example, Box<List> is a smart pointer. We use Box<List> to store the Box<List> data on the heap, otherwise Cons(i32, List) will result in infinite size on the stack, which causes Rust failed to construct the List enum.

To allow cons more than one lists from a same base list:

1enum List {
2    Cons(i32, Rc<List>),
3    Nil,
4}

Rc is another smart pointer for reference counting. It increases the reference counter on RC::clone(&l), and reduce the reference counter automatically when the related variable goes out of scope. When there are zero references, the value will be cleaned up.

Be aware that Rc only works in single-thread context. In multiple-threads context, use Arc instead.

In Rust, functions and struts working with references need lifetime annotation. However, Rust can infer function lifetime in simplest cases:

• If there is only one reference input parameter, then its lifetime will be the lifetime of output values.
• If there are multiple reference input parameters, but one of them is &self or &mut self, then its lifetime will be the lifetime of output values.

String literals have a 'static lifetime, which lives for the entire duration of the program.

1let b;
2{
3    let a = "hi";
4    b = a;
5}
6println!("{}", b); // prints "hi"

Lifetime annotation tells Rust compiler the lifetime of variables, but it cannot alter the lifetime.

Testing

While Go use special function name TestXxx, Rust uses #[test] attribute annotation.

Unit tests are written in mod tests, and integration tests are put in the test directory.

Documentation Comments

Three leading slashes /// with Markdown.

Similar to Python, Rust also supports doctest:

1/// # Example
2///
3/// ```
4/// let foo = "foo";
5/// assert_eq!(foo, "foo");
6/// ```

unsafe

In the unsafe block (unsafe {}), you can:

• Dereference a raw pointer which

  • can have both immutable and mutable pointers or multiple mutable pointers to the same location;
  • is not guaranteed to point to valid memory;
  • can be null;
  • does not implement any automatic cleanup.

• Call an unsafe function or method (unsafe fn dangerous() {}, including foreign functions such as C functions).

• Access or modify a mutable static variable (Rust call global variables as static variables).

• Implement an unsafe trait.

• Access fields of an union (the unsafe counterpart of Rust's enum, mainly used for FFI).