Distinguishing Rust

Rust uses C++ style scope-based resource management. Its clever design prevents unsound memory accesses and data races. That's achieved with compile-time reference analysis augmented with occasional run-time checks. Raw pointers are not allowed. Indirection is achieved with references that are pointers wrapped in a strict ownership policy.

Not required since constructors do not share the type name. Rust generics and traits allow you to define functions that will operate over a set of types.

Rust supports inheriting one or more traits which may have function definitions, but can not have data members. A struct inherits a trait by an impl statement:

Rust supports casting with the "as" keyword, and provides conversion functions for some standard types. Application programs may also provide conversion methods.

Our goal: use no unsafe blocks, deferring instead to std::library facilities where the Rust designers used, and carefully vetted, unsafe blocks to provide functionality we need.

Structs and their child members are accessible anywhere in the crate¹ of definition, but require a pub declaration to become accessible in another crate. Methods are declared in a separate "impl" block.

---

That is the set of primitive types and aggregates that have only copy type members.

Operations of construction, assignment, passing arguments and returning results from functions by value will move ownership of resources from source to destination. That's fast, usually just a few bytes copied.

Unlike C++, you don't have to, and can't, define implicitly called copy and move constructors and assignment operators.

User defined semantics are not needed due to the way data is managed in Rust.

Clones make deep copies and are always invoked explicitly.

enum StepState { NotStarted, Reading { refs: Vec<String> }, ... }

match state {
  StepState::NotStarted => print!("\n getting late"),
  StepState::Reading { refs } => print!("\n reading {:?}", refs),
   ...
}

Strings have an iterator over their characters, chars().

let third_char = my_string.chars().nth(2);

let mut x = 42;
let rx = &mut x;

This means, essentially, that a Rust program cannot read or write to memory it does not own. One nearly equivalent statement is that Rust will not change the contents a reference points to unless the reference is mutable and responsible for the change.

We will (eventually) illustrate that with a Directed Graph type that holds its vertices in a Vec<Vertex>.

The Rust compiler's "borrow-checker" analyzes reference lifetimes and refuses to compile cases where it cannot prove this invariant.

Usually it can do that silently, but, on occasion it needs help and askes you to provide lifetime annotations. To see an example, look at RustBites Pluggin reference.

Owned resources are released when owner goes out of scope, and transferred when owner is moved.

Using Box<T> places t ε T in the heap and implicitly dereferences the Box pointer, giving code access to T's interface. Most of the Rust std::library containers place their contents in the heap, e.g., vector, dequeue, map, ...

enum Result<T, E> { Ok(T), Err(E) }
enum Option<T> { Some(T), None }

It also means that Strings cannot be indexed. Program code uses, instead, the iterator chars() that knows how to detect bit sequences denoting character boundaries.