2.6. Paths
Paths
A path is a sequence of one or more path components logically separated by a namespace qualifier (::
). If a path consists of only one component, it may refer to either an item or a variable in a local control scope. If a path has multiple components, it refers to an item.
Every item has a canonical path within its crate, but the path naming an item is only meaningful within a given crate. There is no global namespace across crates; an item's canonical path merely identifies it within the crate.
Two examples of simple paths consisting of only identifier components:
x; x::y::z;
Path components are usually identifiers, but they may also include angle-bracket-enclosed lists of type arguments. In expression context, the type argument list is given after a ::
namespace qualifier in order to disambiguate it from a relational expression involving the less-than symbol (<
). In type expression context, the final namespace qualifier is omitted.
Two examples of paths with type arguments:
# #![allow(unused_variables)] #fn main() { # struct HashMap<K, V>(K,V); # fn f() { # fn id<T>(t: T) -> T { t } type T = HashMap<i32,String>; // Type arguments used in a type expression let x = id::<i32>(10); // Type arguments used in a call expression # } #}
Paths can be denoted with various leading qualifiers to change the meaning of how it is resolved:
- Paths starting with
::
are considered to be global paths where the components of the path start being resolved from the crate root. Each identifier in the path must resolve to an item.
mod a { pub fn foo() {} } mod b { pub fn foo() { ::a::foo(); // call a's foo function } } # fn main() {}
- Paths starting with the keyword
super
begin resolution relative to the parent module. Each further identifier must resolve to an item.
mod a { pub fn foo() {} } mod b { pub fn foo() { super::a::foo(); // call a's foo function } } # fn main() {}
- Paths starting with the keyword
self
begin resolution relative to the current module. Each further identifier must resolve to an item.
fn foo() {} fn bar() { self::foo(); } # fn main() {}
Additionally keyword super
may be repeated several times after the first super
or self
to refer to ancestor modules.
mod a { fn foo() {} mod b { mod c { fn foo() { super::super::foo(); // call a's foo function self::super::super::foo(); // call a's foo function } } } } # fn main() {}
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/reference/paths.html