Function declaration in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the basic syntax to declare a function in Rust?

In Rust, a function is declared using the fn keyword, followed by the function name, parentheses for parameters, and curly braces for the body.

Example:
fn greet() {
println!("Hello!");
}

beginner

How do you declare a function that takes parameters in Rust?

You list parameters inside the parentheses with their names and types.

Example:
fn add(a: i32, b: i32) -> i32 {
a + b
}
This function takes two 32-bit integers and returns their sum.

beginner

What does the arrow -> mean in a Rust function declaration?

The arrow -> indicates the return type of the function.

Example:
fn square(x: i32) -> i32 {
x * x
}
This means the function returns an i32 value.

beginner

How do you return a value from a Rust function?

In Rust, the last expression in the function is returned automatically if it has no semicolon.

Example:
fn double(x: i32) -> i32 {
x * 2 // returned because no semicolon
}
You can also use the return keyword explicitly.

beginner

Can Rust functions have no return value? How is it declared?

Yes, functions that do not return a value have the return type (), called the unit type.

Example:
fn say_hello() {
println!("Hello!");
}
This function returns nothing (unit).

What keyword starts a function declaration in Rust?

A def

B fn

C function

D func

Rust uses fn to declare functions.

How do you specify the return type of a function in Rust?

A After the function name with a colon

B Inside the function body

C Before the function name

D After the parameter list with an arrow <code>-></code>

The return type is specified after the parameters with ->.

What happens if the last expression in a Rust function has no semicolon?

A It is returned as the function's value

B It causes a syntax error

C It is ignored

D It prints to the console

The last expression without a semicolon is returned automatically.

How do you declare a function that takes two integers and returns their sum?

A fn sum(a: i32, b: i32) -> i32 { a + b }

B fn sum(a, b) { return a + b; }

C function sum(a: int, b: int) -> int { a + b }

D fn sum(a: int, b: int) { a + b }

Rust requires parameter types and return type with ->.

What is the return type of a function that does not return any value?

A void

B null

C () (unit type)

D None

Rust uses the unit type () for functions with no return value.

Explain how to declare a function in Rust that takes parameters and returns a value.

Think about the function signature and how Rust specifies types.

Describe how Rust handles returning values from functions without using the return keyword.

Remember how Rust treats the last line inside the function.

Practice

1. What keyword is used to declare a function in Rust?

easy

A. fn

B. function

C. def

D. func

Solution

1. Step 1: Recall Rust function syntax

   In Rust, functions are declared using the keyword fn.

2. Step 2: Compare options with Rust syntax

   Only fn matches the correct Rust keyword for function declaration.

3. Final Answer:

   fn -> Option A

4. Quick Check:

   Function declaration keyword = fn [OK]

Hint: Remember Rust uses 'fn' to start functions [OK]

Common Mistakes:

• Using 'function' instead of 'fn'
• Confusing with Python's 'def'
• Using 'func' which is not Rust syntax

2. Which of the following is the correct syntax to declare a function named greet that takes no parameters and returns nothing in Rust?

easy

A. def greet() {}

B. fn greet() {}

C. fn greet {}

D. function greet() {}

Solution

1. Step 1: Check function declaration syntax

   In Rust, a function with no parameters and no return value is declared as fn name() {}.

2. Step 2: Validate each option

   fn greet() {} matches Rust syntax exactly. Options A and B use keywords from other languages. fn greet {} misses parentheses.

3. Final Answer:

   fn greet() {} -> Option B

4. Quick Check:

   Empty parameter list requires () in Rust [OK]

Hint: Functions always need () even if no parameters [OK]

Common Mistakes:

• Omitting parentheses
• Using other language keywords
• Adding unnecessary keywords

3. What will be the output of this Rust code?

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    println!("{}", add(3, 4));
}

medium

A. 7

B. 34

C. a + b

D. Error: missing return

Solution

1. Step 1: Understand the add function

   The function takes two integers and returns their sum using expression a + b.

2. Step 2: Trace the main function call

   Calling add(3, 4) returns 7, which is printed by println!.

3. Final Answer:

   7 -> Option A

4. Quick Check:

   3 + 4 = 7 [OK]

Hint: Sum of 3 and 4 is 7, printed as output [OK]

Common Mistakes:

• Thinking 'a + b' prints as string
• Concatenating numbers as strings
• Assuming missing return error

4. Identify the error in this Rust function declaration:

fn multiply(x i32, y: i32) -> i32 {
    x * y
}

medium

A. Function name is invalid

B. Missing return type

C. Missing colon after parameter x

D. Missing semicolon after multiplication

Solution

1. Step 1: Check parameter syntax

   Each parameter must have a colon between name and type. Here, x i32 misses the colon.

2. Step 2: Verify other parts

   Return type is present, function name is valid, and semicolon is not needed after expression in Rust.

3. Final Answer:

   Missing colon after parameter x -> Option C

4. Quick Check:

   Parameters need ':' between name and type [OK]

Hint: Parameters need ':' between name and type [OK]

Common Mistakes:

• Omitting colon in parameters
• Adding unnecessary semicolons
• Confusing return type syntax

5. How would you declare a Rust function named is_even that takes an integer parameter and returns a boolean indicating if the number is even?

hard

A. fn is_even(n: i32) -> boolean { n % 2 == 0 }

B. fn is_even(n: i32) { return n % 2 == 0; }

C. fn is_even(n: int) -> bool { n % 2 = 0 }

D. fn is_even(n: i32) -> bool { n % 2 == 0 }

Solution

1. Step 1: Check parameter and return types

   Parameter type must be i32 and return type bool in Rust.

2. Step 2: Validate function body syntax

   Expression n % 2 == 0 correctly returns a boolean. fn is_even(n: i32) -> bool { n % 2 == 0 } uses correct syntax and types.

3. Final Answer:

   fn is_even(n: i32) -> bool { n % 2 == 0 } -> Option D

4. Quick Check:

   Use i32 and bool with correct expression [OK]

Hint: Use '-> bool' and 'n % 2 == 0' for even check [OK]

Common Mistakes:

• Using wrong type names like int or boolean
• Omitting return type
• Using '=' instead of '==' in condition