pub trait FromStr {
type Err;
fn from_str(s: &str) -> Result<Self, Self::Err>;
}
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.
Basic implementation of FromStr on an example Point type:
use std::str::FromStr;
use std::num::ParseIntError;
#[derive(Debug, PartialEq)]
struct Point {
x: i32,
y: i32
}
impl FromStr for Point {
type Err = ParseIntError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let coords: Vec<&str> = s.trim_matches(|p| p == '(' || p == ')' )
.split(',')
.collect();
let x_fromstr = coords[0].parse::<i32>()?;
let y_fromstr = coords[1].parse::<i32>()?;
Ok(Point { x: x_fromstr, y: y_fromstr })
}
}
let p = Point::from_str("(1,2)");
assert_eq!(p.unwrap(), Point{ x: 1, y: 2} )type ErrThe associated error which can be returned from parsing.
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 implementation of the trait.
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);
impl FromStr for IpAddr[src]
type Err = AddrParseErrorfn from_str(s: &str) -> Result<IpAddr, AddrParseError>[src]
impl FromStr for SocketAddr[src]
type Err = AddrParseErrorfn from_str(s: &str) -> Result<SocketAddr, AddrParseError>[src]
impl FromStr for bool[src]
type Err = ParseBoolErrorfn from_str(s: &str) -> Result<bool, ParseBoolError>[src]
Parse a bool from a string.
Yields a Result<bool, ParseBoolError>, because s may or may not actually be parseable.
use std::str::FromStr;
assert_eq!(FromStr::from_str("true"), Ok(true));
assert_eq!(FromStr::from_str("false"), Ok(false));
assert!(<bool as FromStr>::from_str("not even a boolean").is_err());Note, in many cases, the .parse() method on str is more proper.
assert_eq!("true".parse(), Ok(true));
assert_eq!("false".parse(), Ok(false));
assert!("not even a boolean".parse::<bool>().is_err());impl FromStr for char[src]
impl FromStr for f32[src]
type Err = ParseFloatErrorfn from_str(src: &str) -> Result<f32, ParseFloatError>[src]
Converts a string in base 10 to a float. Accepts an optional decimal exponent.
This function accepts strings such as
Leading and trailing whitespace represent an error.
All strings that adhere to the following EBNF grammar will result in an Ok being returned:
Float ::= Sign? ( 'inf' | 'NaN' | Number )
Number ::= ( Digit+ |
Digit+ '.' Digit* |
Digit* '.' Digit+ ) Exp?
Exp ::= [eE] Sign? Digit+
Sign ::= [+-]
Digit ::= [0-9]
In some situations, some strings that should create a valid float instead return an error. See issue #31407 for details.
Err(ParseFloatError) if the string did not represent a valid number. Otherwise, Ok(n) where n is the floating-point number represented by src.
impl FromStr for f64[src]
type Err = ParseFloatErrorfn from_str(src: &str) -> Result<f64, ParseFloatError>[src]
Converts a string in base 10 to a float. Accepts an optional decimal exponent.
This function accepts strings such as
Leading and trailing whitespace represent an error.
All strings that adhere to the following EBNF grammar will result in an Ok being returned:
Float ::= Sign? ( 'inf' | 'NaN' | Number )
Number ::= ( Digit+ |
Digit+ '.' Digit* |
Digit* '.' Digit+ ) Exp?
Exp ::= [eE] Sign? Digit+
Sign ::= [+-]
Digit ::= [0-9]
In some situations, some strings that should create a valid float instead return an error. See issue #31407 for details.
Err(ParseFloatError) if the string did not represent a valid number. Otherwise, Ok(n) where n is the floating-point number represented by src.
impl FromStr for i8[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<i8, ParseIntError>[src]
impl FromStr for i16[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<i16, ParseIntError>[src]
impl FromStr for i32[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<i32, ParseIntError>[src]
impl FromStr for i64[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<i64, ParseIntError>[src]
impl FromStr for i128[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<i128, ParseIntError>[src]
impl FromStr for isize[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<isize, ParseIntError>[src]
impl FromStr for u8[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<u8, ParseIntError>[src]
impl FromStr for u16[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<u16, ParseIntError>[src]
impl FromStr for u32[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<u32, ParseIntError>[src]
impl FromStr for u64[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<u64, ParseIntError>[src]
impl FromStr for u128[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<u128, ParseIntError>[src]
impl FromStr for usize[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<usize, ParseIntError>[src]
impl FromStr for OsString[src]
impl FromStr for Ipv4Addr[src]
type Err = AddrParseErrorfn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError>[src]
impl FromStr for Ipv6Addr[src]
type Err = AddrParseErrorfn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError>[src]
impl FromStr for SocketAddrV4[src]
type Err = AddrParseErrorfn from_str(s: &str) -> Result<SocketAddrV4, AddrParseError>[src]
impl FromStr for SocketAddrV6[src]
type Err = AddrParseErrorfn from_str(s: &str) -> Result<SocketAddrV6, AddrParseError>[src]
impl FromStr for NonZeroI8[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroI8, <NonZeroI8 as FromStr>::Err>[src]
impl FromStr for NonZeroI16[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroI16, <NonZeroI16 as FromStr>::Err>[src]
impl FromStr for NonZeroI32[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroI32, <NonZeroI32 as FromStr>::Err>[src]
impl FromStr for NonZeroI64[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroI64, <NonZeroI64 as FromStr>::Err>[src]
impl FromStr for NonZeroI128[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroI128, <NonZeroI128 as FromStr>::Err>[src]
impl FromStr for NonZeroIsize[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroIsize, <NonZeroIsize as FromStr>::Err>[src]
impl FromStr for NonZeroU8[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroU8, <NonZeroU8 as FromStr>::Err>[src]
impl FromStr for NonZeroU16[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroU16, <NonZeroU16 as FromStr>::Err>[src]
impl FromStr for NonZeroU32[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroU32, <NonZeroU32 as FromStr>::Err>[src]
impl FromStr for NonZeroU64[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroU64, <NonZeroU64 as FromStr>::Err>[src]
impl FromStr for NonZeroU128[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroU128, <NonZeroU128 as FromStr>::Err>[src]
impl FromStr for NonZeroUsize[src]
type Err = ParseIntErrorfn from_str(src: &str) -> Result<NonZeroUsize, <NonZeroUsize as FromStr>::Err>[src]
impl FromStr for PathBuf[src]
impl FromStr for String[src]
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/str/trait.FromStr.html