Module visibility in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code with module visibility?

Consider the following Rust code. What will it print when run?

Rust

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

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

A No output

B error: function `greet` is private

C Hello from inner module!

D error: module `inner` is private

💡 Hint

Check which modules and functions are marked pub to be accessible outside.

The inner module and its function greet are both pub, so calling outer::inner::greet() works and prints the message.

❓ Predict Output

intermediate

What error does this Rust code produce due to module visibility?

What error will this Rust code produce when compiled?

Rust

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

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

A error: module `inner` is private

B Hello from inner module!

C error: function `greet` is private

D error: function `greet` not found in `outer`

💡 Hint

Remember that modules are private by default unless marked pub.

The inner module is private because it lacks pub. So outer::inner::greet() is inaccessible, causing a privacy error on the module.

🔧 Debug

advanced

Why does this Rust code fail to compile due to visibility?

Given this Rust code, why does it fail to compile?

Rust

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

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

A Module `inner` is private inside `outer` module

B Function `greet` is private inside `inner` module

C Function `greet` is not declared

D Module `outer` is private

💡 Hint

Check the visibility of the function greet inside the public module.

The module inner is public, but the function greet is private by default. So it cannot be accessed from main.

📝 Syntax

advanced

Which option correctly makes a nested module and function public in Rust?

Choose the option that correctly declares a public nested module inner and a public function greet inside it.

A pub mod outer { pub mod inner { fn greet() {} } }

B pub mod outer { mod inner { pub fn greet() {} } }

C mod outer { mod inner { fn greet() {} } }

D mod outer { pub mod inner { pub fn greet() {} } }

💡 Hint

Both the nested module and the function must be marked pub to be accessible outside.

Option D correctly marks inner as pub mod and greet as pub fn. Other options miss one or both pub keywords.

🚀 Application

expert

How many items are accessible from outside in this Rust module structure?

Given this Rust code, how many functions can be called from main without compilation errors?

Rust

mod outer {
    pub mod inner1 {
        pub fn func1() {}
        fn func2() {}
    }
    mod inner2 {
        pub fn func3() {}
        pub fn func4() {}
    }
    pub fn func5() {}
}

fn main() {
    outer::inner1::func1();
    // outer::inner1::func2(); // commented
    // outer::inner2::func3(); // commented
    // outer::inner2::func4(); // commented
    outer::func5();
}

A 2

B 3

C 4

D 5

💡 Hint

Count only functions that are pub and inside pub modules accessible from main.

inner1 is public, so func1 (pub) is accessible, but func2 is private. inner2 is private, so its functions are inaccessible. func5 is public in outer. So only func1 and func5 are accessible, total 2.

Practice

1. What does the pub keyword do in Rust module visibility?

easy

A. Makes a function or item accessible outside its module

B. Makes a function private to its module

C. Deletes the function from the module

D. Renames the function for external use

Solution

1. Step 1: Understand the role of pub

   The pub keyword in Rust is used to make functions, structs, or other items accessible from outside the module they are defined in.

2. Step 2: Contrast with default visibility

   By default, items are private and cannot be accessed outside their module unless marked with pub.

3. Final Answer:

   Makes a function or item accessible outside its module -> Option A

4. Quick Check:

   pub = public access [OK]

Hint: Remember: pub means public, so others can use it [OK]

Common Mistakes:

• Thinking pub hides the item
• Confusing pub with renaming
• Assuming pub deletes the item

2. Which of the following is the correct way to make a struct public in Rust?

easy

A. struct MyStruct { pub field: i32 }

B. struct pub MyStruct { field: i32 }

C. pub struct MyStruct { field: i32 }

D. struct MyStruct pub { field: i32 }

Solution

1. Step 1: Recall correct syntax for public structs

   In Rust, to make a struct public, the pub keyword must come before the struct keyword.

2. Step 2: Check placements of pub

   pub struct MyStruct { field: i32 } correctly places pub before struct. Placing pub inside the braces (on field), writing struct pub MyStruct, or struct MyStruct pub {} are incorrect.

3. Final Answer:

   pub struct MyStruct { field: i32 } -> Option C

4. Quick Check:

   pub struct is correct syntax [OK]

Hint: pub goes before struct, not inside or after [OK]

Common Mistakes:

• Placing pub inside struct braces
• Putting pub after struct name
• Writing pub in the wrong order

3. Given the code:

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

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

What will be the output when this code runs?

medium

A. No output

B. Error: greet is private

C. Error: inner module is private

D. Hello!

Solution

1. Step 1: Check visibility of modules and function

   The outer module is public, containing pub mod inner with pub fn greet(), making them all accessible from main.

2. Step 2: Confirm function call and output

   The call outer::inner::greet() is valid and will print "Hello!" to the console.

3. Final Answer:

   Hello! -> Option D

4. Quick Check:

   pub modules and functions allow access [OK]

Hint: pub on modules and functions means accessible outside [OK]

Common Mistakes:

• Overlooking that the outer module needs pub
• Thinking greet is private by default
• Ignoring nested module visibility

4. What is wrong with this Rust code?

mod my_mod {
    fn secret() {
        println!("Secret function");
    }
}

fn main() {
    my_mod::secret();
}

medium

A. secret function is private and cannot be called from main

B. Missing semicolon after println!

C. Module my_mod is not declared public

D. Function secret must have pub keyword inside main

Solution

1. Step 1: Check function visibility

   The function secret is not marked pub, so it is private to my_mod.

2. Step 2: Understand call from main

   Since main is outside my_mod, it cannot call a private function, causing a compile error.

3. Final Answer:

   secret function is private and cannot be called from main -> Option A

4. Quick Check:

   Private functions can't be accessed outside module [OK]

Hint: Private functions can't be called outside their module [OK]

Common Mistakes:

• Thinking module must be pub to call function
• Assuming missing semicolon causes error
• Believing pub inside main is needed

5. You have a private struct Config inside a module, but want to allow other modules to create instances with limited access to its fields. Which visibility setup is correct?

hard

A. Make struct private and fields public

B. Make struct pub but keep fields private

C. Make both struct and fields private

D. Keep struct private and make fields pub

Solution

1. Step 1: Understand struct and field visibility

   Making the struct pub allows other modules to create instances, but keeping fields private restricts direct access to internal data.

2. Step 2: Evaluate other approaches

   Keeping the struct private (with or without pub fields) prevents other modules from constructing instances. Making everything private blocks access entirely.

3. Final Answer:

   Make struct pub but keep fields private -> Option B

4. Quick Check:

   pub struct + private fields = controlled access [OK]

Hint: pub struct with private fields controls access well [OK]

Common Mistakes:

• Making fields pub but struct private (no instance creation)
• Making everything private (no access)
• Exposing fields unintentionally