Primitive Type str

Unicode string manipulation (the str type).

Rust's str type is one of the core primitive types of the language. &str is the borrowed string type. This type of string can only be created from other strings, unless it is a &'static str (see below). It is not possible to move out of borrowed strings because they are owned elsewhere.

Examples

Here's some code that uses a &str:

fn main() { let s = "Hello, world."; }

let s = "Hello, world.";

This &str is a &'static str, which is the type of string literals. They're 'static because literals are available for the entire lifetime of the program.

You can get a non-'static &str by taking a slice of a String:

fn main() { let some_string = "Hello, world.".to_string(); let s = &some_string; }

let s = &some_string;

Representation

Rust's string type, str, is a sequence of Unicode scalar values encoded as a stream of UTF-8 bytes. All strings are guaranteed to be validly encoded UTF-8 sequences. Additionally, strings are not null-terminated and can thus contain null bytes.

The actual representation of strs have direct mappings to slices: &str is the same as &[u8].

Methods

impl str

Any string that can be represented as a slice.

fn escape_default(&self) -> String

Unstable

: return type may change to be an iterator

Escapes each char in s with char::escape_default.

fn escape_unicode(&self) -> String

Unstable

: return type may change to be an iterator

Escapes each char in s with char::escape_unicode.

fn replace(&self, from: &str, to: &str) -> String

Replaces all occurrences of one string with another.

replace takes two arguments, a sub-&str to find in self, and a second &str to replace it with. If the original &str isn't found, no change occurs.

Examples

fn main() { let s = "this is old"; assert_eq!(s.replace("old", "new"), "this is new"); }

let s = "this is old";

assert_eq!(s.replace("old", "new"), "this is new");

When a &str isn't found:

fn main() { let s = "this is old"; assert_eq!(s.replace("cookie monster", "little lamb"), s); }

let s = "this is old";
assert_eq!(s.replace("cookie monster", "little lamb"), s);

fn nfd_chars(&self) -> Decompositions

Deprecated since 1.0.0

: use the crates.io unicode-normalization library instead

Returns an iterator over the string in Unicode Normalization Form D (canonical decomposition).

fn nfkd_chars(&self) -> Decompositions

Deprecated since 1.0.0

: use the crates.io unicode-normalization library instead

Returns an iterator over the string in Unicode Normalization Form KD (compatibility decomposition).

fn nfc_chars(&self) -> Recompositions

Deprecated since 1.0.0

: use the crates.io unicode-normalization library instead

An Iterator over the string in Unicode Normalization Form C (canonical decomposition followed by canonical composition).

fn nfkc_chars(&self) -> Recompositions

Deprecated since 1.0.0

: use the crates.io unicode-normalization library instead

An Iterator over the string in Unicode Normalization Form KC (compatibility decomposition followed by canonical composition).

fn contains<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>

Returns true if self contains another &str.

Examples

fn main() { assert!("bananas".contains("nana")); assert!(!"bananas".contains("foobar")); }

assert!("bananas".contains("nana"));

assert!(!"bananas".contains("foobar"));

fn chars(&self) -> Chars

An iterator over the codepoints of self.

Examples

fn main() { let v: Vec<char> = "abc åäö".chars().collect(); assert_eq!(v, ['a', 'b', 'c', ' ', 'å', 'ä', 'ö']); }

let v: Vec<char> = "abc åäö".chars().collect();

assert_eq!(v, ['a', 'b', 'c', ' ', 'å', 'ä', 'ö']);

fn bytes(&self) -> Bytes

An iterator over the bytes of self.

Examples

fn main() { let v: Vec<u8> = "bors".bytes().collect(); assert_eq!(v, b"bors".to_vec()); }

let v: Vec<u8> = "bors".bytes().collect();

assert_eq!(v, b"bors".to_vec());

fn char_indices(&self) -> CharIndices

An iterator over the characters of self and their byte offsets.

Examples

fn main() { let v: Vec<(usize, char)> = "abc".char_indices().collect(); let b = vec![(0, 'a'), (1, 'b'), (2, 'c')]; assert_eq!(v, b); }

let v: Vec<(usize, char)> = "abc".char_indices().collect();
let b = vec![(0, 'a'), (1, 'b'), (2, 'c')];

assert_eq!(v, b);

fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> where P: Pattern<'a>

An iterator over substrings of self, separated by characters matched by a pattern.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator will be double ended if the pattern allows a reverse search and forward/reverse search yields the same elements. This is true for, eg, char but not for &str.

If the pattern allows a reverse search but its results might differ from a forward search, rsplit() can be used.

Examples

Simple patterns:

fn main() { let v: Vec<&str> = "Mary had a little lamb".split(' ').collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); let v: Vec<&str> = "".split('X').collect(); assert_eq!(v, [""]); let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect(); assert_eq!(v, ["lion", "", "tiger", "leopard"]); let v: Vec<&str> = "lion::tiger::leopard".split("::").collect(); assert_eq!(v, ["lion", "tiger", "leopard"]); }

let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

More complex patterns with closures:

fn main() { let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["abc", "def", "ghi"]); let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect(); assert_eq!(v, ["lion", "tiger", "leopard"]); }

let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>

An iterator over substrings of self, separated by characters matched by a pattern and yielded in reverse order.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.

For iterating from the front, split() can be used.

Examples

Simple patterns:

fn main() { let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect(); assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]); let v: Vec<&str> = "".rsplit('X').collect(); assert_eq!(v, [""]); let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect(); assert_eq!(v, ["leopard", "tiger", "", "lion"]); let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect(); assert_eq!(v, ["leopard", "tiger", "lion"]); }

let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect();
assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]);

let v: Vec<&str> = "".rsplit('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect();
assert_eq!(v, ["leopard", "tiger", "", "lion"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect();
assert_eq!(v, ["leopard", "tiger", "lion"]);

More complex patterns with closures:

fn main() { let v: Vec<&str> = "abc1def2ghi".rsplit(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["ghi", "def", "abc"]); let v: Vec<&str> = "lionXtigerXleopard".rsplit(char::is_uppercase).collect(); assert_eq!(v, ["leopard", "tiger", "lion"]); }

let v: Vec<&str> = "abc1def2ghi".rsplit(|c: char| c.is_numeric()).collect();
assert_eq!(v, ["ghi", "def", "abc"]);

let v: Vec<&str> = "lionXtigerXleopard".rsplit(char::is_uppercase).collect();
assert_eq!(v, ["leopard", "tiger", "lion"]);

fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> where P: Pattern<'a>

An iterator over substrings of self, separated by characters matched by a pattern.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Equivalent to split, except that the trailing substring is skipped if empty.

This method can be used for string data that is terminated, rather than separated by a pattern.

Iterator behavior

The returned iterator will be double ended if the pattern allows a reverse search and forward/reverse search yields the same elements. This is true for, eg, char but not for &str.

If the pattern allows a reverse search but its results might differ from a forward search, rsplit_terminator() can be used.

Examples

Simple patterns:

fn main() { let v: Vec<&str> = "A.B.".split_terminator('.').collect(); assert_eq!(v, ["A", "B"]); let v: Vec<&str> = "A..B..".split_terminator(".").collect(); assert_eq!(v, ["A", "", "B", ""]); }

let v: Vec<&str> = "A.B.".split_terminator('.').collect();
assert_eq!(v, ["A", "B"]);

let v: Vec<&str> = "A..B..".split_terminator(".").collect();
assert_eq!(v, ["A", "", "B", ""]);

More complex patterns with closures:

fn main() { let v: Vec<&str> = "abc1def2ghi3".split_terminator(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["abc", "def", "ghi"]); }

let v: Vec<&str> = "abc1def2ghi3".split_terminator(|c: char| c.is_numeric()).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>

An iterator over substrings of self, separated by characters matched by a pattern and yielded in reverse order.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Equivalent to split, except that the trailing substring is skipped if empty.

This method can be used for string data that is terminated, rather than separated by a pattern.

Iterator behavior

The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.

For iterating from the front, split_terminator() can be used.

Examples

Simple patterns:

fn main() { let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect(); assert_eq!(v, ["B", "A"]); let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect(); assert_eq!(v, ["", "B", "", "A"]); }

let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect();
assert_eq!(v, ["B", "A"]);

let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect();
assert_eq!(v, ["", "B", "", "A"]);

More complex patterns with closures:

fn main() { let v: Vec<&str> = "abc1def2ghi3".rsplit_terminator(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["ghi", "def", "abc"]); }

let v: Vec<&str> = "abc1def2ghi3".rsplit_terminator(|c: char| c.is_numeric()).collect();
assert_eq!(v, ["ghi", "def", "abc"]);

fn splitn<'a, P>(&'a self, count: usize, pat: P) -> SplitN<'a, P> where P: Pattern<'a>

An iterator over substrings of self, separated by a pattern, restricted to returning at most count items.

The last element returned, if any, will contain the remainder of the string. The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator will not be double ended, because it is not efficient to support.

If the pattern allows a reverse search, rsplitn() can be used.

Examples

Simple patterns:

fn main() { let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect(); assert_eq!(v, ["Mary", "had", "a little lambda"]); let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect(); assert_eq!(v, ["lion", "", "tigerXleopard"]); let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect(); assert_eq!(v, ["abcXdef"]); let v: Vec<&str> = "".splitn(1, 'X').collect(); assert_eq!(v, [""]); }

let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect();
assert_eq!(v, ["Mary", "had", "a little lambda"]);

let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect();
assert_eq!(v, ["lion", "", "tigerXleopard"]);

let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect();
assert_eq!(v, ["abcXdef"]);

let v: Vec<&str> = "".splitn(1, 'X').collect();
assert_eq!(v, [""]);

More complex patterns with closures:

fn main() { let v: Vec<&str> = "abc1def2ghi".splitn(2, |c: char| c.is_numeric()).collect(); assert_eq!(v, ["abc", "def2ghi"]); }

let v: Vec<&str> = "abc1def2ghi".splitn(2, |c: char| c.is_numeric()).collect();
assert_eq!(v, ["abc", "def2ghi"]);

fn rsplitn<'a, P>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>

An iterator over substrings of self, separated by a pattern, starting from the end of the string, restricted to returning at most count items.

The last element returned, if any, will contain the remainder of the string.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator will not be double ended, because it is not efficient to support.

splitn() can be used for splitting from the front.

Examples

Simple patterns:

fn main() { let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect(); assert_eq!(v, ["lamb", "little", "Mary had a"]); let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect(); assert_eq!(v, ["leopard", "tiger", "lionX"]); let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect(); assert_eq!(v, ["leopard", "lion::tiger"]); }

let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
assert_eq!(v, ["lamb", "little", "Mary had a"]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
assert_eq!(v, ["leopard", "tiger", "lionX"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
assert_eq!(v, ["leopard", "lion::tiger"]);

More complex patterns with closures:

fn main() { let v: Vec<&str> = "abc1def2ghi".rsplitn(2, |c: char| c.is_numeric()).collect(); assert_eq!(v, ["ghi", "abc1def"]); }

let v: Vec<&str> = "abc1def2ghi".rsplitn(2, |c: char| c.is_numeric()).collect();
assert_eq!(v, ["ghi", "abc1def"]);

fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> where P: Pattern<'a>

Unstable

: method got recently added

An iterator over the matches of a pattern within self.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator will be double ended if the pattern allows a reverse search and forward/reverse search yields the same elements. This is true for, eg, char but not for &str.

If the pattern allows a reverse search but its results might differ from a forward search, rmatches() can be used.

Examples

#![feature(collections)] fn main() { let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect(); assert_eq!(v, ["abc", "abc", "abc"]); let v: Vec<&str> = "1abc2abc3".matches(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["1", "2", "3"]); }

let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);

let v: Vec<&str> = "1abc2abc3".matches(|c: char| c.is_numeric()).collect();
assert_eq!(v, ["1", "2", "3"]);

fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>

Unstable

: method got recently added

An iterator over the matches of a pattern within self, yielded in reverse order.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.

For iterating from the front, matches() can be used.

Examples

#![feature(collections)] fn main() { let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect(); assert_eq!(v, ["abc", "abc", "abc"]); let v: Vec<&str> = "1abc2abc3".rmatches(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["3", "2", "1"]); }

let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);

let v: Vec<&str> = "1abc2abc3".rmatches(|c: char| c.is_numeric()).collect();
assert_eq!(v, ["3", "2", "1"]);

fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> where P: Pattern<'a>

Unstable

: might have its iterator type changed

An iterator over the start and end indices of the disjoint matches of a pattern within self.

For matches of pat within self that overlap, only the indices corresponding to the first match are returned.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator will be double ended if the pattern allows a reverse search and forward/reverse search yields the same elements. This is true for, eg, char but not for &str.

If the pattern allows a reverse search but its results might differ from a forward search, rmatch_indices() can be used.

Examples

#![feature(collections)] fn main() { let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); assert_eq!(v, [(0, 3), (6, 9), (12, 15)]); let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); assert_eq!(v, [(1, 4), (4, 7)]); let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); assert_eq!(v, [(0, 3)]); // only the first `aba` }

let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, 3), (6, 9), (12, 15)]);

let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, 4), (4, 7)]);

let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, 3)]); // only the first `aba`

fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>

Unstable

: might have its iterator type changed

An iterator over the start and end indices of the disjoint matches of a pattern within self, yielded in reverse order.

For matches of pat within self that overlap, only the indices corresponding to the last match are returned.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.

For iterating from the front, match_indices() can be used.

Examples

#![feature(collections)] fn main() { let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".rmatch_indices("abc").collect(); assert_eq!(v, [(12, 15), (6, 9), (0, 3)]); let v: Vec<(usize, usize)> = "1abcabc2".rmatch_indices("abc").collect(); assert_eq!(v, [(4, 7), (1, 4)]); let v: Vec<(usize, usize)> = "ababa".rmatch_indices("aba").collect(); assert_eq!(v, [(2, 5)]); // only the last `aba` }

let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, 15), (6, 9), (0, 3)]);

let v: Vec<(usize, usize)> = "1abcabc2".rmatch_indices("abc").collect();
assert_eq!(v, [(4, 7), (1, 4)]);

let v: Vec<(usize, usize)> = "ababa".rmatch_indices("aba").collect();
assert_eq!(v, [(2, 5)]); // only the last `aba`

fn lines(&self) -> Lines

An iterator over the lines of a string, separated by \n.

This does not include the empty string after a trailing \n.

Examples

fn main() { let four_lines = "foo\nbar\n\nbaz"; let v: Vec<&str> = four_lines.lines().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }

let four_lines = "foo\nbar\n\nbaz";
let v: Vec<&str> = four_lines.lines().collect();

assert_eq!(v, ["foo", "bar", "", "baz"]);

Leaving off the trailing character:

fn main() { let four_lines = "foo\nbar\n\nbaz\n"; let v: Vec<&str> = four_lines.lines().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }

let four_lines = "foo\nbar\n\nbaz\n";
let v: Vec<&str> = four_lines.lines().collect();

assert_eq!(v, ["foo", "bar", "", "baz"]);

fn lines_any(&self) -> LinesAny

An iterator over the lines of a string, separated by either \n or \r\n.

As with .lines(), this does not include an empty trailing line.

Examples

fn main() { let four_lines = "foo\r\nbar\n\r\nbaz"; let v: Vec<&str> = four_lines.lines_any().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }

let four_lines = "foo\r\nbar\n\r\nbaz";
let v: Vec<&str> = four_lines.lines_any().collect();

assert_eq!(v, ["foo", "bar", "", "baz"]);

Leaving off the trailing character:

fn main() { let four_lines = "foo\r\nbar\n\r\nbaz\n"; let v: Vec<&str> = four_lines.lines_any().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }

let four_lines = "foo\r\nbar\n\r\nbaz\n";
let v: Vec<&str> = four_lines.lines_any().collect();

assert_eq!(v, ["foo", "bar", "", "baz"]);

fn slice_chars(&self, begin: usize, end: usize) -> &str

Unstable

: may have yet to prove its worth

Returns a slice of the string from the character range [begin..end).

That is, start at the begin-th code point of the string and continue to the end-th code point. This does not detect or handle edge cases such as leaving a combining character as the first code point of the string.

Due to the design of UTF-8, this operation is O(end). Use slicing syntax if you want to use byte indices rather than codepoint indices.

Panics

Panics if begin > end or the either begin or end are beyond the last character of the string.

Examples

#![feature(collections)] fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.slice_chars(0, 4), "Löwe"); assert_eq!(s.slice_chars(5, 7), "老虎"); }

let s = "Löwe 老虎 Léopard";

assert_eq!(s.slice_chars(0, 4), "Löwe");
assert_eq!(s.slice_chars(5, 7), "老虎");

unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str

Takes a bytewise slice from a string.

Returns the substring from [begin..end).

Unsafety

Caller must check both UTF-8 character boundaries and the boundaries of the entire slice as well.

Examples

fn main() { let s = "Löwe 老虎 Léopard"; unsafe { assert_eq!(s.slice_unchecked(0, 21), "Löwe 老虎 Léopard"); } }

let s = "Löwe 老虎 Léopard";

unsafe {
    assert_eq!(s.slice_unchecked(0, 21), "Löwe 老虎 Léopard");
}

fn starts_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>

Returns true if the given &str is a prefix of the string.

Examples

fn main() { assert!("banana".starts_with("ba")); }

assert!("banana".starts_with("ba"));

fn ends_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>

Returns true if the given &str is a suffix of the string.

Examples

fn main() { assert!("banana".ends_with("nana")); }

assert!("banana".ends_with("nana"));

fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, P::Searcher: DoubleEndedSearcher<'a>

Returns a string with all pre- and suffixes that match a pattern repeatedly removed.

The pattern can be a simple char, or a closure that determines the split.

Examples

Simple patterns:

fn main() { assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_matches(x), "foo1bar"); }

assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");

More complex patterns with closures:

fn main() { assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar"); }

assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar");

fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>

Returns a string with all prefixes that match a pattern repeatedly removed.

The pattern can be a simple &str, char, or a closure that determines the split.

Examples

Simple patterns:

fn main() { assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12"); }

assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");

More complex patterns with closures:

fn main() { assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123"); }

assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123");

fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>

Returns a string with all suffixes that match a pattern repeatedly removed.

The pattern can be a simple &str, char, or a closure that determines the split.

Examples

Simple patterns:

fn main() { assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar"); }

assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");

More complex patterns with closures:

fn main() { assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar"); }

assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar");

fn is_char_boundary(&self, index: usize) -> bool

Unstable

: it is unclear whether this method pulls its weight with the existence of the char_indices iterator or this method may want to be replaced with checked slicing

Checks that index-th byte lies at the start and/or end of a UTF-8 code point sequence.

The start and end of the string (when index == self.len()) are considered to be boundaries.

Panics

Panics if index is greater than self.len().

Examples

#![feature(str_char)] fn main() { let s = "Löwe 老虎 Léopard"; assert!(s.is_char_boundary(0)); // start of `老` assert!(s.is_char_boundary(6)); assert!(s.is_char_boundary(s.len())); // second byte of `ö` assert!(!s.is_char_boundary(2)); // third byte of `老` assert!(!s.is_char_boundary(8)); }

let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// second byte of `ö`
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));

fn char_range_at(&self, start: usize) -> CharRange

Unstable

: often replaced by char_indices, this method may be removed in favor of just char_at() or eventually removed altogether

Given a byte position, return the next char and its index.

This can be used to iterate over the Unicode characters of a string.

Panics

If i is greater than or equal to the length of the string. If i is not the index of the beginning of a valid UTF-8 character.

Examples

This example manually iterates through the characters of a string; this should normally be done by .chars() or .char_indices().

#![feature(str_char, core)] fn main() { use std::str::CharRange; let s = "中华Việt Nam"; let mut i = 0; while i < s.len() { let CharRange {ch, next} = s.char_range_at(i); println!("{}: {}", i, ch); i = next; } }

use std::str::CharRange;

let s = "中华Việt Nam";
let mut i = 0;
while i < s.len() {
    let CharRange {ch, next} = s.char_range_at(i);
    println!("{}: {}", i, ch);
    i = next;
}

This outputs:

0: 中
3: 华
6: V
7: i
8: ệ
11: t
12:
13: N
14: a
15: m

fn char_range_at_reverse(&self, start: usize) -> CharRange

Unstable

: often replaced by char_indices, this method may be removed in favor of just char_at_reverse() or eventually removed altogether

Given a byte position, return the previous char and its position.

This function can be used to iterate over a Unicode string in reverse.

Returns 0 for next index if called on start index 0.

Panics

If i is greater than the length of the string. If i is not an index following a valid UTF-8 character.

Examples

This example manually iterates through the characters of a string; this should normally be done by .chars().rev() or .char_indices().

#![feature(str_char, core)] fn main() { use std::str::CharRange; let s = "中华Việt Nam"; let mut i = s.len(); while i > 0 { let CharRange {ch, next} = s.char_range_at_reverse(i); println!("{}: {}", i, ch); i = next; } }

use std::str::CharRange;

let s = "中华Việt Nam";
let mut i = s.len();
while i > 0 {
    let CharRange {ch, next} = s.char_range_at_reverse(i);
    println!("{}: {}", i, ch);
    i = next;
}

This outputs:

16: m
15: a
14: N
13:
12: t
11: ệ
8: i
7: V
6: 华
3: 中

fn char_at(&self, i: usize) -> char

Unstable

: frequently replaced by the chars() iterator, this method may be removed or possibly renamed in the future; it is normally replaced by chars/char_indices iterators or by getting the first char from a subslice

Given a byte position, return the char at that position.

Panics

If i is greater than or equal to the length of the string. If i is not the index of the beginning of a valid UTF-8 character.

Examples

#![feature(str_char)] fn main() { let s = "abπc"; assert_eq!(s.char_at(1), 'b'); assert_eq!(s.char_at(2), 'π'); }

let s = "abπc";
assert_eq!(s.char_at(1), 'b');
assert_eq!(s.char_at(2), 'π');

fn char_at_reverse(&self, i: usize) -> char

Unstable

: see char_at for more details, but reverse semantics are also somewhat unclear, especially with which cases generate panics

Given a byte position, return the char at that position, counting from the end.

Panics

If i is greater than the length of the string. If i is not an index following a valid UTF-8 character.

Examples

#![feature(str_char)] fn main() { let s = "abπc"; assert_eq!(s.char_at_reverse(1), 'a'); assert_eq!(s.char_at_reverse(2), 'b'); }

let s = "abπc";
assert_eq!(s.char_at_reverse(1), 'a');
assert_eq!(s.char_at_reverse(2), 'b');

fn as_bytes(&self) -> &[u8]

Converts self to a byte slice.

Examples

fn main() { assert_eq!("bors".as_bytes(), b"bors"); }

assert_eq!("bors".as_bytes(), b"bors");

fn find<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>

Returns the byte index of the first character of self that matches the pattern, if it exists.

Returns None if it doesn't exist.

The pattern can be a simple &str, char, or a closure that determines the split.

Examples

Simple patterns:

fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.find('L'), Some(0)); assert_eq!(s.find('é'), Some(14)); assert_eq!(s.find("Léopard"), Some(13)); }

let s = "Löwe 老虎 Léopard";

assert_eq!(s.find('L'), Some(0));
assert_eq!(s.find('é'), Some(14));
assert_eq!(s.find("Léopard"), Some(13));

More complex patterns with closures:

fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.find(|c: char| c.is_whitespace()), Some(5)); assert_eq!(s.find(char::is_lowercase), Some(1)); }

let s = "Löwe 老虎 Léopard";

assert_eq!(s.find(|c: char| c.is_whitespace()), Some(5));
assert_eq!(s.find(char::is_lowercase), Some(1));

Not finding the pattern:

fn main() { let s = "Löwe 老虎 Léopard"; let x: &[_] = &['1', '2']; assert_eq!(s.find(x), None); }

let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];

assert_eq!(s.find(x), None);

fn rfind<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>

Returns the byte index of the last character of self that matches the pattern, if it exists.

Returns None if it doesn't exist.

The pattern can be a simple &str, char, or a closure that determines the split.

Examples

Simple patterns:

fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.rfind('L'), Some(13)); assert_eq!(s.rfind('é'), Some(14)); }

let s = "Löwe 老虎 Léopard";

assert_eq!(s.rfind('L'), Some(13));
assert_eq!(s.rfind('é'), Some(14));

More complex patterns with closures:

fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.rfind(|c: char| c.is_whitespace()), Some(12)); assert_eq!(s.rfind(char::is_lowercase), Some(20)); }

let s = "Löwe 老虎 Léopard";

assert_eq!(s.rfind(|c: char| c.is_whitespace()), Some(12));
assert_eq!(s.rfind(char::is_lowercase), Some(20));

Not finding the pattern:

fn main() { let s = "Löwe 老虎 Léopard"; let x: &[_] = &['1', '2']; assert_eq!(s.rfind(x), None); }

let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];

assert_eq!(s.rfind(x), None);

fn slice_shift_char(&self) -> Option<(char, &str)>

Unstable

: awaiting conventions about shifting and slices and may not be warranted with the existence of the chars and/or char_indices iterators

Retrieves the first character from a &str and returns it.

This does not allocate a new string; instead, it returns a slice that points one character beyond the character that was shifted.

If the slice does not contain any characters, None is returned instead.

Examples

#![feature(str_char)] fn main() { let s = "Löwe 老虎 Léopard"; let (c, s1) = s.slice_shift_char().unwrap(); assert_eq!(c, 'L'); assert_eq!(s1, "öwe 老虎 Léopard"); let (c, s2) = s1.slice_shift_char().unwrap(); assert_eq!(c, 'ö'); assert_eq!(s2, "we 老虎 Léopard"); }

let s = "Löwe 老虎 Léopard";
let (c, s1) = s.slice_shift_char().unwrap();

assert_eq!(c, 'L');
assert_eq!(s1, "öwe 老虎 Léopard");

let (c, s2) = s1.slice_shift_char().unwrap();

assert_eq!(c, 'ö');
assert_eq!(s2, "we 老虎 Léopard");

fn subslice_offset(&self, inner: &str) -> usize

Unstable

: awaiting convention about comparability of arbitrary slices

Returns the byte offset of an inner slice relative to an enclosing outer slice.

Panics

Panics if inner is not a direct slice contained within self.

Examples

#![feature(collections)] fn main() { let string = "a\nb\nc"; let lines: Vec<&str> = string.lines().collect(); assert!(string.subslice_offset(lines[0]) == 0); // &"a" assert!(string.subslice_offset(lines[1]) == 2); // &"b" assert!(string.subslice_offset(lines[2]) == 4); // &"c" }

let string = "a\nb\nc";
let lines: Vec<&str> = string.lines().collect();

assert!(string.subslice_offset(lines[0]) == 0); // &"a"
assert!(string.subslice_offset(lines[1]) == 2); // &"b"
assert!(string.subslice_offset(lines[2]) == 4); // &"c"

fn as_ptr(&self) -> *const u8

Returns an unsafe pointer to the &str's buffer.

The caller must ensure that the string outlives this pointer, and that it is not reallocated (e.g. by pushing to the string).

Examples

fn main() { let s = "Hello"; let p = s.as_ptr(); }

let s = "Hello";
let p = s.as_ptr();

fn utf16_units(&self) -> Utf16Units

Unstable

: this functionality may only be provided by libunicode

Returns an iterator of u16 over the string encoded as UTF-16.

fn len(&self) -> usize

Returns the length of self in bytes.

Examples

fn main() { assert_eq!("foo".len(), 3); assert_eq!("ƒoo".len(), 4); // fancy f! }

assert_eq!("foo".len(), 3);
assert_eq!("ƒoo".len(), 4); // fancy f!

fn is_empty(&self) -> bool

Returns true if this slice has a length of zero bytes.

Examples

fn main() { assert!("".is_empty()); }

assert!("".is_empty());

fn parse<F>(&self) -> Result<F, F::Err> where F: FromStr

Parses self into the specified type.

Failure

Will return Err if it's not possible to parse self into the type.

Example

fn main() { assert_eq!("4".parse::<u32>(), Ok(4)); }

assert_eq!("4".parse::<u32>(), Ok(4));

Failing:

fn main() { assert!("j".parse::<u32>().is_err()); }

assert!("j".parse::<u32>().is_err());

fn graphemes(&self, is_extended: bool) -> Graphemes

Deprecated since 1.0.0

: use the crates.io unicode-segmentation library instead

Returns an iterator over the grapheme clusters of self.

If is_extended is true, the iterator is over the extended grapheme clusters; otherwise, the iterator is over the legacy grapheme clusters. UAX#29 recommends extended grapheme cluster boundaries for general processing.

Examples

#![feature(unicode, core)] fn main() { let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>(); let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"]; assert_eq!(&gr1[..], b); let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>(); let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; assert_eq!(&gr2[..], b); }

let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>();
let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"];

assert_eq!(&gr1[..], b);

let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>();
let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"];

assert_eq!(&gr2[..], b);

fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices

Deprecated since 1.0.0

: use the crates.io unicode-segmentation library instead

Returns an iterator over the grapheme clusters of self and their byte offsets. See graphemes() for more information.

Examples

#![feature(unicode, core)] fn main() { let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>(); let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; assert_eq!(&gr_inds[..], b); }

let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>();
let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];

assert_eq!(&gr_inds[..], b);

fn words(&self) -> SplitWhitespace

Deprecated since 1.1.0

: words() will be removed. Use split_whitespace() instead

An iterator over the non-empty substrings of self which contain no whitespace, and which are separated by any amount of whitespace.

Examples

#![feature(str_words)] fn main() { #![allow(deprecated)] let some_words = " Mary had\ta little \n\t lamb"; let v: Vec<&str> = some_words.words().collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); }

let some_words = " Mary   had\ta little  \n\t lamb";
let v: Vec<&str> = some_words.words().collect();

assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

fn split_whitespace(&self) -> SplitWhitespace

An iterator over the non-empty substrings of self which contain no whitespace, and which are separated by any amount of whitespace.

Examples

fn main() { let some_words = " Mary had\ta little \n\t lamb"; let v: Vec<&str> = some_words.split_whitespace().collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); }

let some_words = " Mary   had\ta little  \n\t lamb";
let v: Vec<&str> = some_words.split_whitespace().collect();

assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

fn width(&self, is_cjk: bool) -> usize

Deprecated since 1.0.0

: use the crates.io unicode-width library instead

Returns a string's displayed width in columns.

Control characters have zero width.

is_cjk determines behavior for characters in the Ambiguous category: if is_cjk is true, these are 2 columns wide; otherwise, they are 1. In CJK locales, is_cjk should be true, else it should be false. Unicode Standard Annex #11 recommends that these characters be treated as 1 column (i.e., is_cjk = false) if the locale is unknown.

fn trim(&self) -> &str

Returns a &str with leading and trailing whitespace removed.

Examples

fn main() { let s = " Hello\tworld\t"; assert_eq!(s.trim(), "Hello\tworld"); }

let s = " Hello\tworld\t";
assert_eq!(s.trim(), "Hello\tworld");

fn trim_left(&self) -> &str

Returns a &str with leading whitespace removed.

Examples

fn main() { let s = " Hello\tworld\t"; assert_eq!(s.trim_left(), "Hello\tworld\t"); }

let s = " Hello\tworld\t";
assert_eq!(s.trim_left(), "Hello\tworld\t");

fn trim_right(&self) -> &str

Returns a &str with trailing whitespace removed.

Examples

fn main() { let s = " Hello\tworld\t"; assert_eq!(s.trim_right(), " Hello\tworld"); }

let s = " Hello\tworld\t";
assert_eq!(s.trim_right(), " Hello\tworld");

fn to_lowercase(&self) -> String

Unstable

Returns the lowercase equivalent of this string.

Examples

#![feature(collections)] fn main() { let s = "HELLO"; assert_eq!(s.to_lowercase(), "hello"); }

#![feature(collections)]

let s = "HELLO";
assert_eq!(s.to_lowercase(), "hello");

fn to_uppercase(&self) -> String

Unstable

Returns the uppercase equivalent of this string.

Examples

#![feature(collections)] fn main() { let s = "hello"; assert_eq!(s.to_uppercase(), "HELLO"); }

#![feature(collections)]

let s = "hello";
assert_eq!(s.to_uppercase(), "HELLO");

Trait Implementations

impl AsRef<str> for str

fn as_ref(&self) -> &str

impl Repr<Slice<u8>> for str

fn repr(&self) -> T

impl<'a, 'b> Pattern<'a> for &'b str

Non-allocating substring search.

Will handle the pattern "" as returning empty matches at each utf8 boundary.

type Searcher = StrSearcher<'a, 'b>

fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>

fn is_contained_in(self, haystack: &'a str) -> bool

fn is_prefix_of(self, haystack: &'a str) -> bool

fn is_suffix_of(self, haystack: &'a str) -> bool where Self::Searcher: ReverseSearcher<'a>

impl Ord for str

fn cmp(&self, other: &str) -> Ordering

impl PartialEq<str> for str

fn eq(&self, other: &str) -> bool

fn ne(&self, other: &str) -> bool

impl Eq for str

impl PartialOrd<str> for str

fn partial_cmp(&self, other: &str) -> Option<Ordering>

fn lt(&self, other: &Rhs) -> bool

fn le(&self, other: &Rhs) -> bool

fn gt(&self, other: &Rhs) -> bool

fn ge(&self, other: &Rhs) -> bool

impl Index<Range<usize>> for str

Returns a slice of the given string from the byte range [begin..end).

This operation is O(1).

Panics when begin and end do not point to valid characters or point beyond the last character of the string.

Examples

fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(&s[0 .. 1], "L"); assert_eq!(&s[1 .. 9], "öwe 老"); // these will panic: // byte 2 lies within `ö`: // &s[2 ..3]; // byte 8 lies within `老` // &s[1 .. 8]; // byte 100 is outside the string // &s[3 .. 100]; }

let s = "Löwe 老虎 Léopard";
assert_eq!(&s[0 .. 1], "L");

assert_eq!(&s[1 .. 9], "öwe 老");

// these will panic:
// byte 2 lies within `ö`:
// &s[2 ..3];

// byte 8 lies within `老`
// &s[1 .. 8];

// byte 100 is outside the string
// &s[3 .. 100];

type Output = str

fn index(&self, index: Range<usize>) -> &str

impl Index<RangeTo<usize>> for str

Returns a slice of the string from the beginning to byte end.

Equivalent to self[0 .. end].

Panics when end does not point to a valid character, or is out of bounds.

type Output = str

fn index(&self, index: RangeTo<usize>) -> &str

impl Index<RangeFrom<usize>> for str

Returns a slice of the string from begin to its end.

Equivalent to self[begin .. self.len()].

Panics when begin does not point to a valid character, or is out of bounds.

type Output = str

fn index(&self, index: RangeFrom<usize>) -> &str

impl Index<RangeFull> for str

type Output = str

fn index(&self, _index: RangeFull) -> &str

impl AsRef<[u8]> for str

fn as_ref(&self) -> &[u8]

impl<'a> Default for &'a str

fn default() -> &'a str

impl Hash for str

fn hash<H>(&self, state: &mut H) where H: Hasher

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

impl Debug for str

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl Display for str

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl ToOwned for str

type Owned = String

fn to_owned(&self) -> String

impl<'a> PartialEq<String> for str

fn eq(&self, other: &String) -> bool

fn ne(&self, other: &String) -> bool

impl<'a> PartialEq<String> for &'a str

fn eq(&self, other: &String) -> bool

fn ne(&self, other: &String) -> bool

impl<'a> PartialEq<Cow<'a, str>> for str

fn eq(&self, other: &Cow<'a, str>) -> bool

fn ne(&self, other: &Cow<'a, str>) -> bool

impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str

fn eq(&self, other: &Cow<'a, str>) -> bool

fn ne(&self, other: &Cow<'a, str>) -> bool

impl<'a> IntoCow<'a, str> for &'a str

fn into_cow(self) -> Cow<'a, str>

impl UnicodeStr for str

fn graphemes(&self, is_extended: bool) -> Graphemes

fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices

fn words(&self) -> SplitWhitespace

fn split_whitespace(&self) -> SplitWhitespace

fn is_whitespace(&self) -> bool

fn is_alphanumeric(&self) -> bool

fn width(&self, is_cjk: bool) -> usize

fn trim(&self) -> &str

fn trim_left(&self) -> &str

fn trim_right(&self) -> &str

impl AsciiExt for str

type Owned = String

fn is_ascii(&self) -> bool

fn to_ascii_uppercase(&self) -> String

fn to_ascii_lowercase(&self) -> String

fn eq_ignore_ascii_case(&self, other: &str) -> bool

fn make_ascii_uppercase(&mut self)

fn make_ascii_lowercase(&mut self)

impl PartialEq<OsString> for str

fn eq(&self, other: &OsString) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialEq<OsStr> for str

fn eq(&self, other: &OsStr) -> bool

fn ne(&self, other: &Rhs) -> bool

impl AsRef<OsStr> for str

fn as_ref(&self) -> &OsStr

impl ToSocketAddrs for str

type Iter = IntoIter<SocketAddr>

fn to_socket_addrs(&self) -> Result<IntoIter<SocketAddr>>

impl AsRef<Path> for str

fn as_ref(&self) -> &Path