Function call flow in Rust - Step-by-Step Execution

Concept Flow - Function call flow

Start main

↓

Call function foo

↓

Execute foo body

↓

Return from foo

↓

Continue main

↓

End main

This flow shows how the main function calls another function, waits for it to finish, then continues.

Execution Sample

Rust

fn foo() {
    println!("Inside foo");
}

fn main() {
    println!("Start main");
    foo();
    println!("End main");
}

This Rust program prints messages showing the order of function calls and returns.

Execution Table

Step	Function	Action	Output
1	main	Start main function	Start main
2	main	Call foo()
3	foo	Enter foo function	Inside foo
4	foo	Return from foo
5	main	Continue after foo()	End main
6	main	End main function

💡 main function finishes execution

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
call_stack	main	main -> foo	main	empty

Key Moments - 2 Insights

Why does the program print "Inside foo" after "Start main" but before "End main"?

Because main calls foo at step 2, execution moves into foo (step 3), prints "Inside foo", then returns to main (step 4) before continuing to print "End main" (step 5).

What happens to the call stack when foo() is called?

At step 2, foo is added on top of main in the call stack (main -> foo). After foo returns at step 4, it is removed, leaving only main.

Visual Quiz - 3 Questions

Look at the execution table, what is printed at step 3?

A "Start main"

B "Inside foo"

C "End main"

D Nothing

💡 Hint

Check the Output column at step 3 in the execution_table.

At which step does the program return from the foo function?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the Action column describing return events in the execution_table.

If the call to foo() was removed from main, what would the output at step 2 be?

A "Inside foo"

B "Start main"

C No output

D "End main"

💡 Hint

Without calling foo(), step 2 would not print anything related to foo in the execution_table.

Concept Snapshot

Function call flow in Rust:
- main() starts execution
- main calls another function (e.g., foo())
- Execution jumps to called function
- Called function runs and returns
- Execution resumes in main after call
- Call stack tracks active functions

Full Transcript

This example shows how a Rust program runs when main calls another function foo. First, main prints "Start main". Then main calls foo, so execution moves into foo. Foo prints "Inside foo" and then returns to main. After foo returns, main continues and prints "End main". The call stack grows when foo is called and shrinks when foo returns. This flow ensures functions run in order and return control properly.

Practice

1. What happens when a function is called in Rust?

easy

A. The program runs the function's code and then returns to the call point.

B. The program skips the function's code and continues after the call.

C. The function code runs only if called twice.

D. The program stops running after the function call.

Solution

1. Step 1: Understand function call behavior

   When a function is called, the program jumps to the function's code and executes it.

2. Step 2: Return to the call point

   After the function finishes, the program returns to the line after the call and continues running.

3. Final Answer:

   The program runs the function's code and then returns to the call point. -> Option A

4. Quick Check:

   Function call flow = run code then return [OK]

Hint: Function calls run code then return to caller [OK]

Common Mistakes:

• Thinking function code is skipped
• Believing program stops after call
• Assuming function runs only if called twice

2. Which of these is the correct way to call a function named greet in Rust?

easy

A. call greet;

B. greet();

C. greet[];

D. function greet();

Solution

1. Step 1: Recall Rust function call syntax

   Functions are called by writing their name followed by parentheses, even if no arguments are passed.

2. Step 2: Match the correct syntax

   Only greet(); matches this pattern correctly.

3. Final Answer:

   greet(); -> Option B

4. Quick Check:

   Function call syntax = name + () [OK]

Hint: Use functionName() to call functions in Rust [OK]

Common Mistakes:

• Omitting parentheses when calling functions
• Using brackets [] instead of parentheses
• Using keywords like 'call' or 'function' incorrectly

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

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

fn main() {
    let result = add_one(5);
    println!("{}", result);
}

medium

A. 5

B. Error: missing semicolon

C. 6

D. 0

Solution

1. Step 1: Understand the function behavior

   The function add_one takes an integer and returns that integer plus one.

2. Step 2: Trace the function call and output

   Calling add_one(5) returns 6, which is printed by println!.

3. Final Answer:

   6 -> Option C

4. Quick Check:

   5 + 1 = 6 [OK]

Hint: Follow function return values to find output [OK]

Common Mistakes:

• Confusing input and output values
• Thinking semicolon causes error here
• Assuming function prints instead of returns

4. Identify the error in this Rust code snippet:

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

fn main() {
    let result = multiply(4);
    println!("{}", result);
}

medium

A. Function multiply is missing a return statement.

B. Variable result is not declared.

C. println! macro is used incorrectly.

D. multiply is called with wrong number of arguments.

Solution

1. Step 1: Check function definition parameters

   The function multiply requires two arguments: x and y.

2. Step 2: Check function call arguments

   The call multiply(4) provides only one argument, causing an error.

3. Final Answer:

   multiply is called with wrong number of arguments. -> Option D

4. Quick Check:

   Function call args must match definition [OK]

Hint: Match function call arguments to definition [OK]

Common Mistakes:

• Ignoring argument count mismatch
• Thinking missing return causes error here
• Assuming println! usage is wrong

5. Given these functions:

fn first() {
    println!("Start");
    second();
    println!("End");
}

fn second() {
    println!("Middle");
}

fn main() {
    first();
}

What is the order of printed lines when main runs?

hard

A. Start\nMiddle\nEnd

B. Middle\nStart\nEnd

C. Start\nEnd\nMiddle

D. End\nMiddle\nStart

Solution

1. Step 1: Trace the call flow from main

   Main calls first(), which prints "Start" then calls second().

2. Step 2: Follow nested function calls

   second() prints "Middle" and returns. Then first() prints "End".

3. Final Answer:

   Start\nMiddle\nEnd -> Option A

4. Quick Check:

   Call flow order = Start, Middle, End [OK]

Hint: Follow calls step-by-step to find print order [OK]

Common Mistakes:

• Ignoring nested function call order
• Assuming prints happen after all calls
• Mixing up print sequence