pub trait FromStr: Sized {
type Err;
// Required method
fn from_str(s: &str) -> Result<Self, Self::Err>;
}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.
§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§
Source§impl FromStr for IntegratorMethod
impl FromStr for IntegratorMethod
type Err = PropagationError
1.0.0 · Source§impl FromStr for SocketAddr
impl FromStr for SocketAddr
type Err = AddrParseError
Source§impl FromStr for chrono::month::Month
Parsing a str into a Month uses the format %B.
impl FromStr for chrono::month::Month
Parsing a str into a Month uses the format %B.
§Example
use chrono::Month;
assert_eq!("January".parse::<Month>(), Ok(Month::January));
assert!("any day".parse::<Month>().is_err());The parsing is case-insensitive.
assert_eq!("fEbruARy".parse::<Month>(), Ok(Month::February));Only the shortest form (e.g. jan) and the longest form (e.g. january) is accepted.
assert!("septem".parse::<Month>().is_err());
assert!("Augustin".parse::<Month>().is_err());type Err = ParseMonthError
Source§impl FromStr for chrono::weekday::Weekday
Parsing a str into a Weekday uses the format %A.
impl FromStr for chrono::weekday::Weekday
Parsing a str into a Weekday uses the format %A.
§Example
use chrono::Weekday;
assert_eq!("Sunday".parse::<Weekday>(), Ok(Weekday::Sun));
assert!("any day".parse::<Weekday>().is_err());The parsing is case-insensitive.
assert_eq!("mON".parse::<Weekday>(), Ok(Weekday::Mon));Only the shortest form (e.g. sun) and the longest form (e.g. sunday) is accepted.
assert!("thurs".parse::<Weekday>().is_err());type Err = ParseWeekdayError
Source§impl FromStr for log::LevelFilter
impl FromStr for log::LevelFilter
type Err = ParseLevelError
§impl FromStr for MetaAlmanac
impl FromStr for MetaAlmanac
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
Source§impl FromStr for chrono::datetime::DateTime<FixedOffset>
Accepts a relaxed form of RFC3339.
A space or a ‘T’ are accepted as the separator between the date and time
parts. Additional spaces are allowed between each component.
impl FromStr for chrono::datetime::DateTime<FixedOffset>
Accepts a relaxed form of RFC3339. A space or a ‘T’ are accepted as the separator between the date and time parts. Additional spaces are allowed between each component.
All of these examples are equivalent:
"2012-12-12T12:12:12Z".parse::<DateTime<FixedOffset>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<FixedOffset>>()?;
"2012- 12-12T12: 12:12Z".parse::<DateTime<FixedOffset>>()?;type Err = ParseError
Source§impl FromStr for chrono::datetime::DateTime<Local>
Accepts a relaxed form of RFC3339.
A space or a ‘T’ are accepted as the separator between the date and time
parts.
impl FromStr for chrono::datetime::DateTime<Local>
Accepts a relaxed form of RFC3339. A space or a ‘T’ are accepted as the separator between the date and time parts.
All of these examples are equivalent:
"2012-12-12T12:12:12Z".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12+0000".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12+00:00".parse::<DateTime<Local>>()?;type Err = ParseError
Source§impl FromStr for chrono::datetime::DateTime<Utc>
Accepts a relaxed form of RFC3339.
A space or a ‘T’ are accepted as the separator between the date and time
parts.
impl FromStr for chrono::datetime::DateTime<Utc>
Accepts a relaxed form of RFC3339. A space or a ‘T’ are accepted as the separator between the date and time parts.
All of these examples are equivalent:
"2012-12-12T12:12:12Z".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12+0000".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12+00:00".parse::<DateTime<Utc>>()?;type Err = ParseError
Source§impl FromStr for NaiveDate
Parsing a str into a NaiveDate uses the same format,
%Y-%m-%d, as in Debug and Display.
impl FromStr for NaiveDate
Parsing a str into a NaiveDate uses the same format,
%Y-%m-%d, as in Debug and Display.
§Example
use chrono::NaiveDate;
let d = NaiveDate::from_ymd_opt(2015, 9, 18).unwrap();
assert_eq!("2015-09-18".parse::<NaiveDate>(), Ok(d));
let d = NaiveDate::from_ymd_opt(12345, 6, 7).unwrap();
assert_eq!("+12345-6-7".parse::<NaiveDate>(), Ok(d));
assert!("foo".parse::<NaiveDate>().is_err());type Err = ParseError
Source§impl FromStr for NaiveDateTime
Parsing a str into a NaiveDateTime uses the same format,
%Y-%m-%dT%H:%M:%S%.f, as in Debug.
impl FromStr for NaiveDateTime
Parsing a str into a NaiveDateTime uses the same format,
%Y-%m-%dT%H:%M:%S%.f, as in Debug.
§Example
use chrono::{NaiveDateTime, NaiveDate};
let dt = NaiveDate::from_ymd_opt(2015, 9, 18).unwrap().and_hms_opt(23, 56, 4).unwrap();
assert_eq!("2015-09-18T23:56:04".parse::<NaiveDateTime>(), Ok(dt));
let dt = NaiveDate::from_ymd_opt(12345, 6, 7).unwrap().and_hms_milli_opt(7, 59, 59, 1_500).unwrap(); // leap second
assert_eq!("+12345-6-7T7:59:60.5".parse::<NaiveDateTime>(), Ok(dt));
assert!("foo".parse::<NaiveDateTime>().is_err());type Err = ParseError
Source§impl FromStr for NaiveTime
Parsing a str into a NaiveTime uses the same format,
%H:%M:%S%.f, as in Debug and Display.
impl FromStr for NaiveTime
Parsing a str into a NaiveTime uses the same format,
%H:%M:%S%.f, as in Debug and Display.
§Example
use chrono::NaiveTime;
let t = NaiveTime::from_hms_opt(23, 56, 4).unwrap();
assert_eq!("23:56:04".parse::<NaiveTime>(), Ok(t));
let t = NaiveTime::from_hms_nano_opt(23, 56, 4, 12_345_678).unwrap();
assert_eq!("23:56:4.012345678".parse::<NaiveTime>(), Ok(t));
let t = NaiveTime::from_hms_nano_opt(23, 59, 59, 1_234_567_890).unwrap(); // leap second
assert_eq!("23:59:60.23456789".parse::<NaiveTime>(), Ok(t));
// Seconds are optional
let t = NaiveTime::from_hms_opt(23, 56, 0).unwrap();
assert_eq!("23:56".parse::<NaiveTime>(), Ok(t));
assert!("foo".parse::<NaiveTime>().is_err());type Err = ParseError
Source§impl FromStr for FixedOffset
Parsing a str into a FixedOffset uses the format %z.
impl FromStr for FixedOffset
Parsing a str into a FixedOffset uses the format %z.
type Err = ParseError
Source§impl FromStr for http::header::name::HeaderName
impl FromStr for http::header::name::HeaderName
type Err = InvalidHeaderName
Source§impl FromStr for http::header::value::HeaderValue
impl FromStr for http::header::value::HeaderValue
type Err = InvalidHeaderValue
Source§impl FromStr for http::status::StatusCode
impl FromStr for http::status::StatusCode
type Err = InvalidStatusCode
Source§impl FromStr for http::uri::path::PathAndQuery
impl FromStr for http::uri::path::PathAndQuery
type Err = InvalidUri
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 DataType
Parses str into a DataType.
impl FromStr for DataType
Parses str into a DataType.
This is the reverse of [DataType]’s Display
impl, and maintains the invariant that
DataType::try_from(&data_type.to_string()).unwrap() == data_type
§Example
use arrow_schema::DataType;
let data_type: DataType = "Int32".parse().unwrap();
assert_eq!(data_type, DataType::Int32);§impl FromStr for IntervalUnit
Logic for parsing interval unit strings
impl FromStr for IntervalUnit
Logic for parsing interval unit strings
See https://github.com/postgres/postgres/blob/2caa85f4aae689e6f6721d7363b4c66a2a6417d6/src/backend/utils/adt/datetime.c#L189 for a list of unit names supported by PostgreSQL which we try to match here.