Module visibility in Rust - Time & Space Complexity

Time Complexity: Module visibility

O(n)

Understanding Time Complexity

When working with module visibility in Rust, it's important to understand how access to code parts affects program behavior.

We want to see how the visibility rules impact the number of operations or checks done as the code grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

mod outer {
    pub mod inner {
        pub fn greet() {
            println!("Hello from inner module!");
        }
    }
}

fn main() {
    outer::inner::greet();
}
    

This code defines nested modules with public visibility and calls a function from the inner module.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: There are no loops or recursion here; the main operation is a single function call through module paths.
• How many times: The function is called once in this example.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (n)	Approx. Operations
10	10 function calls
100	100 function calls
1000	1000 function calls

Pattern observation: The number of operations grows linearly with the number of function calls, regardless of module visibility.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows directly with how many times you call functions through modules.

Common Mistake

[X] Wrong: "Making modules public slows down the program a lot because of extra checks."

[OK] Correct: Visibility controls are checked at compile time, so they don't add extra work when the program runs.

Interview Connect

Understanding how module visibility affects program structure helps you write clear and maintainable code, a skill valued in many coding tasks.

Self-Check

"What if we changed the inner module's visibility from public to private? How would the time complexity change when calling its functions?"