Rust Modules Quiz

0 Passed

0% acceptance

40 comprehensive questions on Rust's module system, covering module creation, visibility, imports, paths, and the use keyword — with 11 code examples demonstrating practical module organization patterns.

40 Questions

~80 minutes

Question 1

What is a module in Rust?

A namespace that contains definitions (functions, structs, traits, etc.) and can control their visibility

A file that contains Rust code

A package or crate

A type of function

Question 2

How do you define a module in Rust?

Using the mod keyword: mod module_name { ... }

Using the module keyword: module module_name { ... }

Using the namespace keyword: namespace module_name { ... }

Modules are defined automatically

Question 3

What is the default visibility of items in a module?

Private (only accessible within the module)

Public (accessible from anywhere)

Depends on the item type

Inherited from parent module

Question 4

How do you make an item public in a module?

Using the pub keyword: pub fn function_name() { ... }

Using the public keyword

Using the export keyword

Items are public by default

Question 5

What will this module code do?

rust

mod my_module {
    pub fn public_function() {
        println!("This is public");
    }
    
    fn private_function() {
        println!("This is private");
    }
}

fn main() {
    my_module::public_function();
    my_module::private_function();
}

Prints 'This is public' and fails to compile

Prints both messages successfully

Fails to compile because modules can't have functions

Prints 'This is private' and fails to compile

Question 6

How do you access items from a module?

Using path syntax: module_name::item_name

Using dot notation: module_name.item_name

Using bracket notation: module_name[item_name]

Items are automatically available

Question 7

What is the use keyword used for?

Bringing items into scope to avoid repetitive path typing

Defining new modules

Making items public

Importing external crates

Question 8

How do you use the use keyword to import items?

use module_name::item_name;

import module_name::item_name;

using module_name::item_name;

include module_name::item_name;

Question 9

What will this use statement do?

rust

mod network {
    pub mod client {
        pub fn connect() {}
    }
}

use network::client;

fn main() {
    client::connect();
}

Allows calling client::connect() instead of network::client::connect()

Compilation error

Imports the connect function directly

Creates a new module

Question 10

How do you import multiple items with a single use statement?

use module_name::{item1, item2, item3};

use module_name::item1, module_name::item2;

use module_name::all;

Multiple items cannot be imported at once

Question 11

What is an absolute path in Rust modules?

A path that starts from the crate root using crate::

A path that starts from the current module

A path that uses relative navigation

A path that includes the full filesystem path

Question 12

What is a relative path in Rust modules?

A path that starts from the current module and uses self or super

A path that starts from the crate root

A path that uses absolute filesystem paths

A path that includes the full module hierarchy

Question 13

What does super:: refer to in a module path?

The parent module

The current module

The crate root

A sibling module

Question 14

What does self:: refer to in a module path?

The current module

The parent module

The crate root

A child module

Question 15

How do you organize modules across multiple files?

Create module_name.rs files or module_name/ directories with mod.rs

All modules must be in a single file

Use separate directories for each module

Modules cannot span multiple files

Question 16

What is the purpose of mod.rs in a module directory?

It defines the module's public interface and re-exports items

It contains all the module's code

It imports external dependencies

It defines the module's tests

Question 17

How do you declare a submodule in mod.rs?

pub mod submodule_name;

mod submodule_name;

use submodule_name;

include submodule_name;

Question 18

What is re-exporting in modules?

Making items from submodules available at higher levels using pub use

Moving modules to different files

Renaming modules

Converting private items to public

Question 19

What will this re-export code do?

rust

mod network {
    pub mod client {
        pub fn connect() {}
    }
}

pub use network::client::connect;

fn main() {
    connect(); // Can now call directly
}

Allows calling connect() directly without module path

Compilation error

Creates a new function

Moves the function to a different module

Question 20

What is the crate root in Rust?

The main.rs file or lib.rs file that defines the crate

The src/ directory

The Cargo.toml file

The target/ directory

Question 21

In a scenario where you're building a large application with networking, database, and UI components, how should you organize the modules?

Create top-level modules like network, db, ui, each with submodules

Put all code in a single large file

Create separate crates for each component

Use functions instead of modules

Question 22

What is the difference between pub and pub(crate)?

pub is public to external crates, pub(crate) is public within the current crate

pub(crate) is public to external crates, pub is public within the crate

They are identical

pub(crate) doesn't exist

Question 23

How do you make a struct's fields public?

pub struct StructName { pub field1: Type1, pub field2: Type2 }

pub struct StructName { field1: Type1, field2: Type2 }

struct StructName { pub field1: Type1, field2: Type2 }

Fields cannot be made public individually

Question 24

What happens if you try to access a private field of a public struct?

Compilation error: field is private

The field is accessible

Runtime error

The struct becomes private

Question 25

How do you organize tests in modules?

Using #[cfg(test)] modules and #[test] functions

Tests must be in separate files

Tests cannot be in modules

Using test modules without attributes

Question 26

What is the purpose of the #[cfg(test)] attribute?

Conditionally compiles code only when running tests

Marks functions as tests

Runs tests in parallel

Generates test documentation

Question 27

How do you access the crate root from anywhere in the crate?

Using crate:: at the start of paths

Using root::

Using :: at the start

This is not possible

Question 28

What is the difference between use and mod declarations?

mod declares modules, use brings items into scope

use declares modules, mod brings items into scope

They are interchangeable

use is for external crates, mod is for local modules

Question 29

How do you handle name conflicts when importing items?

Use as keyword: use module::Item as NewName;

Use different module names

Name conflicts are not possible

Use the rename keyword

Question 30

What will this code with name aliasing do?

rust

mod math {
    pub fn add(x: i32, y: i32) -> i32 { x + y }
}

use math::add as sum;

fn main() {
    println!("Result: {}", sum(3, 4));
}

Prints 'Result: 7' using the aliased name

Compilation error

Prints 'Result: 0'

Creates a new function

Question 31

How do you import all public items from a module?

use module_name::*;

use module_name::all;

use module_name;

This is not recommended

Question 32

When should you avoid using glob imports (use module::*)?

When it could cause name conflicts or reduce clarity

When importing from the standard library

When the module has many items

Glob imports should always be avoided

Question 33

How do you structure a large project with many modules?

Use a hierarchical structure with clear separation of concerns

Put everything in the root module

Use one file per function

Avoid modules entirely

Question 34

What is the main.rs file in a binary crate?

The crate root that contains the main function

A module file

The Cargo.toml equivalent

The test file

Question 35

What is the lib.rs file in a library crate?

The crate root that defines the library's public API

A module file

Contains the main function

The test file

Question 36

How do you make a module accessible from tests?

Use pub(crate) for items that tests need to access

Make everything pub

Tests can access private items

Use special test attributes

Question 37

What is the purpose of module documentation comments?

To document the module's purpose and usage with /// comments

To define the module's visibility

To import external documentation

To generate module diagrams

Question 38

How do you handle cyclic dependencies between modules?

Restructure to avoid cycles, or use traits/interfaces

Use special syntax to allow cycles

Cyclic dependencies are allowed

Move code to a common parent module

Question 39

What is the benefit of using modules for code organization?

Encapsulation, reusability, and maintainability

Faster compilation

Smaller binary size

Better performance

Question 40

In a complex web application with authentication, routing, database access, and API endpoints, how would you structure the module hierarchy?

Create modules like auth, routing, db, api with appropriate submodules for related functionality

Put all code in a single module

Create one module per file

Use random module organization

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Rust

Cargo and Project Setup

40 comprehensive questions on Rust's package manager Cargo, covering project initialization, building, running, project structure, and dependency management — with 15 code examples demonstrating practical Cargo usage.

Variables and Mutability

40 comprehensive questions on Rust's variable system, covering let bindings, mut keyword, shadowing, type inference, and constants — with 12 code examples demonstrating practical variable usage patterns.

Data Types

45 comprehensive questions on Rust's type system, covering scalar types, compound types, type conversions, numeric operations, and string types — with 15 code examples demonstrating practical type usage patterns.

Control Flow

45 comprehensive questions on Rust's control flow constructs, covering if expressions, loops, and control flow keywords — with 15 code examples demonstrating practical control flow usage.

Functions

40 questions covering function parameters, return values, expressions, diverging functions, and function scope in Rust.

Ownership

45 in-depth questions covering Rust's ownership system, move semantics, copy types, resource cleanup through Drop trait, precise drop timing, and ownership transfer patterns — with 12 code examples to solidify understanding.

Borrowing

45 in-depth questions covering Rust's borrowing system, immutable and mutable references, aliasing rules, reference scopes, and borrow checker validation — with 13 code examples to solidify understanding.

Lifetimes

40 in-depth questions covering Rust's lifetime system, lifetime annotations, elision rules, function signatures with lifetimes, struct references, and common lifetime errors — with 11 code examples to solidify understanding.

Strings

40 comprehensive questions on Rust's string types, covering String vs &str, UTF-8 behavior, slicing, mutating strings, and conversions — with 11 code examples demonstrating practical string handling patterns.

Collections

40 comprehensive questions on Rust's collection types, covering Vec, HashMap, VecDeque, iteration patterns, and capacity management — with 11 code examples demonstrating practical collection usage.

Slices

40 comprehensive questions on Rust's slice types, covering borrowed views, indexing, mutable slices, ranges, and slice methods — with 11 code examples demonstrating practical slice usage patterns.

Pattern Matching

40 comprehensive questions on Rust's pattern matching system, covering match expressions, destructuring, guards, wildcards, and enum matching — with 11 code examples demonstrating practical pattern matching techniques.

Enums

40 comprehensive questions on Rust's enum system, covering simple variants, data-carrying variants, enum matching, methods on enums, and Option/Result patterns — with 11 code examples demonstrating practical enum usage.

Struct

40 comprehensive questions on Rust's struct system, covering named fields, tuple structs, methods, associated functions, and field ownership — with 11 code examples demonstrating practical struct usage.

Modules

Traits

40 comprehensive questions on Rust's trait system, covering trait definitions, implementations, bounds, associated types, and trait objects — with 11 code examples demonstrating practical trait usage patterns.

Generic

40 comprehensive questions on Rust's generic programming system, covering generic functions, structs, enums, impl blocks, and monomorphization — with 11 code examples demonstrating practical generic usage patterns.

Iterators

Master Rust's powerful iterator system for efficient data processing and transformation

Closures

Master Rust's closure system for capturing environment variables and creating flexible function-like constructs

Error Handling

Master Rust's robust error handling system with Result, Option, and the ? operator for reliable code

File and I/O Operations

Master Rust's file system operations and I/O handling for robust data persistence and streaming

Smart Pointers

Master Rust's smart pointer types for automatic memory management and safe heap allocation

Concurrency

Master Rust's concurrency model with threads, channels, and synchronization primitives for safe parallel programming

Async Programming

Master asynchronous programming in Rust with futures, async/await, and concurrent execution patterns

Memory Management

Deep dive into Rust's ownership system, borrowing rules, and advanced memory management patterns for safe and efficient code

Macros

Master Rust's metaprogramming system with declarative and procedural macros for code generation and compile-time programming

Attributes

Master Rust's attribute system for conditional compilation, testing, documentation, and code generation

Testing

Master comprehensive testing strategies in Rust including unit tests, integration tests, documentation tests, and testing best practices

Crate Architecture

Master the design and organization of Rust crates including module systems, workspace management, dependency handling, and publishing strategies

Performance and Optimization

Master advanced performance techniques in Rust including profiling, benchmarking, memory optimization, and compiler optimizations

Rust Modules Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

Question 36

Question 37

Question 38

Question 39

Question 40

About This Modules Quiz

What You Will Practise

Other Quiz Categories

QUIZZES IN Rust

Cargo and Project Setup

Variables and Mutability

Data Types

Control Flow

Functions

Ownership

Borrowing

Lifetimes

Strings

Collections

Slices

Pattern Matching

Enums

Struct

Modules

Traits

Generic

Iterators

Closures

Error Handling

File and I/O Operations

Smart Pointers

Concurrency

Async Programming

Memory Management

Macros

Attributes

Testing

Crate Architecture

Performance and Optimization