Fundamental-Types

There are many, many types of books in the world, which makes good sense, because there are many, many types of people, and everybody wants to read something different. —Lemony Snicke > >

Fixed-Width Numeric Types

// 10_u8.checked_mul(10).expect("数值溢出");
// 100_u8.checked_add(200).expect("");
// let x = 100_u8;
// let y = 100_u8;
// // Do the addition; panic if it overflows.
// let sum = x.checked_add(y).unwrap();
// 超出不报错
500_u16.wrapping_mul(500);  // 53392
500_i16.wrapping_mul(500); // -12144
// In bitwise shift operations, the shift distance
// is wrapped to fall within the size of the value.
// So a shift of 17 bits in a 16-bit type is a shift
// of 1.
// assert_eq!(5_i16.wrapping_shl(17), 10);

Characters

assert_eq!('*' as i32, 42);
assert_eq!('ಠ' as u16, 0xca0);
assert_eq!('ಠ' as i8, -0x60); // U+0CA0 truncated to eight bits, signed

assert_eq!('*'.is_alphabetic(), false);
assert_eq!('β'.is_alphabetic(), true);
assert_eq!('8'.to_digit(10), Some(8));
assert_eq!('ಠ'.len_utf8(), 3);
assert_eq!(std::char::from_digit(2, 10), Some('2'));

Tuples

let text = "I see the eigenvalue in thine eye";
let (head, tail) = text.split_at(21);
assert_eq!(head, "I see the eigenvalue ");
assert_eq!(tail, "in thine eye");

let text = "I see the eigenvalue in thine eye";
let temp = text.split_at(21);
let head = temp.0;
let tail = temp.1;
assert_eq!(head, "I see the eigenvalue ");
assert_eq!(tail, "in thine eye");

Slices

let v: Vec<f64> = vec![0.0, 0.707, 1.0, 0.707];
let a: [f64; 4] = [0.0, -0.707, -1.0, -0.707];
let sv: &[f64] = &v;
let sa: &[f64] = &a;

Error: The variable `sv` contains a reference with a non-static lifetime so
can't be persisted. You can prevent this error by making sure that the
variable goes out of scope - i.e. wrapping the code in {}.
[E0597] Error: `a` does not live long enough
   ╭─[command_23:1:1]
   │
 2 │ let a: [f64; 4] = [0.0, -0.707, -1.0, -0.707];
   │     ┬
   │     ╰── binding `a` declared here
   │
 4 │ let sa: &[f64] = &a;
   │                  ─┬
   │                   ╰── borrowed value does not live long enough
   │                   │
   │                   ╰── cast requires that `a` is borrowed for `'static`
───╯

String Literals

println!("In the room the women come and go,
Singing of Mount Abora");
println!("It was a bright, cold day in April, and \
there were four of us—\
more or less.");
let default_win_install_path = r"C:\Program Files\Gorillas";
println!(r###"
This raw string started with 'r###"'.
Therefore it does not end until we reach a quote mark ('"')
followed immediately by three pound signs ('###'):
"###);

In the room the women come and go,
Singing of Mount Abora
It was a bright, cold day in April, and there were four of us—more or less.

This raw string started with 'r###"'.
Therefore it does not end until we reach a quote mark ('"')
followed immediately by three pound signs ('###'):

Byte Strings

let method = b"GET";
assert_eq!(method, &[b'G', b'E', b'T']);

Strings

let noodles = "noodles".to_string();
let oodles = &noodles[1..];
let poodles = "ಠ_ಠ";

let oodles = &noodles[1..];
let oodles = &noodles[1..];
    ^^^^^^
The variable `oodles` contains a reference with a non-static lifetime so
can't be persisted. You can prevent this error by making sure that the
variable goes out of scope - i.e. wrapping the code in {}.

assert_eq!("ಠ_ಠ".len(), 7);
assert_eq!("ಠ_ಠ".chars().count(), 3)

()

let error_message = "too many pets".to_string();

println!("{}",error_message)

too many pets
()

format string

println!("{}",format!("{}°{:02}′{:02}″N", 24, 5, 23))

24°05′23″N
()

let bits = vec!["veni", "vidi", "vici"];

bits.concat()

"venividivici"

bits.join(",")

"veni,vidi,vici"

"ONE".to_lowercase()

"one"

"peanut".contains("nut")

true

"ಠ_ಠ".replace("ಠ", "■")

"■_■"

Ownership-and-Moves

Ownership

{
let point = Box::new((0.625, 0.5)); // point allocated here
let label = format!("{:?}", point); // label allocated here
assert_eq!(label, "(0.625, 0.5)");
}

()

struct Person { name: String, birth: i32 }
let mut composers = Vec::new();
composers.push(Person {
    name: "Abc".to_string(),
    birth: 123,
});
composers.push(Person {
    name: "DEF".to_string(),
    birth: 444,
});
composers.push(Person {
    name: "ASD".to_string(),
    birth: 555,
});
for composer in &composers {
println!("{}, born {}", composer.name, composer.birth);
}

Abc, born 123
DEF, born 444
ASD, born 555
()

Moves

let s = vec!["udon".to_string(), "ramen".to_string(), "soba".to_string()];
let t = s;
let u = s;

[E0382] Error: use of moved value: `s`
   ╭─[command_4:1:1]
   │
 1 │ let s = vec!["udon".to_string(), "ramen".to_string(), "soba".to_string()];
   │     ┬
   │     ╰── move occurs because `s` has type `Vec<String>`, which does not implement the `Copy` trait
 2 │ let t = s;
   │         ┬│
   │         ╰── value moved here
   │          │
   │          ╰─ help: consider cloning the value if the performance cost is acceptable: `.clone()`
 3 │ let u = s;
   │         ┬
   │         ╰── value used here after move
───╯

let s = vec!["udon".to_string(), "ramen".to_string(), "soba".to_string()];
let t = s.clone();
let u = s.clone();

More Operations That Move

let mut s = "Govinda".to_string();
s = "Siddhartha".to_string(); // value "Govinda" dropped here

let mut s = "Govinda".to_string();
let t = s;
s = "Siddhartha".to_string(); // nothing is dropped here

Moves and Control Flow

Moves and Indexed Content

// Build a vector of the strings "101", "102", ... "105"
let mut v = Vec::new();
for i in 101 .. 106 {
v.push(i.to_string());
}

()

// Pull out random elements from the vector.
let third = v[2]; // error: Cannot move out of index of Vec
let fifth = v[4]; // here too

[E0507] Error: cannot move out of index of `Vec<String>`
   ╭─[command_9:1:1]
   │
 2 │ let third = v[2]; // error: Cannot move out of index of Vec
   │             ┬─┬─
   │             ╰───── help: consider borrowing here: `&`
   │               │
   │               ╰─── move occurs because value has type `String`, which does not implement the `Copy` trait
───╯
[E0507] Error: cannot move out of index of `Vec<String>`
   ╭─[command_9:1:1]
   │
 3 │ let fifth = v[4]; // here too
   │             ┬─┬─
   │             ╰───── help: consider borrowing here: `&`
   │               │
   │               ╰─── move occurs because value has type `String`, which does not implement the `Copy` trait
───╯

// 1. Pop a value off the end of the vector:
let fifth = v.pop().expect("vector empty!");
assert_eq!(fifth, "105");

// 2. Move a value out of a given index in the vector,
// and move the last element into its spot:
let second = v.swap_remove(1);
assert_eq!(second, "102");
// 3. Swap in another value for the one we're taking out:
let third = std::mem::replace(&mut v[2], "substitute".to_string());
assert_eq!(third, "103");
// Let's see what's left of our vector.
assert_eq!(v, vec!["101", "104", "substitute"]);

struct Person { name: Option<String>, birth: i32 }
let mut composers = Vec::new();
composers.push(Person { name: Some("Palestrina".to_string()),
birth: 1525 });

let first_name = composers[0].name;

[E0507] Error: cannot move out of index of `Vec<Person>`
   ╭─[command_13:1:1]
   │
 1 │ let first_name = composers[0].name;
   │                  ┬───────┬────────
   │                  ╰────────────────── help: consider borrowing here: `&`
   │                          │
   │                          ╰────────── move occurs because value has type `Option<String>`, which does not implement the `Copy` trait
───╯

let first_name = std::mem::replace(&mut composers[0].name, None);
assert_eq!(first_name, Some("Palestrina".to_string()));
assert_eq!(composers[0].name, None);

let first_name = composers[0].name.take();

Copy Types: The Exception to Moves

let string1 = "somnambulance".to_string();
let string2 = string1;
let num1: i32 = 36;
let num2 = num1;

struct Label { number: u32 }
fn print(l: Label) { println!("STAMP: {}", l.number); }
let l = Label { number: 3 };
print(l);
println!("My label number is: {}", l.number);

[E0382] Error: borrow of moved value: `l`
   ╭─[command_17:1:1]
   │
 3 │ let l = Label { number: 3 };
   │     ┬
   │     ╰── move occurs because `l` has type `Label`, which does not implement the `Copy` trait
 4 │ print(l);
   │       ┬
   │       ╰── value moved here
 5 │ println!("My label number is: {}", l.number);
   │                                    ────┬───
   │                                        ╰───── value borrowed here after move
───╯

#[derive(Copy, Clone)]
struct Label { number: u32 }

#[derive(Copy, Clone)]
struct StringLabel { name: String }

[E0204] Error: the trait `Copy` cannot be implemented for this type
   ╭─[command_19:1:1]
   │
 1 │ #[derive(Copy, Clone)]
   │          ──┬─
   │            ╰─── error: the trait `Copy` cannot be implemented for this type
 2 │ struct StringLabel { name: String }
   │                      ──────┬─────
   │                            ╰─────── this field does not implement `Copy`
───╯

Rc and Arc: Shared Ownership

use std::rc::Rc;
// Rust can infer all these types; written out for clarity
let s: Rc<String> = Rc::new("shirataki".to_string());
let t: Rc<String> = s.clone();
let u: Rc<String> = s.clone();

assert!(s.contains("shira"));
assert_eq!(t.find("taki"), Some(5));
println!("{} are quite chewy, almost bouncy, but lack flavor", u);

shirataki are quite chewy, almost bouncy, but lack flavor

s.push_str(" noodles");

[E0596] Error: cannot borrow data in an `Rc` as mutable
   ╭─[command_22:1:1]
   │
 1 │ s.push_str(" noodles");
   │ ┬
   │ ╰── cannot borrow as mutable
   │
   │ Note: You can change an existing variable to mutable like: `let mut x = x;`
───╯

References

Libraries cannot provide new inabilities. —Mark Miller

use std::collections::HashMap;
type Table = HashMap<String, Vec<String>>;

fn show(table:Table) {
    for (artist,works) in table {
        println!("works by {}",artist);
        for work in works {
            println!("  {}",work);
        }
    }
}

let mut table = Table::new();
table.insert("Gesualdo".to_string(),
vec!["many madrigals".to_string(),
"Tenebrae Responsoria".to_string()]);
table.insert("Caravaggio".to_string(),
vec!["The Musicians".to_string(),
"The Calling of St. Matthew".to_string()]);
table.insert("Cellini".to_string(),
vec!["Perseus with the head of Medusa".to_string(),
"a salt cellar".to_string()]);
show(table);

works by Gesualdo
  many madrigals
  Tenebrae Responsoria
works by Caravaggio
  The Musicians
  The Calling of St. Matthew
works by Cellini
  Perseus with the head of Medusa
  a salt cellar

fn sort_works(table: &mut Table) {
for (_artist, works) in table {
works.sort();
}
}

let mut table = Table::new();
table.insert("Gesualdo".to_string(),
vec!["many madrigals".to_string(),
"Tenebrae Responsoria".to_string()]);
table.insert("Caravaggio".to_string(),
vec!["The Musicians".to_string(),
"The Calling of St. Matthew".to_string()]);
table.insert("Cellini".to_string(),
vec!["Perseus with the head of Medusa".to_string(),
"a salt cellar".to_string()]);
sort_works(&mut table);

Assigning References

let x = 10;
let y = 20;
let mut r = &x;
if true { r = &y; }
assert!(*r == 10 || *r == 20);

Error: The variable `r` contains a reference with a non-static lifetime so
can't be persisted. You can prevent this error by making sure that the
variable goes out of scope - i.e. wrapping the code in {}.
Error: The variable `r` contains a reference with a non-static lifetime so
can't be persisted. You can prevent this error by making sure that the
variable goes out of scope - i.e. wrapping the code in {}.

References to References

{
    struct Point { x: i32, y: i32 }
    let point = Point { x: 1000, y: 729 };
    let r: &Point = &point;
    let rr: &&Point = &r;
    let rrr: &&&Point = &rr;
    assert_eq!(rrr.y, 729);
}

()

Comparing References

{
    let x = 10;
let y = 10;
let rx = &x;
let ry = &y;
let rrx = ℞
let rry = &ry;
assert!(rrx <= rry);
assert!(rrx == rry);
    assert!(rx == ry); // their referents are equal
assert!(!std::ptr::eq(rx, ry)); // but occupy different addresses
    assert!(rx == rrx); // error: type mismatch: `&i32` vs `&&i32`
assert!(rx == *rrx); // this is okay
}

[E0277] Error: can't compare `{integer}` with `&{integer}`
    ╭─[command_19:1:1]
    │
 13 │     assert!(rx == rrx); // error: type mismatch: `&i32` vs `&&i32`
    │                ─┬
    │                 ╰── no implementation for `{integer} == &{integer}`
────╯

Borrowing a Local Variable

{
    let r;
    {
        let x = 1;
        r = &x;
    }
    assert_eq!(*r,1);
}

[E0597] Error: `x` does not live long enough
   ╭─[command_20:1:1]
   │
 4 │         let x = 1;
   │             ┬
   │             ╰── binding `x` declared here
 5 │         r = &x;
   │             ─┬
   │              ╰── borrowed value does not live long enough
 6 │     }
   │     ┬
   │     ╰── `x` dropped here while still borrowed
 7 │     assert_eq!(*r,1);
   │     ────────┬───────
   │             ╰───────── borrow later used here
───╯

Receiving References as Function Arguments

// This code has several problems, and doesn't compile.
static mut STASH: &i32;
fn f(p: &i32) { STASH = p; }

Error: free static item without body
   ╭─[command_21:1:1]
   │
 2 │ static mut STASH: &i32;
   │ ───────────┬──────────┬
   │            ╰───────────── error: free static item without body
   │                       │
   │                       ╰── help: provide a definition for the static: ` = <expr>;`
───╯

static mut STASH: &i32 = &128;
fn f(p: &i32) { // still not good enough
unsafe {
STASH = p;
}
}

Error: lifetime may not live long enough
   ╭─[command_22:1:1]
   │
 2 │ fn f(p: &i32) { // still not good enough
   │         ┬
   │         ╰── let's call the lifetime of this reference `'1`
   │
 4 │ STASH = p;
   │ ────┬────
   │     ╰────── assignment requires that `'1` must outlive `'static`
───╯

static mut STASH: &i32 = &10;
fn f(p: &'static i32) {
unsafe {
STASH = p;
    println!("{}",STASH);
}
}

static WORTH_POINTING_AT: i32 = 1000;
f(&WORTH_POINTING_AT);

1000

{
    unsafe {
        println!("{}",STASH);
        println!("{}",WORTH_POINTING_AT);
    }
}

10
1000
()

Passing References to Functions

// This could be written more briefly: fn g(p: &i32),
// but let's write out the lifetimes for now.
fn g<'a>(p: &'a i32) {  }
let x = 10;
g(&x);

fn f(p: &'static i32) {  }
let x = 10;
f(&x);
// This fails to compile: the reference &x must not outlive x, but by passing it to f, we
// constrain it to live at least as long as 'static. There’s no way to satisfy everyone here,
// so Rust rejects the code.

fn f(p: &'static i32) {  }
     ^ warning: unused variable: `p`
unused variable: `p`
help: if this is intentional, prefix it with an underscore

_p
warning: unused variable: `p`
unused variable: `p`
help: if this is intentional, prefix it with an underscore

_p
f(&x);
  ^^ borrowed value does not live long enough
let x = 10;
    ^ binding `x` declared here
f(&x);
^^^^^ argument requires that `x` is borrowed for `'static`
`x` does not live long enough

Returning References

fn smallest(v: &[i32]) -> &i32 {
let mut s = &v[0];
for r in &v[1..] {
if *r < *s { s = r; }
}
s
}

// fn smallest<'a>(v: &'a [i32]) -> &'a i32 {  }

let s;
{
let parabola = [9, 4, 1, 0, 1, 4, 9];
s = smallest(&parabola);
}
assert_eq!(*s, 0);

[unused_variables] Error: unused variable: `p`
[E0597] Error: `parabola` does not live long enough
   ╭─[command_42:1:1]
   │
 3 │ let parabola = [9, 4, 1, 0, 1, 4, 9];
   │     ────┬───
   │         ╰───── binding `parabola` declared here
 4 │ s = smallest(&parabola);
   │              ────┬────
   │                  ╰────── borrowed value does not live long enough
   │                  │
   │                  ╰────── cast requires that `parabola` is borrowed for `'static`
 5 │ }
   │ ┬
   │ ╰── `parabola` dropped here while still borrowed
───╯

{
let parabola = [9, 4, 1, 0, 1, 4, 9];
let s = smallest(&parabola);
assert_eq!(*s, 0); // fine: parabola still alive
}

()

Structs Containing References

// This does not compile.
struct S {
r: &i32
}
let s;
{
let x = 10;
s = S { r: &x };
}
assert_eq!(*s.r, 10); // bad: reads from dropped `x`

[E0106] Error: missing lifetime specifier
   ╭─[command_44:1:1]
   │
 3 │ r: &i32
   │    ┬
   │    ╰── expected named lifetime parameter
───╯

struct S<'a> {
r: &'a i32
}
{
    let s;
{
let x = 10;
s = S { r: &x };
}
assert_eq!(*s.r, 10);
}

[unused_variables] Error: unused variable: `p`
[E0597] Error: `x` does not live long enough
    ╭─[command_49:1:1]
    │
  7 │ let x = 10;
    │     ┬
    │     ╰── binding `x` declared here
  8 │ s = S { r: &x };
    │            ─┬
    │             ╰── borrowed value does not live long enough
  9 │ }
    │ ┬
    │ ╰── `x` dropped here while still borrowed
 10 │ assert_eq!(*s.r, 10);
    │ ──────────┬─────────
    │           ╰─────────── borrow later used here
────╯

Distinct Lifetime Parameters

struct S<'a> {
x: &'a i32,
y: &'a i32
}

{
    let x = 10;
let r;
{
let y = 20;
{
let s = S { x: &x, y: &y };
r = s.x;
}
}
println!("{}", r);
}

[unused_variables] Error: unused variable: `p`
[E0597] Error: `y` does not live long enough
    ╭─[command_56:1:1]
    │
  5 │ let y = 20;
    │     ┬
    │     ╰── binding `y` declared here
    │
  7 │ let s = S { x: &x, y: &y };
    │                       ─┬
    │                        ╰── borrowed value does not live long enough
    │
 10 │ }
    │ ┬
    │ ╰── `y` dropped here while still borrowed
 11 │ println!("{}", r);
    │                ┬
    │                ╰── borrow later used here
────╯

struct S<'a, 'b> {
x: &'a i32,
y: &'b i32
}

{
    let x = 10;
let r;
{
let y = 20;
{
let s = S { x: &x, y: &y };
r = s.x;
}
}
println!("{}", r);
}

10
()

fn f<'a>(r: &'a i32, s: &'a i32) -> &'a i32 { r } // perhaps too tight

fn f<'a, 'b>(r: &'a i32, s: &'b i32) -> &'a i32 { r } // looser

fn f<b>(r: &'a i32, s: &'b i32) -> &'a i32 { r }

[E0261] Error: use of undeclared lifetime name `'a`
   ╭─[command_64:1:1]
   │
 1 │ fn f<b>(r: &'a i32, s: &'b i32) -> &'a i32 { r }
   │      │      ─┬
   │      ╰────────── help: consider introducing lifetime `'a` here: `'a, `
   │              │
   │              ╰── undeclared lifetime
───╯
[E0261] Error: use of undeclared lifetime name `'b`
   ╭─[command_64:1:1]
   │
 1 │ fn f<b>(r: &'a i32, s: &'b i32) -> &'a i32 { r }
   │      │                  ─┬
   │      ╰────────────────────── help: consider introducing lifetime `'b` here: `'b, `
   │                          │
   │                          ╰── undeclared lifetime
───╯
[E0261] Error: use of undeclared lifetime name `'a`
   ╭─[command_64:1:1]
   │
 1 │ fn f<b>(r: &'a i32, s: &'b i32) -> &'a i32 { r }
   │      │                              ─┬
   │      ╰────────────────────────────────── help: consider introducing lifetime `'a` here: `'a, `
   │                                      │
   │                                      ╰── undeclared lifetime
───╯
[non_camel_case_types] Error: type parameter `b` should have an upper camel case name
   ╭─[command_64:1:1]
   │
 1 │ fn f<b>(r: &'a i32, s: &'b i32) -> &'a i32 { r }
   │      ┬
   │      ╰── warning: type parameter `b` should have an upper camel case name
   │      │
   │      ╰── help: convert the identifier to upper camel case: `B`
───╯

Omitting Lifetime Parameters

struct S<'a, 'b> {
x: &'a i32,
y: &'b i32
}

fn sum_r_xy(r: &i32, s: S) -> i32 {
r + s.x + s.y
}

// fn sum_r_xy<'a, 'b, 'c>(r: &'a i32, s: S<'b, 'c>) -> i32

fn first_third(point: &[i32; 3]) -> (&i32, &i32) {
(&point[0], &point[2])
}

// fn first_third<'a>(point: &'a [i32; 3]) -> (&'a i32, &'a i32)

struct StringTable {
elements: Vec<String>,
}
impl StringTable {
    fn find_by_prefix(&self,prefix:&str) -> Option<&String> {
        for i in 0..self.elements.len() {
            if self.elements[i].starts_with(prefix) {
                return Some(&self.elements[i]);
            }
        }
        None
    }
}
// fn find_by_prefix<'a, 'b>(&'a self, prefix: &'b str) -> Option<&'a String>

Sharing Versus Mutation

let v = vec![4, 8, 19, 27, 34, 10];
let r = &v;
let aside = v; // move vector to aside
r[0]; // bad: uses `v`, which is now uninitialized

[unused_variables] Error: unused variable: `s`
[unused_variables] Error: unused variable: `p`
Error: The variable `r` contains a reference with a non-static lifetime so
can't be persisted. You can prevent this error by making sure that the
variable goes out of scope - i.e. wrapping the code in {}.

let v = vec![4, 8, 19, 27, 34, 10];
{
let r = &v;
r[0]; // ok: vector is still there
}
let aside = v;

fn extend(vec: &mut Vec<f64>, slice: &[f64]) {
for elt in slice {
vec.push(*elt);
}
}

let mut wave = Vec::new();
let head = vec![0.0, 1.0];
let tail = [0.0, -1.0];
extend(&mut wave, &head); // extend wave with another vector
extend(&mut wave, &tail); // extend wave with an array
assert_eq!(wave, vec![0.0, 1.0, 0.0, -1.0]);

extend(&mut wave, &wave);
assert_eq!(wave, vec![0.0, 1.0, 0.0, -1.0,
0.0, 1.0, 0.0, -1.0])

[unused_variables] Error: unused variable: `s`
[unused_variables] Error: unused variable: `p`
[E0502] Error: cannot borrow `wave` as immutable because it is also borrowed as mutable
   ╭─[command_83:1:1]
   │
 1 │ extend(&mut wave, &wave);
   │ ───┬── ────┬────  ──┬──
   │    ╰───────────────────── mutable borrow later used by call
   │            │        │
   │            ╰───────────── mutable borrow occurs here
   │                     │
   │                     ╰──── immutable borrow occurs here
───╯

Taking Arms Against a Sea of Objects

struct-enums-patterns

Long ago, when shepherds wanted to see if two herds of sheep were isomorphic, they would look for an explicit isomorphism. —John C. Baez and James Dolan, “

Named-Field Structs

// A rectangle of eight-bit grayscale pixels.
struct GrayscaleMap {
pixels: Vec<u8>,
size: (usize, usize)
}

let width = 1024;
let height = 576;
let image = GrayscaleMap {
pixels: vec![0; width * height],
size: (width, height)
};

image

[E0277] Error: `GrayscaleMap` doesn't implement `Debug`

/// A rectangle of eight-bit grayscale pixels.
// 模块外访问
pub struct GrayscaleMap {
pub pixels: Vec<u8>,
pub size: (usize, usize)
}

Tuple-Like Structs

#[derive(Copy, Clone, Debug)]
struct Bounds(usize, usize);

let image_bounds = Bounds(1024, 768);
image_bounds

The type of the variable image was redefined, so was lost.
Bounds(1024, 768)

Unit-Like Structs

struct A;
let a=A;

Struct Layout 内存布局

Defining Methods with impl

/// A first-in, first-out queue of characters.
pub struct Queue {
older: Vec<char>, // older elements, eldest last.
younger: Vec<char> // younger elements, youngest last.
}

impl Queue {
    pub fn push(&mut self,c: char) {
        self.younger.push(c);
    }
    pub fn pop(&mut self) -> Option<char> {
        if self.older.is_empty() {
            if self.younger.is_empty() {
                return None;
            }
            use std::mem::swap;
            swap(&mut self.older,&mut self.younger);
            self.older.reverse();
        }
        self.older.pop()
    }
}

let mut q = Queue { older: Vec::new(), younger: Vec::new() };
q.push('0');
q.push('1');
assert_eq!(q.pop(), Some('0'));
q.push('∞');
assert_eq!(q.pop(), Some('1'));
assert_eq!(q.pop(), Some('∞'));
assert_eq!(q.pop(), None);

impl Queue {
pub fn is_empty(&self) -> bool {
self.older.is_empty() && self.younger.is_empty()
}
}

assert!(q.is_empty());
q.push('☉');
assert!(!q.is_empty());

impl Queue {
pub fn split(self) -> (Vec<char>, Vec<char>) {
(self.older, self.younger)
}
}

let mut q = Queue { older: Vec::new(), younger: Vec::new() };

q.push('P');
q.push('D');
assert_eq!(q.pop(), Some('P'));
q.push('X');
let (older, younger) = q.split();
// q is now uninitialized.
assert_eq!(older, vec!['D']);
assert_eq!(younger, vec!['X'])

()

q

[E0425] Error: cannot find value `q` in this scope
   ╭─[command_23:1:1]
   │
 1 │ q
   │ ┬
   │ ╰── error: cannot find value `q` in this scope
   │ │
   │ ╰── help: a unit struct with a similar name exists: `A`
───╯

impl Queue {
    fn new() -> Queue {
        Queue { older: Vec::new(), younger: Vec::new() }
    }
}

let mut bq = Box::new(Queue::new());
bq.push('A')

()

use std::rc::Rc;

struct Node {
tag: String,
children: Vec<Rc<Node>>
}

impl Node {
    fn new(tag: &str) ->Node {
        Node {
            tag: tag.to_string(),
            children: vec![],
        }
    }
}

impl Node {
fn append_to(self: Rc<Self>, parent: &mut Node) {
parent.children.push(self);
}
}

let shared_node = Rc::new(Node::new("first"));

pub struct Vector2 {
x: f32,
y: f32,
}

impl Vector2 {
const ZERO: Vector2 = Vector2 { x: 0.0, y: 0.0 };
const UNIT: Vector2 = Vector2 { x: 1.0, y: 0.0 };
}

let scaled = Vector2::UNIT.x;

Generic Structs

pub struct TheQueue<T> {
older: Vec<T>,
younger: Vec<T>
}

impl<T> TheQueue<T> {
pub fn new() -> TheQueue<T> {
TheQueue { older: Vec::new(), younger: Vec::new() }
}
pub fn push(&mut self, t: T) {
self.younger.push(t);
}
pub fn is_empty(&self) -> bool {
self.older.is_empty() && self.younger.is_empty()
}
}

impl TheQueue<f64> {
    fn sum(&self) -> f64 {
        0_f64
    }
}

let mut q = TheQueue::<char>::new();

q.push('a');

Structs with Lifetime Parameters

struct Extrema<'elt> {
    greatest: &'elt i32,
    least: &'elt i32,
}

fn find_extrema<'s>(slice: &'s [i32]) -> Extrema<'s> {
let mut greatest = &slice[0];
let mut least = &slice[0];
for i in 1..slice.len() {
if slice[i] < *least { least = &slice[i]; }
if slice[i] > *greatest { greatest = &slice[i]; }
}
Extrema { greatest, least }
}

Deriving Common Traits for Struct Types

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

{
    use std::cell::RefCell;
let ref_cell: RefCell<String> =  RefCell::new("hello".to_string());
let r = ref_cell.borrow();
let count = r.len();
assert_eq!(count,5);
let mut w = ref_cell.borrow_mut();
w.push_str("world");
}

thread '<unnamed>' panicked at src/lib.rs:247:22:
already borrowed: BorrowMutError
stack backtrace:
   0: rust_begin_unwind
             at /rustc/a28077b28a02b92985b3a3faecf92813155f1ea1/library/std/src/panicking.rs:597:5
   1: core::panicking::panic_fmt
             at /rustc/a28077b28a02b92985b3a3faecf92813155f1ea1/library/core/src/panicking.rs:72:14
   2: core::cell::panic_already_borrowed
             at /rustc/a28077b28a02b92985b3a3faecf92813155f1ea1/library/core/src/cell.rs:762:5
   3: <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once
   4: run_user_code_39
   5: evcxr::runtime::Runtime::run_loop
   6: evcxr::runtime::runtime_hook
   7: evcxr_jupyter::main
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

Enums and Patterns

use std::cmp::Ordering;
fn compare(a: i32,b: i32) -> Ordering {
    if a > b {
        Ordering::Greater
    } else if a < b {
        Ordering::Less
    } else {
        Ordering::Equal
    }
}

enum HttpStatus {
Ok = 200,
NotModified = 304,
NotFound = 404,
}

use std::mem::size_of;
assert_eq!(size_of::<Ordering>(), 1);
assert_eq!(size_of::<HttpStatus>(), 2); // 404 doesn't fit in a u8

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
enum TimeUnit {
Seconds, Minutes, Hours, Days, Months, Years,
}

impl TimeUnit {
/// Return the plural noun for this time unit.
fn plural(self) -> &'static str {
match self {
TimeUnit::Seconds => "seconds",
TimeUnit::Minutes => "minutes",
TimeUnit::Hours => "hours",
TimeUnit::Days => "days",
TimeUnit::Months => "months",
TimeUnit::Years => "years",
}
}
/// Return the singular noun for this time unit.
fn singular(self) -> &'static str {
self.plural().trim_end_matches('s')
}
}

Enums in Memory

Patterns

enum RoughTime {
InThePast(TimeUnit, u32),
JustNow,
InTheFuture(TimeUnit, u32),
}

fn rough_time_to_english(rt: RoughTime) -> String {
 match rt {
 RoughTime::InThePast(units, count) =>
 format!("{} {} ago", count, units.plural()),
 RoughTime::JustNow =>
 format!("just now"),
 RoughTime::InTheFuture(units, count) =>
 format!("{} {} from now", count, units.plural()),
 }
}

fn greet_people(names: &[&str]) {
match names {
[] => { println!("Hello, nobody.") },
[a] => { println!("Hello, {}.", a) },
[a, b] => { println!("Hello, {} and {}.", a, b) },
[a, .., b] => { println!("Hello, everyone from {} to {}.", a, b) }
}
}

// An ordered collection of `T`s.
enum BinaryTree<T> {
Empty,
NonEmpty(Box<TreeNode<T>>),
}
// A part of a BinaryTree.
struct TreeNode<T> {
element: T,
left: BinaryTree<T>,
right: BinaryTree<T>,
}

impl <T: Ord> BinaryTree<T> {
    fn add(&mut self,value :T) {
        match *self {
            BinaryTree::Empty => {
                *self = BinaryTree::NonEmpty(Box::new(
                    TreeNode {
                        element: value,
                        left: BinaryTree::Empty,
                        right: BinaryTree::Empty,
                    }
                ))
            },
            BinaryTree::NonEmpty(ref mut node) => {
                if value <= node.element {
                    node.left.add(value);
                } else {
                    node.right.add(value);
                }
            }
        }
    }
}

Structs

LISP programmers know the value of everything, but the cost of nothing. —Alan Perlis, epigram > >

Error Handling

I knew if I stayed around long enough, something like this would happen. —George Bernard Shaw on dying

use std::error::Error;
use std::io::{Write,stderr};
fn print_error(mut err: &dyn Error) {
    let _ = writeln!(stderr(),"error: {}",err);
    while let Some(source) = err.source() {
        let _ = writeln!(stderr(),"cased by :{}",source);
        err = source;
    }
}

let weather = match get_weather(hometown) {
Ok(success_value) => success_value,
Err(err) => return Err(err)
};

Crates and Modules

mod spores {
use cells::{Cell, Gene};
/// A cell made by an adult fern. It disperses on the wind as part of
/// the fern life cycle. A spore grows into a prothallus -- a whole
/// separate organism, up to 5mm across -- which produces the zygote
/// that grows into a new fern. (Plant sex is complicated.)
pub struct Spore {
...
}
/// Simulate the production of a spore by meiosis.
pub fn produce_spore(factory: &mut Sporangium) -> Spore {
...
}
/// Extract the genes in a particular spore.
pub(crate) fn genes(spore: &Spore) -> Vec<Gene> {
...
}
/// Mix genes to prepare for meiosis (part of interphase).
fn recombine(parent: &mut Cell) {
...
}
...
}

bin

Attributes

Test

#[test]
fn trig_works() {
use std::f64::consts::PI;
assert!(roughly_equal(PI.sin(), 0.0));
}
```rust
#[cfg(test)] // 仅当run test时才会include 这个模块
// include this module only when testing
mod tests {
fn roughly_equal(a: f64, b: f64) -> bool {
(a - b).abs() < 1e-6
}
#[test]
fn trig_works() {
use std::f64::consts::PI;
assert!(roughly_equal(PI.sin(), 0.0));
}
}

Documentation

Package Versions

Input and Output

use std::io::{self, Read, Write, ErrorKind};
const DEFAULT_BUF_SIZE: usize = 8 * 1024;
pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W)
    -> io::Result<u64>
    where R: Read,W: Write
    {
        let mut buf = [0; DEFAULT_BUF_SIZE];
        let mut writern = 0;
        loop {
            let len = match reader.read(&mut buf) {
                Ok(0) => return Ok(writern),
                Ok(len) => len,
                Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
                Err(e) => return Err(e),
            };
            writer.write_all(&buf[..len])?;
            writern += len as u64;
        }
    }

use std::io;
use std::io::prelude::*;
fn grep(target: &str) -> io::Result<()> {
    let stdin = io::stdin();
    for line_result in stdin.lock().lines() {
        let line = line_result?;
        if line.contains(target) {
            println!("{}",line);
        }
    }
    Ok(())
}

fn grep<R>(target: &str, reader: R) -> io::Result<()>
where R: BufRead
{
for line_result in reader.lines() {
let line = line_result?;
if line.contains(target) {
println!("{}", line);
}
}
Ok(())
}

// let stdin = io::stdin();
// grep(&target, stdin.lock())?; // ok
// let f = File::open(file)?;
// grep(&target, BufReader::new(f))?; // also o

use std::fs::OpenOptions;
let log = OpenOptions::new()
    .append(true)
    .open("server.log").unwrap_err();
let file = OpenOptions::new()
    .write(true)
    .create_new(true)
    .open("new_file.log").unwrap_err();

thread '<unnamed>' panicked at src/lib.rs:138:27:
called `Result::unwrap_err()` on an `Ok` value: File { fd: 3, path: "/home/realcpf/Documents/rustRepos/rust-prog-2021/new_file.log", read: false, write: true }
stack backtrace:
   0: rust_begin_unwind
             at /rustc/a28077b28a02b92985b3a3faecf92813155f1ea1/library/std/src/panicking.rs:597:5
   1: core::panicking::panic_fmt
             at /rustc/a28077b28a02b92985b3a3faecf92813155f1ea1/library/core/src/panicking.rs:72:14
   2: core::result::unwrap_failed
             at /rustc/a28077b28a02b92985b3a3faecf92813155f1ea1/library/core/src/result.rs:1652:5
   3: <unknown>
   4: <unknown>
   5: evcxr::runtime::Runtime::run_loop
   6: evcxr::runtime::runtime_hook
   7: evcxr_jupyter::main
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

use std::process::{Command, Stdio};
let mut child =
Command::new("grep")
.arg("-e")
.arg("a.*e.*i.*o.*u")
.stdin(Stdio::piped())
.spawn()?;
let mut to_child = child.stdin.take().unwrap();
for word in my_words {
writeln!(to_child, "{}", word)?;
}
drop(to_child); // close grep's stdin, so it will exit
child.wait()?;

[E0425] Error: cannot find value `my_words` in this scope
   ╭─[command_12:1:1]
   │
 9 │ for word in my_words {
   │             ────┬───
   │                 ╰───── not found in this scope
───╯

use std::path::Path;
let home_dir = Path::new("/home/realcpf");

assert_eq!(home_dir.parent(),Some(Path::new("/home")));

use std::ffi::OsStr;
assert_eq!(Path::new("/home/fwolfe/program.txt").file_name(),
Some(OsStr::new("program.txt")));

let path1 = Path::new("/usr/share/dict");
assert_eq!(path1.join("words"),
Path::new("/usr/share/dict/words"));

let file = Path::new("/home/jimb/calendars/calendar-18x18.pdf");
assert_eq!(file.ancestors().collect::<Vec<_>>(),
vec![Path::new("/home/jimb/calendars/calendar-18x18.pdf"),
Path::new("/home/jimb/calendars"),
Path::new("/home/jimb"),
Path::new("/home"),
Path::new("/")])

()

use std::fs;
use std::io;
use std::path::Path;
/// Copy wha tever is at `src` to the target path `dst`.
fn copy_to(src: &Path, src_type: &fs::FileType, dst: &Path)
-> io::Result<()>
{
if src_type.is_file() {
fs::copy(src, dst)?;
} else if src_type.is_dir() {
copy_dir_to(src, dst)?;
} else {
return Err(io::Error::new(io::ErrorKind::Other,
format!("don't know how to copy: {}",
src.display())));
}
Ok(())
}
// Copy the existing directory `src` to the target path `dst`.
fn copy_dir_to(src: &Path, dst: &Path) -> io::Result<()> {
if !dst.is_dir() {
fs::create_dir(dst)?;
}
for entry_result in src.read_dir()? {
let entry = entry_result?;
let file_type = entry.file_type()?;
copy_to(&entry.path(), &file_type, &dst.join(entry.file_name()))?;
}
Ok(())
}

#[cfg(unix)]
use std::os::unix::fs::symlink;
/// Stub implementation of `symlink` for platforms that don't provide it.
#[cfg(not(unix))]
fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(src: P, _dst: Q)
-> std::io::Result<()>
{
Err(io::Error::new(io::ErrorKind::Other,
format!("can't copy symbolic link: {}",
src.as_ref().display())))
}

use std::net::TcpListener;
use std::io;
use std::thread::spawn;
/// Accept connections forever, spawning a thread for each one.
fn echo_main(addr: &str) -> io::Result<()> {
let listener = TcpListener::bind(addr)?;
println!("listening on {}", addr);
loop {
// Wait for a client to connect.
let (mut stream, addr) = listener.accept()?;
println!("connection received from {}", addr);
// Spawn a thread to handle this client.
let mut write_stream = stream.try_clone()?;
spawn(move || {
// Echo everything we receive from `stream` back to it.
io::copy(&mut stream, &mut write_stream)
.expect("error in client thread: ");
println!("connection closed");
});
}
}
fn main() {
echo_main("127.0.0.1:17007").expect("error: ");
}

use std::error::Error;
use std::io;
fn http_get_main(url: &str) -> Result<(), Box<dyn Error>> {
// Send the HTTP request and get a response.
let mut response = reqwest::blocking::get(url)?;
if !response.status().is_success() {
Err(format!("{}", response.status()))?;
}
    // Read the response body and write it to stdout.
let stdout = io::stdout();
io::copy(&mut response, &mut stdout.lock())?;
Ok(())
}
fn main() {
let args: Vec<String> = std::env::args().collect();
if args.len() != 2 {
eprintln!("usage: http-get URL");
return;
}
if let Err(err) = http_get_main(&args[1]) {
eprintln!("error: {}", err);
}
}
```rust

Strings and Text

assert_eq!("うどん: udon".as_bytes(),
&[0xe3, 0x81, 0x86, //う
0xe3, 0x81, 0xa9, //ど
0xe3, 0x82, 0x93, //ん
0x3a, 0x20, 0x75, 0x64, 0x6f, 0x6e // : udon
]);

assert_eq!(" ערבטוב ".chars().next(), Some('ע'));

thread '<unnamed>' panicked at src/lib.rs:6:1:
assertion `left == right` failed
  left: Some(' ')
 right: Some('ע')
stack backtrace:
   0: rust_begin_unwind
             at /rustc/a28077b28a02b92985b3a3faecf92813155f1ea1/library/std/src/panicking.rs:597:5
   1: core::panicking::panic_fmt
             at /rustc/a28077b28a02b92985b3a3faecf92813155f1ea1/library/core/src/panicking.rs:72:14
   2: core::panicking::assert_failed_inner
   3: <unknown>
   4: <unknown>
   5: evcxr::runtime::Runtime::run_loop
   6: evcxr::runtime::runtime_hook
   7: evcxr_jupyter::main
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

assert_eq!("カニ".chars().next(), Some('カ'))

()

assert!(32u8.is_ascii_whitespace());
assert!(b'9'.is_ascii_digit())

()

// char::is_ascii_whitespace函数实现了许多Web标准通用的空格定义，
// 而char::is_whitespace遵循Unicode标准。

let line_tab = '\u{000b}'; // 'line tab', AKA 'vertical tab'
assert_eq!(line_tab.is_whitespace(), true);
assert_eq!(line_tab.is_ascii_whitespace(), false)

()

assert_eq!('F'.to_digit(16), Some(15));
assert_eq!(std::char::from_digit(15, 16), Some('f'));
assert!(char::is_digit('f', 16));

let mut upper = 's'.to_uppercase();
assert_eq!(upper.next(), Some('S'));
assert_eq!(upper.next(), None);

// The uppercase form of the German letter "sharp S" is "SS":
let mut upper = 'ß'.to_uppercase();
assert_eq!(upper.next(), Some('S'));
assert_eq!(upper.next(), Some('S'));
assert_eq!(upper.next(), None);

// Unicode says to lowercase Turkish dotted capital 'İ' to 'i'
// followed by `'\u{307}'`, COMBINING DOT ABOVE, so that a
// subsequent conversion back to uppercase preserves the dot.
let ch = 'İ'; // `'\u{130}'`
let mut lower = ch.to_lowercase();
assert_eq!(lower.next(), Some('i'));
assert_eq!(lower.next(), Some('\u{307}'));
assert_eq!(lower.next(), None)

()

assert_eq!('B' as u32, 66);
assert_eq!('饂' as u8, 66); // upper bits truncated
assert_eq!('二' as i8, -116); // same

assert_eq!(char::from(66), 'B');
assert_eq!(std::char::from_u32(0x9942), Some('饂'));
assert_eq!(std::char::from_u32(0xd800), None); // reserved for UTF-16

let spacey = "man hat tan";
let spaceless: String =
spacey.chars().filter(|c| !c.is_whitespace()).collect();
assert_eq!(spaceless, "manhattan");

let full = "bookkeeping";
assert_eq!(&full[..4], "book");
assert_eq!(&full[5..], "eeping");
assert_eq!(&full[2..4], "ok");
assert_eq!(full[..].len(), 11);
assert_eq!(full[5..].contains("boo"), false)

()

let parenthesized = "Rust (饂)";
assert_eq!(parenthesized[6..].chars().next(), Some('饂'));

let mut also_spaceless = "con".to_string();
also_spaceless.extend("tri but ion".split_whitespace());
assert_eq!(also_spaceless, "contribution");

use std::fmt::Write;
let mut letter = String::new();
writeln!(letter, "Whose {} these are I think I know", "rutabagas")?;
writeln!(letter, "His house is in the village though;")?;
assert_eq!(letter, "Whose rutabagas these are I think I know\n\
His house is in the village though;\n");

let left = "partners".to_string();
let mut right = "crime".to_string();
assert_eq!(left + " in " + &right, "partners in crime");
right += " doesn't pay";
assert_eq!(right, "crime doesn't pay")

()

// 返回给定字节索引范围内的迭代器，并在删除迭代器后删除字符。范围后的字符向前面移动
let mut choco = "chocolate".to_string();
assert_eq!(choco.drain(3..6).collect::<String>(), "col");
assert_eq!(choco, "choate");

let mut beverage = "a piña colada".to_string();
beverage.replace_range(2..7, "kahlua"); // 'ñ' is two bytes!
assert_eq!(beverage, "a kahlua colada");

let haystack = "One fine day, in the middle of the night";
assert_eq!(haystack.find(','), Some(12));
assert_eq!(haystack.find("night"), Some(35));
assert_eq!(haystack.find(char::is_whitespace), Some(3));

assert_eq!("## Elephants"
.trim_start_matches(|ch: char| ch == '#' || ch.is_whitespace()),
"Elephants");

let code = "\t function noodle() { ";
assert_eq!(code.trim_start_matches([' ', '\t'].as_ref()),
"function noodle() { ");
// Shorter equivalent: &[' ', '\t'][..]

assert!("2017".starts_with(char::is_numeric));

let quip = "We also know there are known unknowns";
assert_eq!(quip.find("know"), Some(8));
assert_eq!(quip.rfind("know"), Some(31));
assert_eq!(quip.find("ya know"), None);
assert_eq!(quip.rfind(char::is_uppercase), Some(0));

assert_eq!("The only thing we have to fear is fear itself"
.replace("fear", "spin"),
"The only thing we have to spin is spin itself");
assert_eq!("`Borrow` and `BorrowMut`"
.replace(|ch:char| !ch.is_alphanumeric(), ""),
"BorrowandBorrowMut");

assert_eq!("élan".char_indices().collect::<Vec<_>>(),
vec![(0, 'é'), // has a two-byte UTF-8 encoding
(2, 'l'),
(3, 'a'),
(4, 'n')]);

assert_eq!("élan".bytes().collect::<Vec<_>>(),
vec![195, 169, b'l', b'a', b'n']);

// The ':' characters are separators here. Note the final "".
assert_eq!("jimb:1000:Jim Blandy:".split(':').collect::<Vec<_>>(),
vec!["jimb", "1000", "Jim Blandy", ""]);
// The '\n' characters are terminators here.
assert_eq!("127.0.0.1 localhost\n\
127.0.0.1 www.reddit.com\n"
.split_terminator('\n').collect::<Vec<_>>(),
vec!["127.0.0.1 localhost",
"127.0.0.1 www.reddit.com"]);
// Note, no final ""!

let poem = "This is just to say\n\
I have eaten\n\
the plums\n\
again\n";
assert_eq!(poem.split_whitespace().collect::<Vec<_>>(),
vec!["This", "is", "just", "to", "say",
"I", "have", "eaten", "the", "plums",
"again"]);