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.