Synopsis:

• Rust provides two categories of types: copy and move. Copy types occupy a single contiguous block of stack memory. Move types have control blocks in stack memory used to manage resources in the heap.
• Primitive types and aggregates of primitive types are copy. Construction, assignment, and pass-by-value copies the source's value to the destination.
• All other types are move. Construction, assignment, and pass-by-value move ownership of the value's heap resources to the destination. This makes the source invalid. Attempting to use a "moved" variable is a compile error.
• The source and destination of copy and move operations must have exactly the same type.
• More details about copy and move operations can be found in Rust Bite - Data Operatons, including diagrams and code examples.
• Most move types provide clone operations that support making copies, but using code must explicitly call clone().
• Rust supports making fixed references to either copy or move types. These may refer to instances in a function's stack memory, in the native heap, or in the program's static memory.
• Rust references are constrained by Rust ownership rules to support memory and data race safety by construction. All values in memory have a single owner, responsible for its creation, access, and deallocation.
• Ownership can be borrowed by creating a reference. Program code may create an arbitrary number of non-mutable references to some variable, but may only create a single mutable reference that borrows exclusive access to the variable.
• Rust's type system plays a dominant role in providing memory and data race safety.
• Here we begin to see significant differences between the languages, especially when comparing statically typed languages like C++, Rust, and C#, with dynamically typed languages like Python and JavaScript.

• Binding a name to a value assigns ownership of the value to the named variable. Only the owner has the authority to modify, use, or deallocate the value. No other variable can access or modify the value without borrowing the priviledge to do so from the owner.
• A collection like Vec<T> owns its members. In the code segment below, v owns the vector, and the vector owns the elements [1, 2, 3]. Program code can access them by taking a reference:

  let v = vec![1, 2, 3];
  let rv = &v3[1];
  

2.2 Borrows - Rust References

• References are used to borrow access to a variable from its owner, e.g., let rv = &v. Rust enforces strict rules for the use of references in order to guarantee memory and thread safety.
• • Non-mutable references can share read-only access to a value. Multiple shared references to a single owned value are valid.
  • Mutable references, often called exclusive references, provide exclusive access to the value. No other references can access the value until the end of the mutable reference's lifetime. That usually occurs when the mutable reference goes out of scope.
  • These rules apply to use, not declaration.
• This is a strong constraint that may occasionally affect the way programs are designed. No shared mutability ensures that references to a collection, like Vec<T>, don't dangle when the collection reallocates its resource memory to provide more capacity.

  Example: Attempt to mutate collection with active reference

    show_op("attempt to mutate Vec while immutable ref exists");
  let mut v3 = vec![1, 2, 3];
  let rv3 = &v3[1]; // ok to declare
  v3.push(4);  // v3 will reallocate if capacity is 3
  println!("  rv3: {rv3:?}"); // not ok to use
  

  Example: Compiler error message

  C:\github\JimFawcett\Bits\Rust\rust_data
  > cargo run
  Compiling rust_data v0.1.0 (C:\github\JimFawcett\Bits\Rust\rust_data)
  error[E0502]: cannot borrow `v3` as mutable because it is also borrowed as immutable
  --> src\main.rs:417:3
  |
  416 |   let rv3 = &v3[1]; // ok to declare
  |              -- immutable borrow occurs here
  417 |   v3.push(4);  // v3 will reallocate if capacity is 3
  |   ^^^^^^^^^^ mutable borrow occurs here
  418 |   println!("  rv3: {rv3:?}"); // not ok to use
  |                     ------- immutable borrow later used here    
  
  For more information about this error, try `rustc --explain E0502`.   
  error: could not compile `rust_data` (bin "rust_data") due to previous error
  

2.3 Copy, Move, and Clone Operations

• Copy of primitives and Move are efficient because they copy only a few bytes. Clone is expensive for a collection as it copies both the collection control block and all its heap resources.
• Some Rust types implement the Copy trait. All primitives and aggregations of primitives are "copy" types. All other types are "move".
• For all copy types, construction, assignment, and pass-by-value results in data copy with no transfer of ownership, so the source is still valid.
  The str type represents a constant literal string in static memory. All str's are accessed by a reference, &str. The reference &str is copy. So copying an &str results in a second reference pointing to the original address. Figure 1. Str Copy

  Example: &str copy

    let lstrs = "literal string";  // copy type
  let lstrd = lstrs;
  println!("  source: {lstrs:?}, address: {:p}", lstrs);
  println!("  destin: {lstrd:?}, address: {:p}", lstrd);
  nl();
  println!("  Note: a literal string is a fixed value in memory.
  All access occurs through a reference, so copies just copy
  the reference. Both variables point to the same address." 
  );

  Example: Results of &str copy

  --- direct copy &str ---
  source: "literal string", address: 0x7ff7e742b590
  destin: "literal string", address: 0x7ff7e742b590
  
  Note: a literal string is a fixed value in memory.
  All access occurs through a reference, so copies just copy
  the reference. Both variables point to the same address.
  
• For all move types ownership will be transferred to another variable by construction, assignment, or pass-by-value as a function argument. A "moved-from" variable is invalid. Any use of that will result in a compile error.
  Move is a very efficient operation, copying only a few bites instead of the entire object. When a copy is needed, the developer can choose to explicitly clone the original value. Figure 2. String Move

  Example: String Move

  let s = String::from("a string");
  let addrvec = &s;
  let addrzero = std::ptr::addr_of!(s.as_bytes()[0]);
  println!("address of s: {:p}", addrvec);
  println!("address of first byte of s's char buffer: {:p}\n", addrzero);
  
  let t = s;  // move
  let addrvec = &t;
  let addrzero = std::ptr::addr_of!(t.as_bytes()[0]);
  println!("address of t: {:p}", addrvec);
  println!("address of first byte of t's char buffer: {:p}\n", addrzero);

  Example: Results of String Move

  --- demo_move for String ---
  
  --- let s = String::from("a string") ---
  address of s: 0x25758ff558
  address of first byte of s's char buffer: 0x1725ee5dcd0
  
  --- let t:String = s; // move ---
  address of t: 0x25758ff600
  address of first byte of t's char buffer: 0x1725ee5dcd0
  
  Note: s and t are unique objects
  that share same buffer
  but now, s is invalid
  
• Move types usually implement the Clone trait with the function clone(). Calling clone makes an independent copy of the source. The original and clone are independent entities with different owners. They have the same values immediately following the clone operation, but may mutate to different values, independently. Figure 3. String Clone

  Example: String Clone

  let s_src = String::from("a string");
  let s_src_addr = &s_src;
  let s_src_bufaddr = std::ptr::addr_of!(s_src.as_bytes()[0]);
  println!("  s_src: {:?}, address: {:p}", s_src, s_src_addr);
  println!("  s_src_bufaddr: {:p}", s_src_bufaddr);
  let s_cln = s_src.clone();
  let s_cln_addr = &s_cln;
  let s_cln_bufaddr = std::ptr::addr_of!(s_cln.as_bytes()[0]);
  println!("  s_cln: {:?}, address: {:p}", s_cln, s_cln_addr);
  println!("  s_cln_bufaddr: {:p}", s_cln_bufaddr);
  nl();
  println!("  Note: s_src and s_cln have different addresses
  and their buffers have different addresses.
  So they are unique entities.");
  

  Example: Results of String Clone

  --- string clone ---
  s_src: "a string", address: 0x7610d0f390
  s_src_bufaddr: 0x229473682f0
  s_cln: "a string", address: 0x7610d0f448
  s_cln_bufaddr: 0x22947375d00
  
  Note: s_src and s_cln have different addresses
  and their buffers have different addresses.
  So they are unique entities.
  

2.4 Indexing

3.0 Epilogue

4.0 References