Trait FromStr

1.0.0 · Source
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.

§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§

1.0.0 · Source

type Err

The associated error which can be returned from parsing.

Required Methods§

1.0.0 · Source

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 ForwardKind

§

impl FromStr for ClientHint

§

type Err = ClientHintParsingError

§

impl FromStr for Extension

§

impl FromStr for PerMessageDeflateIdentifier

§

impl FromStr for PseudoHeader

§

impl FromStr for DirectoryServeMode

§

impl FromStr for ElementPatchMode

§

impl FromStr for EventType

§

impl FromStr for CrossOriginKind

§

impl FromStr for ReferrerPolicy

§

impl FromStr for Host

§

impl FromStr for Interface

Source§

impl FromStr for IpNet

§

impl FromStr for ApplicationProtocol

§

impl FromStr for Addresses

§

impl FromStr for DeviceKind

§

impl FromStr for HttpAgent

§

impl FromStr for PlatformKind

§

impl FromStr for TlsAgent

§

impl FromStr for UserAgentKind

§

impl FromStr for RequestInitiator

§

impl FromStr for CidrSubnet

Obtains the CidrSubnet from the well-known addr/prefix notation.

// The "192.0.2.0/24" example from
// https://tools.ietf.org/html/rfc5280#page-42
let subnet = CidrSubnet::from_str("192.0.2.0/24").unwrap();
assert_eq!(subnet, CidrSubnet::V4([0xC0, 0x00, 0x02, 0x00], [0xFF, 0xFF, 0xFF, 0x00]));
§

type Err = ()

1.7.0 · Source§

impl FromStr for IpAddr

1.0.0 · Source§

impl FromStr for SocketAddr

Source§

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());
Source§

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());
Source§

impl FromStr for log::Level

Source§

impl FromStr for log::LevelFilter

Source§

impl FromStr for Value

1.0.0 · Source§

impl FromStr for bool

1.20.0 · Source§

impl FromStr for char

1.0.0 · Source§

impl FromStr for f16

1.0.0 · Source§

impl FromStr for f32

1.0.0 · Source§

impl FromStr for f64

1.0.0 · Source§

impl FromStr for i8

1.0.0 · Source§

impl FromStr for i16

1.0.0 · Source§

impl FromStr for i32

1.0.0 · Source§

impl FromStr for i64

1.0.0 · Source§

impl FromStr for i128

1.0.0 · Source§

impl FromStr for isize

1.0.0 · Source§

impl FromStr for u8

1.0.0 · Source§

impl FromStr for u16

1.0.0 · Source§

impl FromStr for u32

1.0.0 · Source§

impl FromStr for u64

1.0.0 · Source§

impl FromStr for u128

1.0.0 · Source§

impl FromStr for usize

§

impl FromStr for rama::http::dep::http::uri::Authority

§

impl FromStr for PathAndQuery

§

impl FromStr for Quality

§

type Err = Error

§

impl FromStr for ContentType

§

type Err = Error

§

impl FromStr for ETag

§

type Err = InvalidETag

§

impl FromStr for LastEventId

§

type Err = InvalidLastEventId

Source§

impl FromStr for Mime

§

impl FromStr for Referer

§

type Err = InvalidReferer

§

impl FromStr for Server

§

type Err = InvalidServer

§

impl FromStr for rama::http::headers::UserAgent

§

type Err = InvalidUserAgent

§

impl FromStr for rama::http::headers::util::HttpDate

§

impl FromStr for DnsResolveMode

§

impl FromStr for rama::http::matcher::uri::dep::regex::bytes::Regex

§

type Err = Error

§

impl FromStr for rama::http::matcher::uri::dep::regex::Regex

§

type Err = Error

§

impl FromStr for Http1HeaderName

§

impl FromStr for HeaderName

§

impl FromStr for HeaderValue

§

impl FromStr for Method

§

impl FromStr for Scheme

§

impl FromStr for StatusCode

§

impl FromStr for Uri

§

impl FromStr for rama::net::address::Authority

§

impl FromStr for Domain

§

impl FromStr for DomainAddress

§

impl FromStr for ProxyAddress

§

impl FromStr for SocketAddress

§

impl FromStr for Forwarded

§

impl FromStr for ForwardedAuthority

§

impl FromStr for ForwardedElement

§

impl FromStr for ForwardedProtocol

§

type Err = InvalidProtocolStr

§

impl FromStr for NodeId

§

impl FromStr for DeviceName

Source§

impl FromStr for Ipv4Net

Source§

impl FromStr for Ipv6Net

§

impl FromStr for Protocol

§

type Err = InvalidProtocolStr

§

impl FromStr for Basic

§

impl FromStr for Bearer

§

impl FromStr for Header<'static>

§

impl FromStr for StringFilter

§

impl FromStr for TraceState

§

type Err = TraceStateError

§

impl FromStr for rama::telemetry::tracing::level_filters::LevelFilter

§

impl FromStr for rama::telemetry::tracing::Level

§

impl FromStr for rama::ua::UserAgent

§

impl FromStr for NonEmptyString

§

impl FromStr for BmpString

§

type Err = Error

§

impl FromStr for Ia5String

§

type Err = Error

§

impl FromStr for PrintableString

§

type Err = Error

§

impl FromStr for TeletexString

§

type Err = Error

Source§

impl FromStr for BigInt

Source§

impl FromStr for BigUint

§

impl FromStr for Oid<'_>

1.0.0 · Source§

impl FromStr for String

Source§

impl FromStr for ByteString

1.85.0 · Source§

impl FromStr for CString

1.0.0 · Source§

impl FromStr for Ipv4Addr

1.0.0 · Source§

impl FromStr for Ipv6Addr

1.5.0 · Source§

impl FromStr for SocketAddrV4

1.5.0 · Source§

impl FromStr for SocketAddrV6

1.35.0 · Source§

impl FromStr for NonZero<i8>

1.35.0 · Source§

impl FromStr for NonZero<i16>

1.35.0 · Source§

impl FromStr for NonZero<i32>

1.35.0 · Source§

impl FromStr for NonZero<i64>

1.35.0 · Source§

impl FromStr for NonZero<i128>

1.35.0 · Source§

impl FromStr for NonZero<isize>

1.35.0 · Source§

impl FromStr for NonZero<u8>

1.35.0 · Source§

impl FromStr for NonZero<u16>

1.35.0 · Source§

impl FromStr for NonZero<u32>

1.35.0 · Source§

impl FromStr for NonZero<u64>

1.35.0 · Source§

impl FromStr for NonZero<u128>

1.35.0 · Source§

impl FromStr for NonZero<usize>

1.45.0 · Source§

impl FromStr for OsString

1.32.0 · Source§

impl FromStr for PathBuf

Source§

impl FromStr for 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>>()?;
Source§

impl FromStr for 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>>()?;
Source§

impl FromStr for 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>>()?;
Source§

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());
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.

§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());
Source§

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());
Source§

impl FromStr for FixedOffset

Parsing a str into a FixedOffset uses the format %z.

Source§

impl FromStr for Map<String, Value>

Source§

impl FromStr for Number

Source§

impl FromStr for Url

Parse a string as an URL, without a base URL or encoding override.

Source§

impl FromStr for Braced

Source§

impl FromStr for Hyphenated

Source§

impl FromStr for Simple

Source§

impl FromStr for Urn

Source§

impl FromStr for Uuid

§

impl FromStr for A

§

impl FromStr for AAAA

§

impl FromStr for Attribute

§

type Err = ParseError

§

impl FromStr for ClientSubnet

§

impl FromStr for DNSClass

§

type Err = ProtoError

§

impl FromStr for HttpDate

§

type Err = Error

§

impl FromStr for Key

§

type Err = ParseError

§

impl FromStr for Key

§

type Err = ParseError

§

impl FromStr for Language

§

type Err = ParseError

§

impl FromStr for LowerName

§

type Err = ProtoError

§

impl FromStr for Month

§

type Err = InvalidVariant

§

impl FromStr for Name

§

type Err = ProtoError

§

impl FromStr for ObjectIdentifier

§

type Err = ParseOidError

§

impl FromStr for Pem

§

type Err = PemError

§

impl FromStr for RecordType

§

type Err = ProtoError

§

impl FromStr for Region

§

type Err = ParseError

§

impl FromStr for ScopedIp

§

type Err = AddrParseError

§

impl FromStr for Script

§

type Err = ParseError

§

impl FromStr for SmolStr

§

impl FromStr for SubdivisionId

§

type Err = ParseError

§

impl FromStr for SubdivisionSuffix

§

type Err = ParseError

§

impl FromStr for Subtag

§

type Err = ParseError

§

impl FromStr for Subtag

§

type Err = ParseError

§

impl FromStr for SvcParamKey

§

type Err = ProtoError

§

impl FromStr for Targets

§

type Err = ParseError

§

impl FromStr for UriTemplateString

§

type Err = Error

§

impl FromStr for Variant

§

type Err = ParseError

§

impl FromStr for Weekday

§

type Err = InvalidVariant

§

impl<S> FromStr for Ascii<S>
where S: FromStr,

§

type Err = <S as FromStr>::Err

§

impl<S> FromStr for RiAbsoluteString<S>
where S: Spec,

§

type Err = Error

§

impl<S> FromStr for RiFragmentString<S>
where S: Spec,

§

type Err = Error

§

impl<S> FromStr for RiQueryString<S>
where S: Spec,

§

type Err = Error

§

impl<S> FromStr for RiReferenceString<S>
where S: Spec,

§

type Err = Error

§

impl<S> FromStr for RiRelativeString<S>
where S: Spec,

§

type Err = Error

§

impl<S> FromStr for RiString<S>
where S: Spec,

§

type Err = Error

§

impl<S> FromStr for UniCase<S>
where S: FromStr + AsRef<str>,

§

type Err = <S as FromStr>::Err

§

impl<T> FromStr for QualityValue<T>
where T: FromStr,

§

type Err = Error

§

impl<const MIN: i8, const MAX: i8> FromStr for RangedI8<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: i16, const MAX: i16> FromStr for RangedI16<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: i32, const MAX: i32> FromStr for RangedI32<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: i64, const MAX: i64> FromStr for RangedI64<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: i128, const MAX: i128> FromStr for RangedI128<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: isize, const MAX: isize> FromStr for RangedIsize<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: u8, const MAX: u8> FromStr for RangedU8<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: u16, const MAX: u16> FromStr for RangedU16<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: u32, const MAX: u32> FromStr for RangedU32<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: u64, const MAX: u64> FromStr for RangedU64<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: u128, const MAX: u128> FromStr for RangedU128<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: usize, const MAX: usize> FromStr for RangedUsize<MIN, MAX>

§

type Err = ParseIntError

§

impl<const N: usize> FromStr for TinyAsciiStr<N>

§

type Err = ParseError