Rust by Example

println!("called `my_mod::private_nested::function()`");

}

// Private parent items will still restrict the visibility of a child item,

// even if it is declared as visible within a bigger scope.

#[allow(dead_code)]

pub(crate) fn restricted_function() {

println!("called `my_mod::private_nested::restricted_function()`");

}

}

}

fn function() {

println!("called `function()`");

}

fn main() {

// Modules allow disambiguation between items that have the same name.

function();

my_mod::function();

// Public items, including those inside nested modules, can be

// accessed from outside the parent module.

my_mod::indirect_access();

my_mod::nested::function();

my_mod::call_public_function_in_my_mod();

// pub(crate) items can be called from anywhere in the same crate

my_mod::public_function_in_crate();

// pub(in path) items can only be called from within the module specified

// Error! function `public_function_in_my_mod` is private

//my_mod::nested::public_function_in_my_mod();

// TODO ^ Try uncommenting this line

// Private items of a module cannot be directly accessed, even if

// nested in a public module:

// Error! `private_function` is private

//my_mod::private_function();

// TODO ^ Try uncommenting this line

// Error! `private_function` is private

//my_mod::nested::private_function();

// TODO ^ Try uncommenting this line

// Error! `private_nested` is a private module

//my_mod::private_nested::function();

// TODO ^ Try uncommenting this line

// Error! `private_nested` is a private module

//my_mod::private_nested::restricted_function();

// TODO ^ Try uncommenting this line

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Struct visibility

Structs have an extra level of visibility with their fields. The visibility defaults to private, and can be overridden with the pub modifier. This visibility only matters when a struct is accessed from outside the module where it is defined, and has the goal of hiding information (encapsulation).

mod my {

// A public struct with a public field of generic type `T`

pub struct OpenBox {

pub contents: T,

}

// A public struct with a private field of generic type `T`

#[allow(dead_code)]

pub struct ClosedBox {

contents: T,

}

impl ClosedBox {

// A public constructor method