Question 1

What are the roles of rustup, rustc and the cargo commands?

Accepted Answer

Cargo: a packaging and build tool
Rustup: toolchain management tool
Rustc: just the compiler

Question 2

How does rust ensure memory safety?

Accepted Answer

Ownership

Question 3

Where are rust variables stored as the program executes?

Accepted Answer

Stack

Question 4

Does the code compile?
let x = 1;
let mut y = 1;
let x = “helllo”
y= 3.14;

Accepted Answer

No because setting floating point value after initially setting it to an int

Question 5

What are the types of x and y?
let x = 1.0;
let y = 3;

Accepted Answer

x is f64 
y = i32

Question 6

What is the problem with this function?
fn add_numbers(a, b) -> i32 { 
a + b 
}

Accepted Answer

No types for x and y in the parentheses of function (need :i32)

Question 7

Does the code compile?
let x = 1;
let y = 2;
let z = if x > y {x} else {y};

Accepted Answer

The code compiles

Question 8

Does the following code compile?

let x = 1;
let y = x;
println!(“{},{}”, x, y);

Accepted Answer

The code compiles because i32 has a copy trait

Question 9

Does the following code compile?
let x = “hello”.to_string();
let y = x;
println!(“{},{}”, x, y);

Accepted Answer

No. Absence of copy type so ownership results in no  access to x anymore

Question 10

What part of memory will hold the integer value (42) after executing this code?

let x = Box::new(42);

Accepted Answer

Heap

Question 11

What is the output of the following program?
(...)

fn main(){
let values = vec![1,2,3,4];
let result = sum(value);
println!(“the sum of {:?} is {}”, values, result);
}

Accepted Answer

Problem: values stops existing after let result line

Question 12

What is the output of the following program?

fn main() {
 let values = vec![“one”.to_string(), “two”.to_string()];
let x = values[values.len()-2];
println!(“{}, x)
}

Accepted Answer

Doesn’t compile
Dynamic data structures, tracks length at runtime so ownership can’t move data out of vector
Can’t index vectors cause you don’t know the length for sure
Cannot move out of index of ‘Vec<String>’

Question 13

What are ownership rules?

Accepted Answer

Each value in rust has an owner
There can only be one owner at a time
When the owner goes out of scope, the value will be dropped

Question 14

What are the Borrow Rules?

Accepted Answer

At given given time, you can have either one mutable reference of any number of immutable references
References must always be valid

Question 15

What is the data type of s in the following example?

fn main ()
{
let s = &“hello”.to_string()[1..2];
println!(“{s}”);
}

Accepted Answer

String slice: &str

Question 16

Is this a valid struct definition?
#derive(Debug, Clone, Copy)]
struct person{
name: string;
x = i32;
}

Accepted Answer

No, you can't copy a string type so Copy trait can't be implemented

Question 17

Where do you need to provide an irrefutable pattern for matching?

Accepted Answer

Variable assignment
Parameters of function
For loops

Question 18

What is the data type of x
let x = Some(12);

Accepted Answer

Option<i32>

Question 19

What does Option::<T>::upwrap() do?

Accepted Answer

Panics

Question 20

Change the line to make it work? fn sum(row: &str) -> Result, ParseIntError>{ let mut acc = 0; acc += token.parse::();

Accepted Answer

acc += token.parse::<i32>()?;

Question 21

What is the potential danger of creating a &str slice reference, like let s = &unknown_string[4..9]

Accepted Answer

If they’re unicode encoded so it may end up in the middle of character because there is variable length encoding
Program would panic

Question 22

String vs &str?

Accepted Answer

String owns the data, str always borrows the data

Question 23

What is the data type of r?
let mut v = vec![1,2,3,4];
let r = &mut x[1..3];

Accepted Answer

r:&mut[i32]

Question 24

What is the type and value of x?

Let mut m = HashMap::new();
m.insert(“for”,”bar”);
Let x = m.entry(“bar”).or_insert(“baz”);

Accepted Answer

x:&mut &str ->“baz”

Question 25

What’s the problem with the following generic function? fn smaller(a:T, b:T)->T{ if a <= b {a} else {b} }

Accepted Answer

The T data type needs to have the partial order trait, so that you can compare. fn smaller(a: T, b: T) -> T { if a <= b { a } else { b } }

Question 26

What is wrong with the following generic type implementation block? Struct Vector{ … } Impl Vector{ … } Trait Introspect { fn kind(&self)-> &str; }

Accepted Answer

Can’t implement kind

Question 27

The following code doesn’t compile

fn smaller<T>(x:&T, y: &T)->(...)

Accepted Answer

TICKS need to be added
No lifetime specification

Question	Answer
What are the roles of rustup, rustc and the cargo commands?	Cargo: a packaging and build tool Rustup: toolchain management tool Rustc: just the compiler
How does rust ensure memory safety?	Ownership
Where are rust variables stored as the program executes?	Stack
Does the code compile? let x = 1; let mut y = 1; let x = “helllo” y= 3.14;	No because setting floating point value after initially setting it to an int
What are the types of x and y? let x = 1.0; let y = 3;	x is f64 y = i32
What is the problem with this function? fn add_numbers(a, b) -> i32 { a + b }	No types for x and y in the parentheses of function (need :i32)
Does the code compile? let x = 1; let y = 2; let z = if x > y {x} else {y};	The code compiles
Does the following code compile? let x = 1; let y = x; println!(“{},{}”, x, y);	The code compiles because i32 has a copy trait
Does the following code compile? let x = “hello”.to_string(); let y = x; println!(“{},{}”, x, y);	No. Absence of copy type so ownership results in no access to x anymore
What part of memory will hold the integer value (42) after executing this code? let x = Box::new(42);	Heap
What is the output of the following program? (...) fn main(){ let values = vec![1,2,3,4]; let result = sum(value); println!(“the sum of {:?} is {}”, values, result); }	Problem: values stops existing after let result line
What is the output of the following program? fn main() { let values = vec![“one”.to_string(), “two”.to_string()]; let x = values[values.len()-2]; println!(“{}, x) }	Doesn’t compile Dynamic data structures, tracks length at runtime so ownership can’t move data out of vector Can’t index vectors cause you don’t know the length for sure Cannot move out of index of ‘Vec<String>’
What are ownership rules?	Each value in rust has an owner There can only be one owner at a time When the owner goes out of scope, the value will be dropped
What are the Borrow Rules?	At given given time, you can have either one mutable reference of any number of immutable references References must always be valid
What is the data type of s in the following example? fn main () { let s = &“hello”.to_string()[1..2]; println!(“{s}”); }	String slice: &str
Is this a valid struct definition? #derive(Debug, Clone, Copy)] struct person{ name: string; x = i32; }	No, you can't copy a string type so Copy trait can't be implemented
Where do you need to provide an irrefutable pattern for matching?	Variable assignment Parameters of function For loops
What is the data type of x let x = Some(12);	Option<i32>
What does Option::<T>::upwrap() do?	Panics
Change the line to make it work? fn sum(row: &str) -> Result<i32>, ParseIntError>{ let mut acc = 0; acc += token.parse::<i32>();	acc += token.parse::<i32>()?;
What is the potential danger of creating a &str slice reference, like let s = &unknown_string[4..9]	If they’re unicode encoded so it may end up in the middle of character because there is variable length encoding Program would panic
String vs &str?	String owns the data, str always borrows the data
What is the data type of r? let mut v = vec![1,2,3,4]; let r = &mut x[1..3];	r:&mut[i32]
What is the type and value of x? Let mut m = HashMap::new(); m.insert(“for”,”bar”); Let x = m.entry(“bar”).or_insert(“baz”);	x:&mut &str ->“baz”
What’s the problem with the following generic function? fn smaller<T>(a:T, b:T)->T{ if a <= b {a} else {b} }	The T data type needs to have the partial order trait, so that you can compare. fn smaller<T: PartialOrd>(a: T, b: T) -> T { if a <= b { a } else { b } }
What is wrong with the following generic type implementation block? Struct Vector<T>{ … } Impl<T> Vector<T>{ … } Trait Introspect { fn kind(&self)-> &str; }	Can’t implement kind
The following code doesn’t compile fn smaller<T>(x:&T, y: &T)->(...)	TICKS need to be added No lifetime specification

"Know" box contains:
Time elapsed:
Retries:

RUST 1