Start Coding

Subjects

JAVASCRIPTHTMLCSSPYTHONSQLJAVACPPCSHARPPHPTYPESCRIPTCRUBYGOSWIFTKOTLINRUSTRBASHSCALAOBJECTIVE-CDARTPERLLUAMATLABXMLJSONMARKDOWNASSEMBLYLATEXYAMLSOLIDITYBLOCKCHAIN

Topics

Rust Basics

Introduction to RustInstalling RustRust SyntaxRust VariablesRust Data TypesRust ConstantsRust FunctionsRust CommentsRust OperatorsRust Control Flow

Ownership and Borrowing

Rust Ownership ConceptRust ReferencesRust Borrowing RulesRust LifetimesRust Move SemanticsRust Copy Types

Rust Structs and Enums

Rust StructsRust MethodsRust Associated FunctionsRust EnumsRust Pattern MatchingRust Option EnumRust Result Enum

Rust Collections

Rust VectorsRust StringsRust Hash MapsRust ArraysRust SlicesRust Iterators

Rust Error Handling

Rust Panic!Rust Result<T, E>Rust Propagating ErrorsRust Custom Error TypesRust Unwrap and Expect

Rust Generics and Traits

Rust Generic TypesRust Generic FunctionsRust Trait DefinitionsRust Trait ImplementationsRust Trait BoundsRust Associated Types

Rust Modules and Packages

Rust Module SystemRust CratesRust WorkspacesRust Use KeywordRust Visibility RulesRust External Dependencies

Rust Concurrency

Rust ThreadsRust Message PassingRust Shared StateRust Sync and Send TraitsRust Atomic TypesRust Mutex and RwLock

Rust Advanced Topics

Rust Unsafe CodeRust Advanced TraitsRust Advanced TypesRust MacrosRust FFI (Foreign Function Interface)Rust Asynchronous Programming

Rust Testing and Documentation

Rust Unit TestsRust Integration TestsRust Documentation TestsRust Benchmark TestsRust Documentation Comments

Rust Ecosystem

Rust Cargo Package ManagerRust Standard LibraryRust Community and ResourcesRust Popular CratesRust Web DevelopmentRust Systems Programming

Rust Visibility Rules

Visibility rules in Rust determine how different parts of your code can be accessed and used. These rules are crucial for maintaining encapsulation and creating well-structured programs.

Understanding Visibility in Rust

By default, all items in Rust are private. This means they can only be accessed within the same module. To make items public, you use the pub keyword.

Public vs. Private

  • Private: Accessible only within the current module
  • Public: Accessible from outside the current module

Visibility Rules in Action

Let's explore how visibility rules work with different Rust elements:

1. Modules


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

    fn private_function() {
        println!("This function is private");
    }
}

fn main() {
    my_module::public_function(); // OK
    // my_module::private_function(); // Error: private function
}

In this example, public_function can be called from outside the module, while private_function cannot.

2. Structs and Enums

For structs and enums, you can control the visibility of individual fields:


pub struct Person {
    pub name: String,
    age: u32, // Private field
}

impl Person {
    pub fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }

    pub fn get_age(&self) -> u32 {
        self.age
    }
}

Here, name is public, but age is private. We provide a public method get_age() to access the private field.

Best Practices

  • Make items public only when necessary
  • Use private fields with public getter methods for controlled access
  • Consider using the pub(crate) visibility modifier for crate-level visibility

Advanced Visibility Rules

Rust offers more granular control over visibility with additional modifiers:

  • pub(crate): Visible within the current crate
  • pub(super): Visible in the parent module
  • pub(in path): Visible in a specific path

Related Concepts

To deepen your understanding of Rust's visibility rules, explore these related topics:

Mastering visibility rules is essential for creating well-organized and maintainable Rust code. It allows you to control access to your code's internals while providing a clean public API for others to use.