Rust Book Day 2

Question 1

what are constants as opposed to immutable variables (7 facts)

Answer 1

• are valid for the entire time a program runs (within the scope declared)
• mut not allowed
• use const keyword instead of let
• type of the value must be annotated
• can also be declared in global scope
• may be set only to a constant expression, not the result of a value that could only be computed at runtime
• capital letters and underscores

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

Question 2

What is shadowing

Answer 2

declare a new variabled with the same name as a previous variable

fn main() {
let x = 5;

let x = x + 1;

{
    let x = x * 2;
    println!("The value of x in the inner scope is: {x}");
}

println!("The value of x is: {x}"); }

The value of x in the inner scope is: 12
The value of x is: 6 !!!!!

Question 3

Can we shadow a variable with different type ?

Answer 3

let spaces = “ “;
let spaces = spaces.len();

This is fine even with a different type

let mut spaces = “ “;
spaces = spaces.len();

This is not fine (not shadowing actually)

Question 4

what is scalar vs compound

Answer 4

scalar type represents a single value
- integers
- floating point numbers
- booleans
- characters

Question 5

what are signed integers vs unsigned

Answer 5

unsigned can’t be negative

if you use u8 you can go from 0 to 255 where as i8 goes from -128 to 127

Question 6

how to make 10000 easier to read

Answer 6

10_000

Question 7

will 255 + 1 wrap when using u8 ?

Answer 7

yes, in –release mode, but not in standard debug mode,

you can use Wrapping(255u8) to make it specific

or wrapping_add method

Question 8

what are floating point types and are they signed ?

Answer 8

signed, f32 and f64 (default, roughly same CPU speed)

Question 9

what is result of
let truncated = -5 / 3;

Answer 9

// Results in -1

Question 10

how is a boolean specified ?

Answer 10

bool

Question 11

how is a character annotated ?

Answer 11

char

fn main() {
let c = ‘z’;
let z: char = ‘ℤ’; // with explicit type annotation
let heart_eyed_cat = ‘😻’;
}

Question 12

how to define a tuple and name one fact about them

Answer 12

let my_tup: (i32, f64, u8) = (500, 6.4, 1)

once declared they cannot grow or shrink in size

Question 13

how to destructure a tuple, name also an alternative “destructuring”

Answer 13

let tup = (500, 6.4, 1);

let (x, y, z) = tup;

println!("The value of y is: {y}");

alternatively:

let five_hundred = x.0;

Question 14

what’s special about arrays in rust?

Answer 14

have fixed length, define it like this:
let a: [i32; 5] = [1, 2, 3, 4, 5];

let a = [3; 5];
// same as
let a = [3, 3, 3, 3, 3];

access it with a[0]

Question 15

what are statements and expressions

Answer 15

statements are instructions which do not return a value, like let y = 6;

expressions evaluate to a resultant value

Question 16

A new scope block created with curly brackets is an expression, for example:

Answer 16

let y = {
let x = 3;
x + 1
};

println!("The value of y is: {y}");

// returns 4

// note that there is no semicolon at the end

Question 17

how to specify return type of a function ?

Answer 17

->

like this:

fn plus_one(x: i32) -> i32 {
x + 1
}

Question 18

how to make comments?

Answer 18

//

Question 19

how to write if, elseif else if ?

Answer 19

• no brackets needed for the condition
• curly brackets needed for the code to execute

let number = 6;

if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else if number % 2 == 0 {
    println!("number is divisible by 2");
} else {
    println!("number is not divisible by 4, 3, or 2");
}

Question 20

loop labels

Answer 20

// to break them
‘counting_up: loop {

break ‘counting_up;

Question 21

while

Answer 21

while number != 0 {
println!(“{number}!”);

    number -= 1;
}

Question 22

increase integer shorthand

Answer 22

index += 1;

Question 23

for loop

Answer 23

for element in a {
println!(“value is {element}”);
}

Question 24

countdown

Answer 24

for number in (1..4).rev() {
println!(“{number}!”);
}
println!(“LIFTOFF!!!”);