Function declaration in Rust - Mini Project: Build & Apply

Function declaration

📖 Scenario: You are creating a simple calculator program that adds two numbers.

🎯 Goal: Build a Rust program that declares a function to add two numbers and prints the result.

📋 What You'll Learn

Declare a function named add that takes two i32 parameters and returns their sum as i32.

Call the add function with two numbers.

Print the result of the addition.

💡 Why This Matters

🌍 Real World

Functions help organize code into reusable blocks, making programs easier to read and maintain.

💼 Career

Knowing how to declare and use functions is essential for any software developer to write clean and efficient code.

1

Create two variables with numbers

Create two variables called num1 and num2 with values 5 and 7 respectively.

Rust

# Your code here

Hint

Use let to create variables and assign the numbers 5 and 7.

2

Declare the add function

Declare a function named add that takes two i32 parameters named a and b, and returns their sum as i32.

Rust

fn main() {
    let num1 = 5;
    let num2 = 7;
}

// Your code here

Hint

Use fn to declare the function and specify parameter types and return type.

3

Call the add function and store the result

Inside the main function, call the add function with num1 and num2 as arguments, and store the result in a variable called sum.

Rust

fn main() {
    let num1 = 5;
    let num2 = 7;
    // Your code here
}

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

Hint

Call the function by its name and pass the two variables as arguments.

4

Print the sum

Add a println! statement inside the main function to print the value of sum.

Rust

fn main() {
    let num1 = 5;
    let num2 = 7;
    let sum = add(num1, num2);
    // Your code here
}

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

Hint

Use println!("{}", sum); to print the sum.

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