Rust by Example

pub fn new(contents: T) -> ClosedBox {

ClosedBox {

contents: contents,

}

}

}

}

fn main() {

// Public structs with public fields can be constructed as usual

let open_box = my::OpenBox { contents: "public information" };

// and their fields can be normally accessed.

println!("The open box contains: {}", open_box.contents);

// Public structs with private fields cannot be constructed using field names.

// Error! `ClosedBox` has private fields

//let closed_box = my::ClosedBox { contents: "classified information" };

// TODO ^ Try uncommenting this line

// However, structs with private fields can be created using

// public constructors

let _closed_box = my::ClosedBox::new("classified information");

// and the private fields of a public struct cannot be accessed.

// Error! The `contents` field is private

//println!("The closed box contains: {}", _closed_box.contents);

// TODO ^ Try uncommenting this line

}

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

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

See also:

generics and methods

The use declaration

The use declaration can be used to bind a full path to a new name, for easier access. It is often used like this:

use crate::deeply::nested::{

my_first_function,

my_second_function,

AndATraitType

};

fn main() {

my_first_function();

}

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

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

You can use the as keyword to bind imports to a different name:

// Bind the `deeply::nested::function` path to `other_function`.

use deeply::nested::function as other_function;

fn function() {

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

}

mod deeply {

pub mod nested {

pub fn function() {

println!("called `deeply::nested::function()`");

}

}

}

fn main() {

// Easier access to `deeply::nested::function`

other_function();