1
2
3
4
5

{                      // s is not valid here, it’s not yet declared
    let s = "hello";   // s is valid from this point forward

    // do stuff with s
}                      // this scope is now over, and s is no longer valid

1
2
3
4
5

{                      
    let mut s = String::from("hello");   // s is valid from this point forward

    // do stuff with s
}                      // this scope is now over, and s is no longer valid

1
2

let x = 5;
let y = x;

1
2

let s1 = String::from("hello");
let s2 = s1;

1
2
3
4

let s1 = String::from("hello");
let s2 = s1;

println!("{}, world!", s1);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:5:28
  |
2 |     let s1 = String::from("hello");
  |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 | 
5 |     println!("{}, world!", s1);
  |                            ^^ value borrowed here after move

For more information about this error, try `rustc --explain E0382`.
error: could not compile `ownership` due to previous error

1
2
3
4

let s1 = String::from("hello");
let s2 = s1.clone();

println!("s1 = {}, s2 = {}", s1, s2);

1
2
3
4
5
6
7
8
9

fn main() {
    let s = String::from("hello");  // s comes into scope

    takes_ownership(s);   
}
fn takes_ownership(some_string: String) { // some_string comes into scope
    println!("{}", some_string);
} // Here, some_string goes out of scope and `drop` is called. The backing
  // memory is freed.

1
2
3
4
5
6
7
8
9
10
11

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

1
2
3
4
5
6

let mut s = String::from("hello");

let r1 = &mut s;
let r2 = &mut s;

println!("{}, {}", r1, r2);

1
2
3
4
5
6
7
8
9
10
11
12

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut s;
  |              ------ first mutable borrow occurs here
5 |     let r2 = &mut s;
  |              ^^^^^^ second mutable borrow occurs here
6 | 
7 |     println!("{}, {}", r1, r2);
  |                        -- first borrow later used here

1
2
3
4
5
6
7

let mut s = String::from("hello");

let r1 = &s; // no problem
let r2 = &s; // no problem
let r3 = &mut s; // BIG PROBLEM

println!("{}, {}, and {}", r1, r2, r3);

1
2
3
4
5
6
7
8
9

let mut s = String::from("hello");

let r1 = &s; // no problem
let r2 = &s; // no problem
println!("{} and {}", r1, r2);
// variables r1 and r2 will not be used after this point

let r3 = &mut s; // no problem
println!("{}", r3);

1
2
3
4
5
6
7
8
9
10

fn main() {
    let reference_to_nothing = dangle();
}
fn dangle() -> &String { // dangle returns a reference to a String

    let s = String::from("hello"); // s is a new String

    &s // we return a reference to the String, s
} // Here, s goes out of scope, and is dropped. Its memory goes away.
  // Danger!

1
2
3
4
5
6
7
8
9
10

let s = String::from("hello world");

let hello = &s[0..5];
let world = &s[6..11];

let len = s.len();

let slice = &s[3..len];
let slice = &s[3..];
let slice = &s[..];

1
2
3
4
5
6
7
8
9
10

fn main() {
    let mut s = String::from("hello world");

    let word = &s[..5];

    s.push_str("!!"); // error!

    println!("the first word is: {}", word);

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
  --> src/main.rs:10:5
   |
8  |     let word = &s[..5];
   |                 - immutable borrow occurs here
9  | 
10 |     s.push_str("!!"); // error!
   |     ^^^^^^^^^^^^^^^^ mutable borrow occurs here
11 | 
12 |     println!("the first word is: {}", word);
   |                                       ---- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.

1

let s = "hello world";

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

fn main() {
    let my_string = String::from("hello world");

    // `first_word` works on slices of `String`s, whether partial or whole
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    // `first_word` also works on references to `String`s, which are equivalent
    // to whole slices of `String`s
    let word = first_word(&my_string);

    let my_string_literal = "hello world";

    // `first_word` works on slices of string literals, whether partial or whole
    let word = first_word(&my_string_literal[0..6]);
    let word = first_word(&my_string_literal[..]);

    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
}