Rust by Example

let sum = parsed + turbo_parsed;

println!("Sum: {:?}", sum);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Expressions

A Rust program is (mostly) made up of a series of statements:

fn main() {

// statement

// statement

// statement

}

There are a few kinds of statements in Rust. The most common two are declaring a variable binding, and using a ; with an expression:

fn main() {

// variable binding

let x = 5;

// expression;

x;

x + 1;

15;

}

Blocks are expressions too, so they can be used as values in assignments. The last expression in the block will be assigned to the place expression such as a local variable. However, if the last expression of the block ends with a semicolon, the return value will be ().

fn main() {

let x = 5u32;

let y = {

let x_squared = x * x;

let x_cube = x_squared * x;

// This expression will be assigned to `y`

x_cube + x_squared + x

};

let z = {

// The semicolon suppresses this expression and `()` is assigned to `z`

2 * x;

};

println!("x is {:?}", x);

println!("y is {:?}", y);

println!("z is {:?}", z);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Flow of Control

An essential part of any programming languages are ways to modify control flow: if/else, for, and others. Let's talk about them in Rust.

if/else

Branching with if-else is similar to other languages. Unlike many of them, the boolean condition doesn't need to be surrounded by parentheses, and each condition is followed by a block. if-else conditionals are expressions, and, all branches must return the same type.

fn main() {

let n = 5;

if n < 0 {

print!("{} is negative", n);

} else if n > 0 {

print!("{} is positive", n);

} else {

print!("{} is zero", n);

}

let big_n =

if n < 10 && n > -10 {

println!(", and is a small number, increase ten-fold");

// This expression returns an `i32`.

10 * n

} else {

println!(", and is a big number, halve the number");

// This expression must return an `i32` as well.

n / 2

// TODO ^ Try suppressing this expression with a semicolon.

};

// ^ Don't forget to put a semicolon here! All `let` bindings need it.

println!("{} -> {}", n, big_n);

}