std::path::Path - Rust
Description: API documentation for the Rust `Path` struct in crate `std`.
Keywords: rust, rustlang, rust-lang, Path

# 1.0.0[−][src]Struct std::path::Path

    pub struct Path { /* fields omitted */ }

A slice of a path (akin to `str`).

This type supports a number of operations for inspecting a path, including breaking the path into its components (separated by `/` on Unix and by either `/` or `\` on Windows), extracting the file name, determining whether the path is absolute, and so on.

This is an unsized type, meaning that it must always be used behind a pointer like `&` or `Box`. For an owned version of this type, see `PathBuf`.

More details about the overall approach can be found in the module documentation.

# Examples

    use std::path::Path;
    use std::ffi::OsStr;

    // Note: this example does work on Windows
    let path = Path::new("./foo/bar.txt");

    let parent = path.parent();
    assert_eq!(parent, Some(Path::new("./foo")));

    let file_stem = path.file_stem();
    assert_eq!(file_stem, Some(OsStr::new("bar")));

    let extension = path.extension();
    assert_eq!(extension, Some(OsStr::new("txt")));Run

## Methods

### `impl Path`[src]

#### `pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &Path`[src]

Directly wraps a string slice as a `Path` slice.

This is a cost-free conversion.

# Examples

    use std::path::Path;

    Path::new("foo.txt");Run

You can create `Path`s from `String`s, or even other `Path`s:

    use std::path::Path;

    let string = String::from("foo.txt");
    let from_string = Path::new(&string);
    let from_path = Path::new(&from_string);
    assert_eq!(from_string, from_path);Run

#### `pub fn as_os_str(&self) -> &OsStr`[src]

Yields the underlying `OsStr` slice.

# Examples

    use std::path::Path;

    let os_str = Path::new("foo.txt").as_os_str();
    assert_eq!(os_str, std::ffi::OsStr::new("foo.txt"));Run

#### `pub fn to_str(&self) -> Option<&str>`[src]

Yields a `&str` slice if the `Path` is valid unicode.

This conversion may entail doing a check for UTF-8 validity. Note that validation is performed because non-UTF-8 strings are perfectly valid for some OS.

# Examples

    use std::path::Path;

    let path = Path::new("foo.txt");
    assert_eq!(path.to_str(), Some("foo.txt"));Run

#### `pub fn to_string_lossy(&self) -> Cow<str>`[src]

Converts a `Path` to a `Cow<str>`.

Any non-Unicode sequences are replaced with `U+FFFD REPLACEMENT CHARACTER`.

# Examples

Calling `to_string_lossy` on a `Path` with valid unicode:

    use std::path::Path;

    let path = Path::new("foo.txt");
    assert_eq!(path.to_string_lossy(), "foo.txt");Run

Had `path` contained invalid unicode, the `to_string_lossy` call might have returned `"fo�.txt"`.

#### `pub fn to_path_buf(&self) -> PathBuf`[src]

Converts a `Path` to an owned `PathBuf`.

# Examples

    use std::path::Path;

    let path_buf = Path::new("foo.txt").to_path_buf();
    assert_eq!(path_buf, std::path::PathBuf::from("foo.txt"));Run

#### `pub fn is_absolute(&self) -> bool`[src]

Returns `true` if the `Path` is absolute, i.e., if it is independent of the current directory.

- On Unix, a path is absolute if it starts with the root, so `is_absolute` and `has_root` are equivalent.

- On Windows, a path is absolute if it has a prefix and starts with the root: `c:\windows` is absolute, while `c:temp` and `\temp` are not.

# Examples

    use std::path::Path;

    assert!(!Path::new("foo.txt").is_absolute());Run

#### `pub fn is_relative(&self) -> bool`[src]

Returns `true` if the `Path` is relative, i.e., not absolute.

See `is_absolute`'s documentation for more details.

# Examples

    use std::path::Path;

    assert!(Path::new("foo.txt").is_relative());Run

#### `pub fn has_root(&self) -> bool`[src]

Returns `true` if the `Path` has a root.

- On Unix, a path has a root if it begins with `/`.

- On Windows, a path has a root if it:

  - has no prefix and begins with a separator, e.g., `\windows`
  - has a prefix followed by a separator, e.g., `c:\windows` but not `c:windows`
  - has any non-disk prefix, e.g., `\\server\share`

# Examples

    use std::path::Path;

    assert!(Path::new("/etc/passwd").has_root());Run

#### `pub fn parent(&self) -> Option<&Path>`[src]

Returns the `Path` without its final component, if there is one.

Returns `None` if the path terminates in a root or prefix.

# Examples

    use std::path::Path;

    let path = Path::new("/foo/bar");
    let parent = path.parent().unwrap();
    assert_eq!(parent, Path::new("/foo"));

    let grand_parent = parent.parent().unwrap();
    assert_eq!(grand_parent, Path::new("/"));
    assert_eq!(grand_parent.parent(), None);Run

####
ⓘImportant traits for Ancestors<'a>

### Important traits for Ancestors<'a>

`impl<'a> Iterator for Ancestors<'a> type Item = &'a Path;`
`pub fn ancestors(&self) -> Ancestors`1.28.0[src]

Produces an iterator over `Path` and its ancestors.

The iterator will yield the `Path` that is returned if the `parent` method is used zero or more times. That means, the iterator will yield `&self`, `&self.parent().unwrap()`, `&self.parent().unwrap().parent().unwrap()` and so on. If the `parent` method returns `None`, the iterator will do likewise. The iterator will always yield at least one value, namely `&self`.

# Examples

    use std::path::Path;

    let mut ancestors = Path::new("/foo/bar").ancestors();
    assert_eq!(ancestors.next(), Some(Path::new("/foo/bar")));
    assert_eq!(ancestors.next(), Some(Path::new("/foo")));
    assert_eq!(ancestors.next(), Some(Path::new("/")));
    assert_eq!(ancestors.next(), None);Run

#### `pub fn file_name(&self) -> Option<&OsStr>`[src]

Returns the final component of the `Path`, if there is one.

If the path is a normal file, this is the file name. If it's the path of a directory, this is the directory name.

Returns `None` if the path terminates in `..`.

# Examples

    use std::path::Path;
    use std::ffi::OsStr;

    assert_eq!(Some(OsStr::new("bin")), Path::new("/usr/bin/").file_name());
    assert_eq!(Some(OsStr::new("foo.txt")), Path::new("tmp/foo.txt").file_name());
    assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.").file_name());
    assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.//").file_name());
    assert_eq!(None, Path::new("foo.txt/..").file_name());
    assert_eq!(None, Path::new("/").file_name());Run

#### `pub fn strip_prefix<P>(&self, base: P) -> Result<&Path, StripPrefixError> where
P: AsRef<Path>,` 1.7.0[src]

Returns a path that, when joined onto `base`, yields `self`.

# Errors

If `base` is not a prefix of `self` (i.e., `starts_with` returns `false`), returns `Err`.

# Examples

    use std::path::{Path, PathBuf};

    let path = Path::new("/test/haha/foo.txt");

    assert_eq!(path.strip_prefix("/"), Ok(Path::new("test/haha/foo.txt")));
    assert_eq!(path.strip_prefix("/test"), Ok(Path::new("haha/foo.txt")));
    assert_eq!(path.strip_prefix("/test/"), Ok(Path::new("haha/foo.txt")));
    assert_eq!(path.strip_prefix("/test/haha/foo.txt"), Ok(Path::new("")));
    assert_eq!(path.strip_prefix("/test/haha/foo.txt/"), Ok(Path::new("")));
    assert_eq!(path.strip_prefix("test").is_ok(), false);
    assert_eq!(path.strip_prefix("/haha").is_ok(), false);

    let prefix = PathBuf::from("/test/");
    assert_eq!(path.strip_prefix(prefix), Ok(Path::new("haha/foo.txt")));Run

#### `pub fn starts_with<P: AsRef<Path>>(&self, base: P) -> bool`[src]

Determines whether `base` is a prefix of `self`.

Only considers whole path components to match.

# Examples

    use std::path::Path;

    let path = Path::new("/etc/passwd");

    assert!(path.starts_with("/etc"));
    assert!(path.starts_with("/etc/"));
    assert!(path.starts_with("/etc/passwd"));
    assert!(path.starts_with("/etc/passwd/"));

    assert!(!path.starts_with("/e"));Run

#### `pub fn ends_with<P: AsRef<Path>>(&self, child: P) -> bool`[src]

Determines whether `child` is a suffix of `self`.

Only considers whole path components to match.

# Examples

    use std::path::Path;

    let path = Path::new("/etc/passwd");

    assert!(path.ends_with("passwd"));Run

#### `pub fn file_stem(&self) -> Option<&OsStr>`[src]

Extracts the stem (non-extension) portion of `self.file_name`.

The stem is:

- `None`, if there is no file name;
- The entire file name if there is no embedded `.`;
- The entire file name if the file name begins with `.` and has no other `.`s within;
- Otherwise, the portion of the file name before the final `.`

# Examples

    use std::path::Path;

    let path = Path::new("foo.rs");

    assert_eq!("foo", path.file_stem().unwrap());Run

#### `pub fn extension(&self) -> Option<&OsStr>`[src]

Extracts the extension of `self.file_name`, if possible.

The extension is:

- `None`, if there is no file name;
- `None`, if there is no embedded `.`;
- `None`, if the file name begins with `.` and has no other `.`s within;
- Otherwise, the portion of the file name after the final `.`

# Examples

    use std::path::Path;

    let path = Path::new("foo.rs");

    assert_eq!("rs", path.extension().unwrap());Run

#### `#[must_use] pub fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf`[src]

Creates an owned `PathBuf` with `path` adjoined to `self`.

See `PathBuf::push` for more details on what it means to adjoin a path.

# Examples

    use std::path::{Path, PathBuf};

    assert_eq!(Path::new("/etc").join("passwd"), PathBuf::from("/etc/passwd"));Run

#### `pub fn with_file_name<S: AsRef<OsStr>>(&self, file_name: S) -> PathBuf`[src]

Creates an owned `PathBuf` like `self` but with the given file name.

See `PathBuf::set_file_name` for more details.

# Examples

    use std::path::{Path, PathBuf};

    let path = Path::new("/tmp/foo.txt");
    assert_eq!(path.with_file_name("bar.txt"), PathBuf::from("/tmp/bar.txt"));

    let path = Path::new("/tmp");
    assert_eq!(path.with_file_name("var"), PathBuf::from("/var"));Run

#### `pub fn with_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf`[src]

Creates an owned `PathBuf` like `self` but with the given extension.

See `PathBuf::set_extension` for more details.

# Examples

    use std::path::{Path, PathBuf};

    let path = Path::new("foo.rs");
    assert_eq!(path.with_extension("txt"), PathBuf::from("foo.txt"));Run

####
ⓘImportant traits for Components<'a>

### Important traits for Components<'a>

`impl<'a> Iterator for Components<'a> type Item = Component<'a>;`
`pub fn components(&self) -> Components`[src]

Produces an iterator over the `Component`s of the path.

When parsing the path, there is a small amount of normalization:

- Repeated separators are ignored, so `a/b` and `a//b` both have `a` and `b` as components.

- Occurrences of `.` are normalized away, except if they are at the beginning of the path. For example, `a/./b`, `a/b/`, `a/b/.` and `a/b` all have `a` and `b` as components, but `./a/b` starts with an additional `CurDir` component.

- A trailing slash is normalized away, `/a/b` and `/a/b/` are equivalent.

Note that no other normalization takes place; in particular, `a/c` and `a/b/../c` are distinct, to account for the possibility that `b` is a symbolic link (so its parent isn't `a`).

# Examples

    use std::path::{Path, Component};
    use std::ffi::OsStr;

    let mut components = Path::new("/tmp/foo.txt").components();

    assert_eq!(components.next(), Some(Component::RootDir));
    assert_eq!(components.next(), Some(Component::Normal(OsStr::new("tmp"))));
    assert_eq!(components.next(), Some(Component::Normal(OsStr::new("foo.txt"))));
    assert_eq!(components.next(), None)Run

####
ⓘImportant traits for Iter<'a>

### Important traits for Iter<'a>

`impl<'a> Iterator for Iter<'a> type Item = &'a OsStr;`
`pub fn iter(&self) -> Iter`[src]

Produces an iterator over the path's components viewed as `OsStr` slices.

For more information about the particulars of how the path is separated into components, see `components`.

# Examples

    use std::path::{self, Path};
    use std::ffi::OsStr;

    let mut it = Path::new("/tmp/foo.txt").iter();
    assert_eq!(it.next(), Some(OsStr::new(&path::MAIN_SEPARATOR.to_string())));
    assert_eq!(it.next(), Some(OsStr::new("tmp")));
    assert_eq!(it.next(), Some(OsStr::new("foo.txt")));
    assert_eq!(it.next(), None)Run

#### `pub fn display(&self) -> Display`[src]

Returns an object that implements `Display` for safely printing paths that may contain non-Unicode data.

# Examples

    use std::path::Path;

    let path = Path::new("/tmp/foo.rs");

    println!("{}", path.display());Run

#### `pub fn metadata(&self) -> Result<Metadata>`1.5.0[src]

Queries the file system to get information about a file, directory, etc.

This function will traverse symbolic links to query information about the destination file.

This is an alias to `fs::metadata`.

# Examples

    use std::path::Path;

    let path = Path::new("/Minas/tirith");
    let metadata = path.metadata().expect("metadata call failed");
    println!("{:?}", metadata.file_type());Run

#### `pub fn symlink_metadata(&self) -> Result<Metadata>`1.5.0[src]

Queries the metadata about a file without following symlinks.

This is an alias to `fs::symlink_metadata`.

# Examples

    use std::path::Path;

    let path = Path::new("/Minas/tirith");
    let metadata = path.symlink_metadata().expect("symlink_metadata call failed");
    println!("{:?}", metadata.file_type());Run

#### `pub fn canonicalize(&self) -> Result<PathBuf>`1.5.0[src]

Returns the canonical, absolute form of the path with all intermediate components normalized and symbolic links resolved.

This is an alias to `fs::canonicalize`.

# Examples

    use std::path::{Path, PathBuf};

    let path = Path::new("/foo/test/../test/bar.rs");
    assert_eq!(path.canonicalize().unwrap(), PathBuf::from("/foo/test/bar.rs"));Run

#### `pub fn read_link(&self) -> Result<PathBuf>`1.5.0[src]

Reads a symbolic link, returning the file that the link points to.

This is an alias to `fs::read_link`.

# Examples

    use std::path::Path;

    let path = Path::new("/laputa/sky_castle.rs");
    let path_link = path.read_link().expect("read_link call failed");Run

#### `pub fn read_dir(&self) -> Result<ReadDir>`1.5.0[src]

Returns an iterator over the entries within a directory.

The iterator will yield instances of `io::Result``<``DirEntry``>`. New errors may be encountered after an iterator is initially constructed.

This is an alias to `fs::read_dir`.

# Examples

    use std::path::Path;

    let path = Path::new("/laputa");
    for entry in path.read_dir().expect("read_dir call failed") {
        if let Ok(entry) = entry {
            println!("{:?}", entry.path());
        }
    }Run

#### `pub fn exists(&self) -> bool`1.5.0[src]

Returns `true` if the path points at an existing entity.

This function will traverse symbolic links to query information about the destination file. In case of broken symbolic links this will return `false`.

If you cannot access the directory containing the file, e.g., because of a permission error, this will return `false`.

# Examples

    use std::path::Path;
    assert_eq!(Path::new("does_not_exist.txt").exists(), false);Run

# See Also

This is a convenience function that coerces errors to false. If you want to check errors, call fs::metadata.

#### `pub fn is_file(&self) -> bool`1.5.0[src]

Returns `true` if the path exists on disk and is pointing at a regular file.

This function will traverse symbolic links to query information about the destination file. In case of broken symbolic links this will return `false`.

If you cannot access the directory containing the file, e.g., because of a permission error, this will return `false`.

# Examples

    use std::path::Path;
    assert_eq!(Path::new("./is_a_directory/").is_file(), false);
    assert_eq!(Path::new("a_file.txt").is_file(), true);Run

# See Also

This is a convenience function that coerces errors to false. If you want to check errors, call fs::metadata and handle its Result. Then call fs::Metadata::is_file if it was Ok.

#### `pub fn is_dir(&self) -> bool`1.5.0[src]

Returns `true` if the path exists on disk and is pointing at a directory.

This function will traverse symbolic links to query information about the destination file. In case of broken symbolic links this will return `false`.

If you cannot access the directory containing the file, e.g., because of a permission error, this will return `false`.

# Examples

    use std::path::Path;
    assert_eq!(Path::new("./is_a_directory/").is_dir(), true);
    assert_eq!(Path::new("a_file.txt").is_dir(), false);Run

# See Also

This is a convenience function that coerces errors to false. If you want to check errors, call fs::metadata and handle its Result. Then call fs::Metadata::is_dir if it was Ok.

#### `pub fn into_path_buf(self: Box<Path>) -> PathBuf`1.20.0[src]

Converts a `Box<Path>` into a `PathBuf` without copying or allocating.

## Trait Implementations

### `impl<'_> From<&'_ Path> for Box<Path>`1.17.0[src]

####
ⓘImportant traits for Box<I>

### Important traits for Box<I>

`impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`fn from(path: &Path) -> Box<Path>`[src]

Performs the conversion.

### `impl<'a> From<&'a Path> for Cow<'a, Path>`1.6.0[src]

#### `fn from(s: &'a Path) -> Cow<'a, Path>`[src]

Performs the conversion.

### `impl<'_> From<&'_ Path> for Arc<Path>`1.24.0[src]

#### `fn from(s: &Path) -> Arc<Path>`[src]

Converts a `Path` into an `Arc` by copying the `Path` data into a new `Arc` buffer.

### `impl<'_> From<&'_ Path> for Rc<Path>`1.24.0[src]

#### `fn from(s: &Path) -> Rc<Path>`[src]

Converts a `Path` into an `Rc` by copying the `Path` data into a new `Rc` buffer.

### `impl Debug for Path`[src]

#### `fn fmt(&self, formatter: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

### `impl PartialEq<Path> for Path`[src]

#### `fn eq(&self, other: &Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Path> for PathBuf` 1.6.0[src]

#### `fn eq(&self, other: &Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<PathBuf> for Path` 1.6.0[src]

#### `fn eq(&self, other: &PathBuf) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<&'a Path> for PathBuf` 1.6.0[src]

#### `fn eq(&self, other: &&'a Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<PathBuf> for &'a Path` 1.6.0[src]

#### `fn eq(&self, other: &PathBuf) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Path> for Cow<'a, Path>`1.6.0[src]

#### `fn eq(&self, other: &Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Cow<'a, Path>> for Path` 1.6.0[src]

#### `fn eq(&self, other: &Cow<'a, Path>) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<&'b Path> for Cow<'a, Path>`1.6.0[src]

#### `fn eq(&self, other: &&'b Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Cow<'a, Path>> for &'b Path` 1.6.0[src]

#### `fn eq(&self, other: &Cow<'a, Path>) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<OsStr> for Path` 1.8.0[src]

#### `fn eq(&self, other: &OsStr) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Path> for OsStr` 1.8.0[src]

#### `fn eq(&self, other: &Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<&'a OsStr> for Path` 1.8.0[src]

#### `fn eq(&self, other: &&'a OsStr) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Path> for &'a OsStr` 1.8.0[src]

#### `fn eq(&self, other: &Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for Path` 1.8.0[src]

#### `fn eq(&self, other: &Cow<'a, OsStr>) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Path> for Cow<'a, OsStr>`1.8.0[src]

#### `fn eq(&self, other: &Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<OsString> for Path` 1.8.0[src]

#### `fn eq(&self, other: &OsString) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Path> for OsString` 1.8.0[src]

#### `fn eq(&self, other: &Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<OsStr> for &'a Path` 1.8.0[src]

#### `fn eq(&self, other: &OsStr) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<&'a Path> for OsStr` 1.8.0[src]

#### `fn eq(&self, other: &&'a Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Cow<'b, OsStr>> for &'a Path` 1.8.0[src]

#### `fn eq(&self, other: &Cow<'b, OsStr>) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<&'a Path> for Cow<'b, OsStr>`1.8.0[src]

#### `fn eq(&self, other: &&'a Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<OsString> for &'a Path` 1.8.0[src]

#### `fn eq(&self, other: &OsString) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<&'a Path> for OsString` 1.8.0[src]

#### `fn eq(&self, other: &&'a Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl Eq for Path`[src]

### `impl Ord for Path`[src]

#### `fn cmp(&self, other: &Path) -> Ordering`[src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `fn max(self, other: Self) -> Self`1.21.0[src]

Compares and returns the maximum of two values. Read more

#### `fn min(self, other: Self) -> Self`1.21.0[src]

Compares and returns the minimum of two values. Read more

#### `fn clamp(self, min: Self, max: Self) -> Self`[src]

🔬 This is a nightly-only experimental API. (`clamp` #44095)

Restrict a value to a certain interval. Read more

### `impl PartialOrd<Path> for Path`[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<Path> for PathBuf` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<PathBuf> for Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<&'a Path> for PathBuf` 1.8.0[src]

#### `fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<PathBuf> for &'a Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<Path> for Cow<'a, Path>`1.8.0[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<&'b Path> for Cow<'a, Path>`1.8.0[src]

#### `fn partial_cmp(&self, other: &&'b Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<OsStr> for Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<Path> for OsStr` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<&'a OsStr> for Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<Path> for &'a OsStr` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>`1.8.0[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<OsString> for Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<Path> for OsString` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<OsStr> for &'a Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<&'a Path> for OsStr` 1.8.0[src]

#### `fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Cow<'b, OsStr>) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<&'a Path> for Cow<'b, OsStr>`1.8.0[src]

#### `fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<OsString> for &'a Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<'a, 'b> PartialOrd<&'a Path> for OsString` 1.8.0[src]

#### `fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl Hash for Path`[src]

#### `fn hash<H: Hasher>(&self, h: &mut H)`[src]

Feeds this value into the given [`Hasher`]. Read more

#### `fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

### `impl<'a> IntoIterator for &'a Path` 1.6.0[src]

#### `type Item = &'a OsStr`

The type of the elements being iterated over.

#### `type IntoIter = Iter<'a>`

Which kind of iterator are we turning this into?

####
ⓘImportant traits for Iter<'a>

### Important traits for Iter<'a>

`impl<'a> Iterator for Iter<'a> type Item = &'a OsStr;`
`fn into_iter(self) -> Iter<'a>`[src]

Creates an iterator from a value. Read more

### `impl<'_> AsRef<Path> for Component<'_>`1.25.0[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl<'_> AsRef<Path> for Components<'_>`[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl<'_> AsRef<Path> for Iter<'_>`[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl AsRef<OsStr> for Path`[src]

#### `fn as_ref(&self) -> &OsStr`[src]

Performs the conversion.

### `impl AsRef<Path> for Path`[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl AsRef<Path> for OsStr`[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl<'_> AsRef<Path> for Cow<'_, OsStr>`1.8.0[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl AsRef<Path> for OsString`[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl AsRef<Path> for str`[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl AsRef<Path> for String`[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl AsRef<Path> for PathBuf`[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl Borrow<Path> for PathBuf`[src]

#### `fn borrow(&self) -> &Path`[src]

Immutably borrows from an owned value. Read more

### `impl ToOwned for Path`[src]

#### `type Owned = PathBuf`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> PathBuf`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut PathBuf)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into` #41263)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

## Auto Trait Implementations

### `impl UnwindSafe for Path`

### `impl RefUnwindSafe for Path`

### `impl Unpin for Path`

### `impl Send for Path`

### `impl Sync for Path`

## Blanket Implementations

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

####
ⓘImportant traits for &'_ mut I

### Important traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W`
`fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

####
ⓘImportant traits for &'_ mut I

### Important traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W`
`fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into` #41263)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more