pub trait FromStr: Sized {
type Err;
// Required method
fn from_str(s: &str) -> Result<Self, Self::Err>;
}wayland and Linux only.Expand description
Parse a value from a string
FromStr’s from_str method is often used implicitly, through
str’s parse method. See parse’s documentation for examples.
FromStr does not have a lifetime parameter, and so you can only parse types
that do not contain a lifetime parameter themselves. In other words, you can
parse an i32 with FromStr, but not a &i32. You can parse a struct that
contains an i32, but not one that contains an &i32.
§Input format and round-tripping
The input format expected by a type’s FromStr implementation depends on the type. Check the
type’s documentation for the input formats it knows how to parse. Note that the input format of
a type’s FromStr implementation might not necessarily accept the output format of its
Display implementation, and even if it does, the Display implementation may not be lossless
so the round-trip may lose information.
However, if a type has a lossless Display implementation whose output is meant to be
conveniently machine-parseable and not just meant for human consumption, then the type may wish
to accept the same format in FromStr, and document that usage. Having both Display and
FromStr implementations where the result of Display cannot be parsed with FromStr may
surprise users.
§Examples
Basic implementation of FromStr on an example Point type:
use std::str::FromStr;
#[derive(Debug, PartialEq)]
struct Point {
x: i32,
y: i32
}
#[derive(Debug, PartialEq, Eq)]
struct ParsePointError;
impl FromStr for Point {
type Err = ParsePointError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let (x, y) = s
.strip_prefix('(')
.and_then(|s| s.strip_suffix(')'))
.and_then(|s| s.split_once(','))
.ok_or(ParsePointError)?;
let x_fromstr = x.parse::<i32>().map_err(|_| ParsePointError)?;
let y_fromstr = y.parse::<i32>().map_err(|_| ParsePointError)?;
Ok(Point { x: x_fromstr, y: y_fromstr })
}
}
let expected = Ok(Point { x: 1, y: 2 });
// Explicit call
assert_eq!(Point::from_str("(1,2)"), expected);
// Implicit calls, through parse
assert_eq!("(1,2)".parse(), expected);
assert_eq!("(1,2)".parse::<Point>(), expected);
// Invalid input string
assert!(Point::from_str("(1 2)").is_err());Required Associated Types§
Required Methods§
1.0.0 · Sourcefn from_str(s: &str) -> Result<Self, Self::Err>
fn from_str(s: &str) -> Result<Self, Self::Err>
Parses a string s to return a value of this type.
If parsing succeeds, return the value inside Ok, otherwise
when the string is ill-formatted return an error specific to the
inside Err. The error type is specific to the implementation of the trait.
§Examples
Basic usage with i32, a type that implements FromStr:
use std::str::FromStr;
let s = "5";
let x = i32::from_str(s).unwrap();
assert_eq!(5, x);Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.
Implementors§
§impl FromStr for CursorIcon
impl FromStr for CursorIcon
type Err = ParseError
1.0.0 · Source§impl FromStr for SocketAddr
impl FromStr for SocketAddr
type Err = AddrParseError
Source§impl FromStr for log::LevelFilter
impl FromStr for log::LevelFilter
type Err = ParseLevelError
Source§impl FromStr for ByteString
impl FromStr for ByteString
type Err = Infallible
1.5.0 · Source§impl FromStr for SocketAddrV4
impl FromStr for SocketAddrV4
type Err = AddrParseError
1.5.0 · Source§impl FromStr for SocketAddrV6
impl FromStr for SocketAddrV6
type Err = AddrParseError
1.54.0 · Source§impl FromStr for proc_macro::Literal
Parse a single literal from its stringified representation.
impl FromStr for proc_macro::Literal
Parse a single literal from its stringified representation.
In order to parse successfully, the input string must not contain anything but the literal token. Specifically, it must not contain whitespace or comments in addition to the literal.
The resulting literal token will have a Span::call_site() span.
NOTE: some errors may cause panics instead of returning LexError. We
reserve the right to change these errors into LexErrors later.
1.15.0 · Source§impl FromStr for proc_macro::TokenStream
Attempts to break the string into tokens and parse those tokens into a token stream.
May fail for a number of reasons, for example, if the string contains unbalanced delimiters
or characters not existing in the language.
All tokens in the parsed stream get Span::call_site() spans.
impl FromStr for proc_macro::TokenStream
Attempts to break the string into tokens and parse those tokens into a token stream.
May fail for a number of reasons, for example, if the string contains unbalanced delimiters
or characters not existing in the language.
All tokens in the parsed stream get Span::call_site() spans.
NOTE: some errors may cause panics instead of returning LexError. We reserve the right to
change these errors into LexErrors later.
Source§impl FromStr for proc_macro2::TokenStream
Attempts to break the string into tokens and parse those tokens into a token
stream.
impl FromStr for proc_macro2::TokenStream
Attempts to break the string into tokens and parse those tokens into a token stream.
May fail for a number of reasons, for example, if the string contains unbalanced delimiters or characters not existing in the language.
NOTE: Some errors may cause panics instead of returning LexError. We
reserve the right to change these errors into LexErrors later.
Source§impl FromStr for Url
Parse a string as an URL, without a base URL or encoding override.
impl FromStr for Url
Parse a string as an URL, without a base URL or encoding override.
type Err = ParseError
§impl FromStr for FluentNumber
impl FromStr for FluentNumber
type Err = ParseFloatError
§impl FromStr for State
impl FromStr for State
type Err = Infallible
§impl FromStr for Zoned
Parses a zoned timestamp from the Temporal datetime format.
impl FromStr for Zoned
Parses a zoned timestamp from the Temporal datetime format.
See the fmt::temporal for more information on
the precise format.
Note that this is only enabled when the std feature
is enabled because it requires access to a global
TimeZoneDatabase.