Results

in

Utilities for the str primitive type.

std::primitive::str

String manipulation.

core::primitive::str

std::ops::RangeFull::get_unchecked

RangeFull, str ->

std::ops::RangeFull::get_unchecked_mut

RangeFull, str ->

&str -> usize

Returns the length of self.

std::string::String::from

&str -> String

Converts a &str into a String.

&str -> Bytes

Returns an iterator over the bytes of a string slice.

&str -> Chars

Returns an iterator over the chars of a string slice.

&str -> Lines

Returns an iterator over the lines of a string, as string …

Converts a string slice to a raw pointer.

&str -> bool

Checks if all characters in this string are within the …

&str -> bool

Returns true if self has a length of zero bytes.

&str -> String

str::into_string

Box<str> -> String

Converts a Box<str> into a String without copying or …

str::char_indices

&str -> CharIndices

Returns an iterator over the chars of a string slice, and …

str::encode_utf16

&str -> EncodeUtf16

Returns an iterator of u16 over the string encoded as …

str::escape_debug

&str -> EscapeDebug

Returns an iterator that escapes each char in self with …

fn::is_prefix_of

&str -> bool

std::boxed::Box::is_prefix_of

&str -> bool

std::sync::Exclusive::is_prefix_of

&str -> bool

fn::is_suffix_of

&str -> bool

std::boxed::Box::is_suffix_of

&str -> bool

std::sync::Exclusive::is_suffix_of

&str -> bool

str::to_lowercase

&str -> String

Returns the lowercase equivalent of this string slice, as …

str::to_uppercase

&str -> String

Returns the uppercase equivalent of this string slice, as …

std::ops::Range::get_unchecked

Range<usize>, str ->

std::ops::RangeFrom::get_unchecked

RangeFrom<usize>, str ->

std::ops::RangeTo::get_unchecked

RangeTo<usize>, str ->

std::ops::RangeInclusive::get_unchecked

RangeInclusive<usize>, str ->

std::ops::RangeToInclusive::get_unchecked

RangeToInclusive<usize>, str ->

std::range::Range::get_unchecked

Range<usize>, str ->

std::range::RangeInclusive::get_unchecked

RangeInclusive<usize>, str ->

std::range::RangeFrom::get_unchecked

RangeFrom<usize>, str ->

char::into_searcher

char, &str ->

str::escape_default

&str -> EscapeDefault

Returns an iterator that escapes each char in self with …

str::escape_unicode

&str -> EscapeUnicode

Returns an iterator that escapes each char in self with …

fn::is_contained_in

&str -> bool

std::boxed::Box::is_contained_in

&str -> bool

std::sync::Exclusive::is_contained_in

&str -> bool

str::split_whitespace

&str -> SplitWhitespace

Splits a string slice by whitespace.

std::ops::Range::get_unchecked_mut

Range<usize>, str ->

std::ops::RangeFrom::get_unchecked_mut

RangeFrom<usize>, str ->

std::ops::RangeTo::get_unchecked_mut

RangeTo<usize>, str ->

std::ops::RangeInclusive::get_unchecked_mut

RangeInclusive<usize>, str ->

std::ops::RangeToInclusive::get_unchecked_mut

RangeToInclusive<usize>, str ->

std::range::Range::get_unchecked_mut

Range<usize>, str ->

std::range::RangeInclusive::get_unchecked_mut

RangeInclusive<usize>, str ->

std::range::RangeFrom::get_unchecked_mut

RangeFrom<usize>, str ->

str::to_ascii_lowercase

&str -> String

Returns a copy of this string where each character is …

str::to_ascii_uppercase

&str -> String

Returns a copy of this string where each character is …

str::split_ascii_whitespace

&str -> SplitAsciiWhitespace

Splits a string slice by ASCII whitespace.

core::panicking::panic

&str -> never

The underlying implementation of core’s panic! macro …

proc_macro::Literal::string

&str -> Literal

String literal.

core::panicking::panic_nounwind

&str -> never

Like panic, but without unwinding and track_caller to …

core::panicking::panic_str_2015

&str -> never

This exists solely for the 2015 edition panic! macro to …

core::panicking::panic_nounwind_nobacktrace

&str -> never

Like panic_nounwind, but also inhibits showing a backtrace.

&str -> LinesAny

Returns an iterator over the lines of a string.

std::borrow::Cow::add

Cow<str>, &str ->

std::string::String::add

String, &str -> String

std::borrow::Cow::from

&str -> Cow<str>

Converts a string slice into a Borrowed variant. No heap …

std::boxed::Box::from

&str -> Box<str>

Converts a &str into a Box<str>

std::rc::Rc::from

&str -> Rc<str>

Allocates a reference-counted string slice and copies v …

std::sync::Arc::from

&str -> Arc<str>

Allocates a reference-counted str and copies v into it.

std::vec::Vec::from

&str -> Vec<u8>

Allocates a Vec<u8> and fills it with a UTF-8 string.

&str -> &str

Returns a string slice with leading and trailing …

std::ops::RangeFull::index

RangeFull, &str -> &

&str -> &Path

&str -> &str

Returns the same string as a string slice &str.

&str, usize -> String

Creates a new String by repeating a string n times.

std::ffi::CString::from_str

&str -> Result<CString>

Converts a string s into a CString.

&str -> Result<char>

std::bstr::ByteString::from_str

&str -> Result<ByteString>

std::string::String::from_str

&str -> Result<String>

&str -> &str

Returns a string slice with trailing whitespace removed.

str::as_mut_ptr

&mut str -> u8

Converts a mutable string slice to a raw pointer.

str::trim_ascii

&str -> &str

Returns a string slice with leading and trailing ASCII …

str::trim_start

&str -> &str

Returns a string slice with leading whitespace removed.

char::is_prefix_of

char, &str -> bool

char::is_suffix_of

char, &str -> bool

fn::into_searcher

&str -> CharPredicateSearcher<F>

std::boxed::Box::into_searcher

&str -> CharPredicateSearcher<F>

std::string::String::into_searcher

&String, &str ->

std::sync::Exclusive::into_searcher

&str -> CharPredicateSearcher<F>

str::trim_ascii_end

&str -> &str

Returns a string slice with trailing ASCII whitespace …

str::clone_to_uninit

&str, u8 -> ()

char::is_contained_in

char, &str -> bool

str::is_char_boundary

&str, usize -> bool

Checks that index-th byte is the first byte in a UTF-8 …

str::trim_ascii_start

&str -> &str

Returns a string slice with leading ASCII whitespace …

str::ceil_char_boundary

&str, usize -> usize

Finds the closest x not below index where …

str::floor_char_boundary

&str, usize -> usize

Finds the closest x not exceeding index where …

str::make_ascii_lowercase

&mut str -> ()

Converts this string to its ASCII lower case equivalent …

str::make_ascii_uppercase

&mut str -> ()

Converts this string to its ASCII upper case equivalent …

proc_macro::Ident::new

&str, Span -> Ident

Creates a new Ident with the given string as well as the …

proc_macro::Ident::new_raw

&str, Span -> Ident

Same as Ident::new, but creates a raw identifier (r#ident).

&str -> &str

Returns a string slice with leading whitespace removed.

str::trim_right

&str -> &str

Returns a string slice with trailing whitespace removed.

&str, &str -> bool

std::bstr::ByteStr::eq

&ByteStr, &str -> bool

std::bstr::ByteString::eq

&ByteString, &str -> bool

std::ffi::OsString::eq

&OsString, &str -> bool

std::ffi::OsStr::eq

&OsStr, &str -> bool

std::string::String::eq

&String, &str -> bool

&str, &String -> bool

std::string::String::ne

&String, &str -> bool

&str, &str -> Ordering

std::ops::RangeFull::get

RangeFull, &str -> Option<&>

std::boxed::Box::clone

&Box<str> -> Box<str>

std::ops::Range::index

Range<usize>, &str -> &

std::ops::RangeFrom::index

RangeFrom<usize>, &str -> &

std::ops::RangeTo::index

RangeTo<usize>, &str -> &

std::ops::RangeInclusive::index

RangeInclusive<usize>, &str -> &

std::ops::RangeToInclusive::index

RangeToInclusive<usize>, &str -> &

std::range::Range::index

Range<usize>, &str -> &

std::range::RangeInclusive::index

RangeInclusive<usize>, &str -> &

std::range::RangeFrom::index

RangeFrom<usize>, &str -> &

&str -> Result<F>

Parses this string slice into another type.

std::option::Option::expect

Option<T>, &str -> T

Returns the contained Some value, consuming the self value.

&str -> &[u8]

Converts a string slice to a byte slice. To convert the …

&str, P -> bool

Returns true if the given pattern matches a sub-slice of …

&str -> Result<bool, ParseBoolError>

Parse a bool from a string.

&str -> Result<f32, ParseFloatError>

Converts a string in base 10 to a float. Accepts an …

&str -> Result<f64, ParseFloatError>

Converts a string in base 10 to a float. Accepts an …

&str -> Result<i8, ParseIntError>

Parses an integer from a string slice with decimal digits.

&str -> Result<i16, ParseIntError>

Parses an integer from a string slice with decimal digits.

&str -> Result<i32, ParseIntError>

Parses an integer from a string slice with decimal digits.

&str -> Result<i64, ParseIntError>

Parses an integer from a string slice with decimal digits.

&str -> Result<i128, ParseIntError>

Parses an integer from a string slice with decimal digits.

&str -> Result<u8, ParseIntError>

Parses an integer from a string slice with decimal digits.

&str -> Result<u16, ParseIntError>

Parses an integer from a string slice with decimal digits.

&str -> Result<u32, ParseIntError>

Parses an integer from a string slice with decimal digits.

&str -> Result<u64, ParseIntError>

Parses an integer from a string slice with decimal digits.

&str -> Result<u128, ParseIntError>

Parses an integer from a string slice with decimal digits.

isize::from_str

&str -> Result<isize, ParseIntError>

Parses an integer from a string slice with decimal digits.

usize::from_str

&str -> Result<usize, ParseIntError>

Parses an integer from a string slice with decimal digits.

std::ffi::OsString::from_str

&str -> Result<OsString, FromStr::Err>

std::net::IpAddr::from_str

&str -> Result<IpAddr, AddrParseError>

std::net::Ipv4Addr::from_str

&str -> Result<Ipv4Addr, AddrParseError>

std::net::Ipv6Addr::from_str

&str -> Result<Ipv6Addr, AddrParseError>

std::net::SocketAddr::from_str

&str -> Result<SocketAddr, AddrParseError>

std::net::SocketAddrV4::from_str

&str -> Result<SocketAddrV4, AddrParseError>

std::net::SocketAddrV6::from_str

&str -> Result<SocketAddrV6, AddrParseError>

std::num::NonZero::from_str

&str -> Result<NonZero<i128>>

std::path::PathBuf::from_str

&str -> Result<PathBuf, FromStr::Err>

&str, P -> bool

Returns true if the given pattern matches a suffix of this …

str::starts_with

&str, P -> bool

Returns true if the given pattern matches a prefix of this …

str::is_prefix_of

&str, &str -> bool

Checks whether the pattern matches at the front of the …

array::is_prefix_of

[char], &str -> bool

std::string::String::is_prefix_of

&String, &str -> bool

str::is_suffix_of

&str, &str -> bool

Checks whether the pattern matches at the back of the …

array::is_suffix_of

[char], &str -> bool

std::string::String::is_suffix_of

&String, &str -> bool

array::into_searcher

[char], &str -> CharArraySearcher

str::into_searcher

&str, &str -> StrSearcher

str::as_utf8_pattern

&&str -> Option<Utf8Pattern>

str::is_contained_in

&str, &str -> bool

Checks whether the pattern matches anywhere in the haystack

array::is_contained_in

[char], &str -> bool

std::string::String::is_contained_in

&String, &str -> bool

fn::strip_prefix_of

&str -> Option<&str>

std::boxed::Box::strip_prefix_of

&str -> Option<&str>

std::sync::Exclusive::strip_prefix_of

&str -> Option<&str>

fn::strip_suffix_of

&str -> Option<&str>

std::boxed::Box::strip_suffix_of

&str -> Option<&str>

std::sync::Exclusive::strip_suffix_of

&str -> Option<&str>

str::to_socket_addrs

&str -> Result<IntoIter<SocketAddr>>

str::into_boxed_bytes

Box<str> -> Box<[u8]>

Converts a Box<str> into a Box<[u8]> without copying or …

str::eq_ignore_ascii_case

&str, &str -> bool

Checks that two strings are an ASCII case-insensitive …

proc_macro::TokenStream::from_str

&str -> Result<TokenStream, LexError>

proc_macro::Literal::from_str

&str -> Result<Literal, LexError>

std::borrow::Cow::eq

&Cow<str>, &str -> bool

std::borrow::Cow::ne

&Cow<str>, &str -> bool

std::ops::Range::get

Range<usize>, &str -> Option<&>

std::ops::RangeFrom::get

RangeFrom<usize>, &str -> Option<&>

std::ops::RangeTo::get

RangeTo<usize>, &str -> Option<&>

std::ops::RangeInclusive::get

RangeInclusive<usize>, &str -> Option<&>

std::ops::RangeToInclusive::get

RangeToInclusive<usize>, &str -> Option<&>

std::range::Range::get

Range<usize>, &str -> Option<&>

std::range::RangeInclusive::get

RangeInclusive<usize>, &str -> Option<&>

std::range::RangeFrom::get

RangeFrom<usize>, &str -> Option<&>

&str, P -> Option<usize>

Returns the byte index of the first character of this …

&str, I -> &

&str, P -> Option<usize>

Returns the byte index for the first character of the last …

&str, P -> Split<P>

Returns an iterator over substrings of this string slice, …

&mut str -> &mut str

&str, P -> RSplit<P>

Returns an iterator over substrings of the given string …

&str, P -> Matches<P>

Returns an iterator over the disjoint matches of a pattern …

&str -> Option<&[Char]>

If this string slice is_ascii, returns it as a slice of …

std::string::String::push_str

&mut String, &str -> ()

Appends a given string slice onto the end of this String.

&str, P -> RMatches<P>

Returns an iterator over the disjoint matches of a pattern …

std::ops::RangeFull::index_mut

RangeFull, &mut str -> &mut

std::hash::Hasher::write_str

&mut Hasher, &str -> ()

Writes a single str into this hasher.

std::ffi::OsString::write_str

&mut OsString, &str -> Result

std::hash::DefaultHasher::write_str

&mut DefaultHasher, &str -> ()

std::hash::SipHasher::write_str

&mut SipHasher, &str -> ()

std::string::String::add_assign

&mut String, &str -> ()

str::clone_into

&str, &mut String -> ()

std::string::String::extend_one

&mut String, &str -> ()

std::fmt::Formatter::debug_tuple

&mut Formatter, &str -> DebugTuple

Creates a DebugTuple builder designed to assist with …

str::partial_cmp

&str, &str -> Option<Ordering>

std::ffi::OsString::partial_cmp

&OsString, &str -> Option<Ordering>

std::ffi::OsStr::partial_cmp

&OsStr, &str -> Option<Ordering>

std::fmt::Formatter::debug_struct

&mut Formatter, &str -> DebugStruct

Creates a DebugStruct builder designed to assist with …

slice::is_prefix_of

&[char], &str -> bool

Creates an empty str

std::rc::Rc::default

Creates an empty str inside an Rc

std::sync::Arc::default

-> Arc<str>

Creates an empty str inside an Arc

std::boxed::Box::default

-> Box<str>

std::any::type_name

Returns the name of a type as a string slice.

std::intrinsics::type_name

Gets a static string slice containing the name of a type.

std::boxed::Box::from

String -> Box<str>

Converts the given String to a boxed str slice that is …

std::rc::Rc::from

String -> Rc<str>

Allocates a reference-counted string slice and copies v …

std::sync::Arc::from

String -> Arc<str>

Allocates a reference-counted str and copies v into it.

std::string::String::into_boxed_str

String -> Box<str>

Converts this String into a Box<str>.

std::panic::Location::file

&Location -> &str

Returns the name of the source file from which the panic …

std::str::Lines::last

Lines -> Option<&str>

std::str::SplitWhitespace::last

SplitWhitespace -> Option<&str>

std::str::SplitAsciiWhitespace::last

SplitAsciiWhitespace -> Option<&str>

std::string::String::leak

String -> &mut str

Consumes and leaks the String, returning a mutable …

std::string::String::deref

&String -> &str

std::str::Utf8Chunk::valid

&Utf8Chunk -> &str

Returns the next validated UTF-8 substring.

std::string::Drain::as_ref

&Drain -> &str

std::string::String::as_ref

&String -> &str

std::ascii::Char::as_str

&Char -> &str

Views this ASCII character as a one-code-unit UTF-8 str.

std::str::Chars::as_str

&Chars -> &str

Views the underlying data as a subslice of the original …

std::str::CharIndices::as_str

&CharIndices -> &str

Views the underlying data as a subslice of the original …

std::string::Drain::as_str

&Drain -> &str

Returns the remaining (sub)string of this iterator as a …

std::string::String::as_str

&String -> &str

Extracts a string slice containing the entire String.

std::string::IntoChars::as_str

&IntoChars -> &str

Views the underlying data as a subslice of the original …

std::string::String::borrow

&String -> &str

std::str::pattern::Searcher::haystack

&Searcher -> &str

Getter for the underlying string to be searched in

std::str::pattern::CharSearcher::haystack

&CharSearcher -> &str

std::str::pattern::CharArraySearcher::haystack

&CharArraySearcher -> &str

std::str::pattern::CharArrayRefSearcher::haystack

&CharArrayRefSearcher -> &str

std::str::pattern::CharSliceSearcher::haystack

&CharSliceSearcher -> &str

std::str::pattern::StrSearcher::haystack

&StrSearcher -> &str

std::array::TryFromSliceError::description

&TryFromSliceError -> &str

std::cell::BorrowError::description

&BorrowError -> &str

std::cell::BorrowMutError::description

&BorrowMutError -> &str

std::char::ParseCharError::description

&ParseCharError -> &str

std::char::CharTryFromError::description

&CharTryFromError -> &str

std::char::DecodeUtf16Error::description

&DecodeUtf16Error -> &str

std::convert::Infallible::description

&Infallible -> &str

std::env::VarError::description

&VarError -> &str

std::env::JoinPathsError::description

&JoinPathsError -> &str

std::ffi::NulError::description

&NulError -> &str

std::ffi::IntoStringError::description

&IntoStringError -> &str

std::ffi::FromBytesWithNulError::description

&FromBytesWithNulError -> &str

std::fmt::Error::description

&Error -> &str

std::io::WriterPanicked::description

&WriterPanicked -> &str

std::io::Error::description

&Error -> &str

std::net::AddrParseError::description

&AddrParseError -> &str

std::num::ParseFloatError::description

&ParseFloatError -> &str

std::num::TryFromIntError::description

&TryFromIntError -> &str

std::num::ParseIntError::description

&ParseIntError -> &str

std::path::StripPrefixError::description

&StripPrefixError -> &str

std::str::Utf8Error::description

&Utf8Error -> &str

std::str::ParseBoolError::description

&ParseBoolError -> &str

std::string::FromUtf8Error::description

&FromUtf8Error -> &str

std::string::FromUtf16Error::description

&FromUtf16Error -> &str

std::sync::mpsc::RecvError::description

&RecvError -> &str

std::sync::mpsc::TryRecvError::description

&TryRecvError -> &str

std::sync::mpsc::RecvTimeoutError::description

&RecvTimeoutError -> &str

std::time::SystemTimeError::description

&SystemTimeError -> &str

std::str::from_raw_parts

u8, usize -> &str

Creates a &str from a pointer and a length.

core::ascii::Char::as_str

&Char -> &str

Views this ASCII character as a one-code-unit UTF-8 str.

proc_macro::Diagnostic::message

&Diagnostic -> &str

Returns the message in self.

test::TestName::as_slice

&TestName -> &str

std::error::Error::description

&Error -> &str

std::thread::Thread::name

&Thread -> Option<&str>

Gets the thread’s name.

&[Char] -> &str

Views this slice of ASCII characters as a UTF-8 str.

std::fmt::Arguments::as_str

&Arguments -> Option<&str>

Gets the formatted string, if it has no arguments to be …

std::ffi::OsStr::to_str

&OsStr -> Option<&str>

Yields a &str slice if the OsStr is valid Unicode.

std::path::Path::to_str

&Path -> Option<&str>

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

&ByteStr -> Result<&str>

std::str::Lines::remainder

&Lines -> Option<&str>

Returns the remaining lines of the split string.

std::str::SplitWhitespace::remainder

&SplitWhitespace -> Option<&str>

Returns remainder of the split string

std::str::SplitAsciiWhitespace::remainder

&SplitAsciiWhitespace -> Option<&str>

Returns remainder of the split string.

std::sync::PoisonError::description

&PoisonError<T> -> &str

std::sync::TryLockError::description

&TryLockError<T> -> &str

std::sync::mpsc::SendError::description

&SendError<T> -> &str

std::sync::mpsc::TrySendError::description

&TrySendError<T> -> &str

std::panic::PanicHookInfo::payload_as_str

&PanicHookInfo -> Option<&str>

Returns the payload associated with the panic, if it is a …

std::any::type_name_of_val

Returns the type name of the pointed-to value as a string …

std::str::from_raw_parts_mut

u8, usize -> &mut str

Creates a &mut str from a pointer and a length.

std::str::from_utf8_unchecked

&[u8] -> &str

Converts a slice of bytes to a string slice without …

str::from_utf8_unchecked

&[u8] -> &str

Converts a slice of bytes to a string slice without …

std::fmt::Arguments::as_statically_known_str

&Arguments -> Option<&str>

Same as Arguments::as_str, but will only return Some(s) if …

std::str::from_boxed_utf8_unchecked

Box<[u8]> -> Box<str>

Converts a boxed slice of bytes to a boxed string slice …

core::panic::PanicMessage::as_str

&PanicMessage -> Option<&str>

Gets the formatted message, if it has no arguments to be …

test::TestDesc::test_mode

&TestDesc -> Option<&str>

Returns None for ignored test or tests that are just run, …

std::str::Lines::next

&mut Lines -> Option<&str>

std::str::LinesAny::next

&mut LinesAny -> Option<&str>

std::str::SplitWhitespace::next

&mut SplitWhitespace -> Option<&str>

std::str::SplitAsciiWhitespace::next

&mut SplitAsciiWhitespace -> Option<&str>

std::string::String::as_mut

&mut String -> &mut str

std::ffi::CStr::to_str

&CStr -> Result<&str, Utf8Error>

Yields a &str slice if the CStr contains valid UTF-8.

std::string::String::deref_mut

&mut String -> &mut str

std::boxed::Box::from_iter

T -> Box<str>

std::str::Lines::next_back

&mut Lines -> Option<&str>

std::str::LinesAny::next_back

&mut LinesAny -> Option<&str>

std::str::SplitWhitespace::next_back

&mut SplitWhitespace -> Option<&str>

std::str::SplitAsciiWhitespace::next_back

&mut SplitAsciiWhitespace -> Option<&str>

std::string::String::as_mut_str

&mut String -> &mut str

Converts a String into a mutable string slice.

std::string::String::borrow_mut

&mut String -> &mut str

std::boxed::Box::description

&Box<E> -> &str

std::str::from_utf8

&[u8] -> Result<&str, Utf8Error>

Converts a slice of bytes to a string slice.

&[u8] -> Result<&str, Utf8Error>

Converts a slice of bytes to a string slice.

std::str::SplitInclusive::remainder

&SplitInclusive<P> -> Option<&str>

Returns remainder of the split string.

std::str::Split::remainder

&Split<P> -> Option<&str>

Returns remainder of the split string.

std::str::RSplit::remainder

&RSplit<P> -> Option<&str>

Returns remainder of the split string.

std::str::SplitTerminator::remainder

&SplitTerminator<P> -> Option<&str>

Returns remainder of the split string.

std::str::RSplitTerminator::remainder

&RSplitTerminator<P> -> Option<&str>

Returns remainder of the split string.

std::str::SplitN::remainder

&SplitN<P> -> Option<&str>

Returns remainder of the split string.

std::str::RSplitN::remainder

&RSplitN<P> -> Option<&str>

Returns remainder of the split string.

std::io::IntoInnerError::description

&IntoInnerError<W> -> &str

std::sync::Arc::description

&Arc<T> -> &str

std::str::from_utf8_unchecked_mut

&mut [u8] -> &mut str

Converts a slice of bytes to a string slice without …

str::from_utf8_unchecked_mut

&mut [u8] -> &mut str

Converts a slice of bytes to a string slice without …

std::str::SplitInclusive::next

&mut SplitInclusive<P> -> Option<&str>

std::str::Split::next

&mut Split<P> -> Option<&str>

std::str::RSplit::next

&mut RSplit<P> -> Option<&str>

std::str::SplitTerminator::next

&mut SplitTerminator<P> -> Option<&str>

std::str::RSplitTerminator::next

&mut RSplitTerminator<P> -> Option<&str>

std::str::SplitN::next

&mut SplitN<P> -> Option<&str>

std::str::RSplitN::next

&mut RSplitN<P> -> Option<&str>

std::str::Matches::next

&mut Matches<P> -> Option<&str>

std::str::RMatches::next

&mut RMatches<P> -> Option<&str>

std::str::SplitInclusive::next_back

&mut SplitInclusive<P> -> Option<&str>

std::str::Split::next_back

&mut Split<P> -> Option<&str>

std::str::RSplit::next_back

&mut RSplit<P> -> Option<&str>

std::str::SplitTerminator::next_back

&mut SplitTerminator<P> -> Option<&str>

std::str::RSplitTerminator::next_back

&mut RSplitTerminator<P> -> Option<&str>

std::str::Matches::next_back

&mut Matches<P> -> Option<&str>

std::str::RMatches::next_back

&mut RMatches<P> -> Option<&str>

std::collections::hash_map::OccupiedError::description

&OccupiedError<K, V> -> &str

char::encode_utf8

char, &mut [u8] -> &mut str

Encodes this character as UTF-8 into the provided byte …

std::str::pattern::CharPredicateSearcher::haystack

&CharPredicateSearcher<F> -> &str

std::collections::btree_map::OccupiedError::description

&OccupiedError<K, V> -> &str

std::str::from_utf8_mut

&mut [u8] -> Result<&mut str, Utf8Error>

Converts a mutable slice of bytes to a mutable string …

str::from_utf8_mut

&mut [u8] -> Result<&mut str, Utf8Error>

Converts a mutable slice of bytes to a mutable string …

std::str::MatchIndices::next

&mut MatchIndices<P> -> Option<(usize, &str)>

std::str::RMatchIndices::next

&mut RMatchIndices<P> -> Option<(usize, &str)>

std::str::MatchIndices::next_back

&mut MatchIndices<P> -> Option<(usize, &str)>

std::str::RMatchIndices::next_back

&mut RMatchIndices<P> -> Option<(usize, &str)>

&str -> &str

Returns a string slice with leading and trailing …

&str -> &str

&str -> &str

Returns the same string as a string slice &str.

&str -> &str

Returns a string slice with trailing whitespace removed.

str::trim_ascii

&str -> &str

Returns a string slice with leading and trailing ASCII …

str::trim_start

&str -> &str

Returns a string slice with leading whitespace removed.

str::trim_ascii_end

&str -> &str

Returns a string slice with trailing ASCII whitespace …

str::trim_ascii_start

&str -> &str

Returns a string slice with leading ASCII whitespace …

&str -> &str

Returns a string slice with leading whitespace removed.

str::trim_right

&str -> &str

Returns a string slice with trailing whitespace removed.

std::boxed::Box::clone

&Box<str> -> Box<str>

fn::strip_prefix_of

&str -> Option<&str>

std::boxed::Box::strip_prefix_of

&str -> Option<&str>

std::sync::Exclusive::strip_prefix_of

&str -> Option<&str>

fn::strip_suffix_of

&str -> Option<&str>

std::boxed::Box::strip_suffix_of

&str -> Option<&str>

std::sync::Exclusive::strip_suffix_of

&str -> Option<&str>

&mut str -> &mut str

str::trim_matches

&str, P -> &str

Returns a string slice with all prefixes and suffixes that …

char::strip_prefix_of

char, &str -> Option<&str>

char::strip_suffix_of

char, &str -> Option<&str>

str::trim_end_matches

&str, P -> &str

Returns a string slice with all suffixes that match a …

str::trim_start_matches

&str, P -> &str

Returns a string slice with all prefixes that match a …

str::slice_unchecked

&str, usize, usize -> &str

Creates a string slice from another string slice, …

str::trim_left_matches

&str, P -> &str

Returns a string slice with all prefixes that match a …

str::trim_right_matches

&str, P -> &str

Returns a string slice with all suffixes that match a …

str::strip_prefix

&str, P -> Option<&str>

Returns a string slice with the prefix removed.

str::strip_suffix

&str, P -> Option<&str>

Returns a string slice with the suffix removed.

tuple::get_unchecked

(Bound<usize>, Bound<usize>), str -> str

str::strip_prefix_of

&str, &str -> Option<&str>

Removes the pattern from the front of haystack, if it …

array::strip_prefix_of

[char], &str -> Option<&str>

std::string::String::strip_prefix_of

&String, &str -> Option<&str>

str::strip_suffix_of

&str, &str -> Option<&str>

Removes the pattern from the back of haystack, if it …

array::strip_suffix_of

[char], &str -> Option<&str>

std::string::String::strip_suffix_of

&String, &str -> Option<&str>

tuple::get_unchecked_mut

(Bound<usize>, Bound<usize>), str -> str

&str, usize -> (&str, &str)

Divides one string slice into two at an index.

slice::strip_prefix_of

&[char], &str -> Option<&str>

slice::strip_suffix_of

&[char], &str -> Option<&str>

str::slice_mut_unchecked

&mut str, usize, usize -> &mut str

Creates a string slice from another string slice, …

(Bound<usize>, Bound<usize>), &str -> &str

std::str::pattern::Pattern::strip_prefix_of

Pattern, &str -> Option<&str>

Removes the pattern from the front of haystack, if it …

std::str::pattern::Pattern::strip_suffix_of

Pattern, &str -> Option<&str>

Removes the pattern from the back of haystack, if it …

str::split_at_checked

&str, usize -> Option<(&str, &str)>

Divides one string slice into two at an index.

(Bound<usize>, Bound<usize>), &str -> Option<&str>

str::split_once

&str, P -> Option<(&str, &str)>

Splits the string on the first occurrence of the specified …

str::rsplit_once

&str, P -> Option<(&str, &str)>

Splits the string on the last occurrence of the specified …

tuple::index_mut

(Bound<usize>, Bound<usize>), &mut str -> &mut str

str::split_at_mut

&mut str, usize -> (&mut str, &mut str)

Divides one mutable string slice into two at an index.

(Bound<usize>, Bound<usize>), &mut str -> Option<&mut str>

str::split_at_mut_checked

&mut str, usize -> Option<(&mut str, &mut str)>

Divides one mutable string slice into two at an index.