Rust

An enum type takes up the memory space as large as its largest variant.

enum <ident> {
  <ident>(<data types>),
  <ident>,
}

The memory layout of enum contains:

• tag: small integer for variant identification
• payload: the actual data.

A struct type holds sequence of data, just like C.

A trait definition declares the method signatures,

trait <ident> {
  fn <ident>(<parameters>) -> <return type>,
}

Actual implementation is needed for each type.

impl <trait ident> for <type ident> {
  fn <ident>(<parameters>) -> <return type> {
    <implementation>
  },
}

A function can be defined on a generic type that implements certain traits

fn <ident>\<T: <traits+>\>(<ident>: T) { ... }

This code does static dispatching, which generates the function for each concrete type on demand, just like C++ template.

Dynamic dispatching is also possible through dyn keyword:

fn <ident>(<ident>: Box\<dyn <trait>\>) { ... }

which calls the function via the function pointer in the vtable generated automatically, similar to C++ virtual method.

Box, & or other indirection is needed in order to fix the size of argument for compilation.

Only single variable can own a data. Others should use references for the data. Multiple references (&) can exists simultaneously, while there can only be single mutable reference (&mut).

Smart pointers are pointer with additional functionality. Some of the smart pointers need extra information stored with the memory address, in which case the pointer is called a fat pointer.

• Box<T> moves the ownership of the pointer just like C++ std::unique_ptr does.
• Rc<T> stores reference counts with the pointer.
• Arc<T> enables sharing pointer across threads. T is required to implement Sync for the ability to be shared across multiple threads.

Lifetime is a range in the source code in which the reference is valid. Lifetime ends when the scope is terminated. Note that empty lines and lines before the assignment does not count.

A generic lifetime for multiple references represents the intersections of all their lifetimes.

fn f<'a>(x: &'a T, y: &'a U) -> V: 'a { ... };

The return value is valid while the all the arguments are valid.

A lifetime constraints can be used for complex case:

fn f<'a, 'b, 'c>(x: &'a T, y: &'b U) -> V: 'c
where
  'a: 'c,
  'b: 'c,
{ ... }    

This means both lifetime 'a and 'b lives longer than 'c.

The default lifetime is indicated by '_, and the lifetime valid throughout the code is indicated by 'static. 'static is used for string literal, and by default Future type.

Defined with !macro_rules macro with the following syntax:

macro_rules! <macro ident> {
 (<$meta variable>:<fragment specifier>) => {
   <replacement code($meta variable)>
 };
 // more matches...
}

The fragment specifier can be

• expr
• ident
• ty
• path
• literal
• block
• stmt
• pat

Compile-time function on the token sequence to token sequence. It is usually as parser-retokenization pair with syn and quote crate respectively.

Three form of procedural macro exists:

• function-like: called inline just like function
• derive macro: annotated on top of a code block or statement as #[derive(...)]
• attribute macro: annotated similarly but with more flexibility.