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);
Object Safety§
Implementors§
1.0.0 · source§impl FromStr for SocketAddr
impl FromStr for SocketAddr
type Err = AddrParseError
source§impl FromStr for chrono::month::Month
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
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>
impl FromStr for chrono::datetime::DateTime<FixedOffset>
Accepts a relaxed form of RFC3339. A space or a ‘T’ are acepted 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>
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>
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
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
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
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
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
impl FromStr for Url
Parse a string as an URL, without a base URL or encoding override.
type Err = ParseError
§impl FromStr for 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);