Оператор use и подключение модулей

Оператор use позволяет добавить путь к функционалу из других модулей к текущую область видимости или, грубо говоря, импортировать функционал. Формальное применение:

use модуль::функция/структура/перечисление/трейт;

Особенно данный оператор может быть полезен, если нам приходится по многу раз функционал модуля. Например, вызовем функцию модуля:

mod my_module{	
	pub mod inner_module{
		pub fn hello(){
			println! ("Hello");
		}
	}
}
fn main(){
	my_module::inner_module::hello();
	my_module::inner_module::hello();
	my_module::inner_module::hello();
}

Функция hello() прекрасно работает, но вот прописывать полный путь к этой функции с учетом всех модулей может быть утомительно, кроме того, это само по себе утяжеляет код. Теперь применим оператор use для подключения или импорта функции в текущую область видимости:

mod my_module{	
	pub mod inner_module{
		pub fn hello(){
			println! ("Hello");
		}
	}
}

use my_module::inner_module::hello;
fn main(){
	hello();
	hello();
	hello();
}

Инструкция

use my_module::inner_module::hello;

добавляет в текущую область видимости функцию hello из модуля my_module::inner_module::, благодаря чему далее при вызове функции можно не прописывать весь набор модулей.

Подключение всего модуля

Возможно, в некотором модуле определено несколько функций, структур, перечислений. И мы хотим, чтобы они все были доступны в рамках используемой области видимости:

mod my_module{	
	pub mod inner_module{
		pub fn hello(){
			println! ("Hello");
		}
		pub fn bye(){
			println! ("Good bye");
		}
	}
}

use my_module::inner_module::*;
fn main(){
	hello();
	bye();
}

Символ звездочка (*) позволяет подключить всю функциональность модуля:

use my_module::inner_module::*;

Подключение нескольких компонентов одного модуля

Возможно, мы захотим подключить не весь модуль, а только несколько компонентов из него:

mod my_module{	
	pub mod inner_module{
		pub fn hello(){
			println! ("Hello");
		}
		pub fn bye(){
			println! ("Good bye");
		}
		pub fn welcome(){
			println! ("Welcome");
		}
	}
}

use my_module::inner_module::{hello, bye};
fn main(){
	hello();
	bye();
}

Здесь инструкция

use my_module::inner_module::{hello, bye};

подключает две функции - hello и bye - набор подключаемых компонентов одного и того же модуля указывается в фигурных скобках через запятую. Все остальные компоненты этого модуля (как например, в данном случае функция welcome) будут не доступны.

Но, возможно, в модуле есть еще какие-то компоненты, которые мы также хотим подключить, но обращаться к ним через имя модуля. Тогда для подключения модуля можно использовать ключевое слово self:

mod my_module{	
	pub mod inner_module{
		pub fn hello(){
			println! ("Hello");
		}
		pub fn bye(){
			println! ("Good bye");
		}
		pub fn welcome(){
			println! ("Welcome");
		}
	}
}

use my_module::inner_module::{self, hello, bye};
fn main(){
	hello();
	bye();
	inner_module::welcome();
}

Одноименный функционал в модулю

Выше подключалась функция hello(), но что если в области видимости, в которую подключается функция hello() из другого модуля, уже есть своя функция hello():

mod my_module{	
	pub mod inner_module{
		pub fn hello(){
			println! ("Hello");
		}
	}
}

use my_module::inner_module::hello;
fn main(){
	hello();
}
fn hello(){
	println!("Welcome to Rust");
}

В этом случае мы получим при компиляции ошибку. И, чтобы избежать подобных ситуаций, можно подключить модуль, в котором определена функция, и обращать к функции через имя модуля:

mod my_module{	
	pub mod inner_module{
		pub fn hello(){
			println! ("Hello");
		}
	}
}

use my_module::inner_module;
fn main(){
	hello();				// Welcome to Rust
	inner_module::hello();	// Hello
}
fn hello(){
	println!("Welcome to Rust");
}

Установка псевдонимов с помощью оператора as

Оператор as позволяет установить для подключаемого функционала псевдоним:

mod my_module{
	
	pub struct Person { 
		pub name: String, 
		pub age: u8 
	}
	impl Person{
		pub fn display(&self){
			println!("Name: {}  Age: {}", &self.name, &self.age);
		}
	}
}

use my_module::Person as User;
fn main(){
	let tom = User{
        name: String::from("Tom"),
        age: 36
    };
    tom.display();
}

Здесь инструкция

use my_module::Person as User;

указывает, что для обращения к структуре Person теперь применяется имя "User":

let tom = User{ name: String::from("Tom"), age: 36 };

С помощью псевдонимов мы могли бы решить проблему в предыдущем примере с одноименными функциями:

mod my_module{	
	pub mod inner_module{
		pub fn hello(){
			println! ("Hello");
		}
	}
}

use my_module::inner_module::hello as simple_hello;
fn main(){
	hello();
	simple_hello();
}
fn hello(){
	println!("Welcome to Rust");
}

Здесь для функции hello() из модуля my_module::inner_module устанавливается псевдоним "simple_hello", через который мы можем к ней обращаться.