Study notes: Rust

Based on the Rustlings tutorial and The Rust Programming Language by Steve Klabnik and Carol Nichols

See also: On Rustlings and training material

Variables

Don’t need to specify the type when declaring a variable if providing a value (assigning) in the same statement.

Values are not cast/coerced if the type doesn’t match exactly:

let x: i32 = 10.0; // FAIL

Integer types: u8, i32, etc. — not int. See Primitive types § Integers.

Can’t change the value of a variable unless it was declared with “mut”:

let mut x = 5;
x = 6;

Constant values must be declared with a type, and the value must be known at compile time:

const x: i8 = 2;

Can reuse a variable name, even with a different type, by shadowing it with a new “let” statement:

let x = "three";
let x = 3;
println!(x + 2);

Declared but unassigned (uninitialised) variables do not get a default “zero” value, unlike in Java. So they can’t be used before they’ve been assigned a value:

let x: i32;
// println!("{}", x);  // FAIL
x = 10;
println!("{}", x);  // OK

Conditionals

Multiple branches/arms:

if cond { 1 } else if cond2 == "2" { 2 } else { 0 }

No need for brackets around the condition expression.

To implictly return from a branch, make the if/else the last expression in the function and the value the last expression in the branch. And don’t use “;” — that would make it a statement (that has no effect) and the branch wouldn’t return anything.

Functions

Declared with the “fn” keyword:

fn main() { println!(...); }

Order of function declaration in the source code doesn’t matter.

Cannot redefine a function in the same namespace.

Parameters require a type annotation:

fn call(x: u8) { ... }

Parameters are required at the call site — can’t set defaults. [I think. Though you could accept an Option type and call .unwrap_or(default) on it.]

Return type must be specified in the function definition, unless it is () i.e. void:

fn inc(i: i32) -> i32 { i + 1 }

If the function block ends in an expression/value, the value is returned implicitly. Can also use a “return” statement to explicitly return, e.g. to break out of a loop early:

fn call(x: u8) -> u8 {
  if x == 1 {
    return x;
  }
  x * 2
}

NB: Don’t use a “;” at the end of the returned expression. “x * 2;” is a statement with no return value.

Ranges

0..3 means 0, 1, 2.

for i in 0..x { println!("{}", i); }

0..-2 is () / an empty iterator.

String interpolation

In the expression println!("{}", i):

• println! is a macro.
• The first argument has to be a string literal, containing a set of braces for each additional argument.
• "{}" means just print the value (using its Display trait, I think). So the value of i gets coerced into a string.
• Use "{:?}" to get the debugging representation instead — e.g. for a custom struct prepended with the #[derive(Debug)] attribute.

Comment syntax

Inline: some /* comment */ code

To end of line:

// comment
some code // comment

Primitive types

let x: u8 = 10;
let x = 10u8;

let x: bool = true;

let a = [1, 2];

let a = [0; 5];
// equivalent to:
let a = [0, 0, 0, 0, 0];

let t = ("a", 1);

let (s, n) = t;

let t: (f32, bool) = (1.0, true);

let x = t.0;
assert_eq!(x, 1.0);