Trait alloc::str::FromStr 1.0.0[−][src]
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; 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} )Run
Associated Types
Loading content...Required methods
pub fn from_str(s: &str) -> Result<Self, Self::Err>[src]
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.
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);Run
Implementations on Foreign Types
impl FromStr for NonZeroU8[src]
impl FromStr for NonZeroU8[src]impl FromStr for NonZeroU32[src]
impl FromStr for NonZeroU32[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<NonZeroU32, <NonZeroU32 as FromStr>::Err>[src]
impl FromStr for NonZeroU16[src]
impl FromStr for NonZeroU16[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<NonZeroU16, <NonZeroU16 as FromStr>::Err>[src]
impl FromStr for NonZeroI64[src]
impl FromStr for NonZeroI64[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<NonZeroI64, <NonZeroI64 as FromStr>::Err>[src]
impl FromStr for NonZeroU128[src]
impl FromStr for NonZeroU128[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<NonZeroU128, <NonZeroU128 as FromStr>::Err>[src]
impl FromStr for NonZeroUsize[src]
impl FromStr for NonZeroUsize[src]type Err = ParseIntError
pub fn from_str(
src: &str
) -> Result<NonZeroUsize, <NonZeroUsize as FromStr>::Err>[src]
src: &str
) -> Result<NonZeroUsize, <NonZeroUsize as FromStr>::Err>
impl FromStr for NonZeroI16[src]
impl FromStr for NonZeroI16[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<NonZeroI16, <NonZeroI16 as FromStr>::Err>[src]
impl FromStr for NonZeroI128[src]
impl FromStr for NonZeroI128[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<NonZeroI128, <NonZeroI128 as FromStr>::Err>[src]
impl FromStr for NonZeroI32[src]
impl FromStr for NonZeroI32[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<NonZeroI32, <NonZeroI32 as FromStr>::Err>[src]
impl FromStr for NonZeroI8[src]
impl FromStr for NonZeroI8[src]impl FromStr for NonZeroU64[src]
impl FromStr for NonZeroU64[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<NonZeroU64, <NonZeroU64 as FromStr>::Err>[src]
impl FromStr for NonZeroIsize[src]
impl FromStr for NonZeroIsize[src]type Err = ParseIntError
pub fn from_str(
src: &str
) -> Result<NonZeroIsize, <NonZeroIsize as FromStr>::Err>[src]
src: &str
) -> Result<NonZeroIsize, <NonZeroIsize as FromStr>::Err>
Implementors
impl FromStr for bool[src]
impl FromStr for bool[src]type Err = ParseBoolError
pub fn 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.
Examples
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());Run
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());Run
impl FromStr for f32[src]
impl FromStr for f32[src]type Err = ParseFloatError
pub fn 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
- ‘3.14’
- ‘-3.14’
- ‘2.5E10’, or equivalently, ‘2.5e10’
- ‘2.5E-10’
- ‘5.’
- ‘.5’, or, equivalently, ‘0.5’
- ‘inf’, ‘-inf’, ‘NaN’
Leading and trailing whitespace represent an error.
Grammar
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]
Known bugs
In some situations, some strings that should create a valid float instead return an error. See issue #31407 for details.
Arguments
- src - A string
Return value
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]
impl FromStr for f64[src]type Err = ParseFloatError
pub fn 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
- ‘3.14’
- ‘-3.14’
- ‘2.5E10’, or equivalently, ‘2.5e10’
- ‘2.5E-10’
- ‘5.’
- ‘.5’, or, equivalently, ‘0.5’
- ‘inf’, ‘-inf’, ‘NaN’
Leading and trailing whitespace represent an error.
Grammar
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]
Known bugs
In some situations, some strings that should create a valid float instead return an error. See issue #31407 for details.
Arguments
- src - A string
Return value
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]
impl FromStr for i8[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<i8, ParseIntError>[src]
impl FromStr for i16[src]
impl FromStr for i16[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<i16, ParseIntError>[src]
impl FromStr for i32[src]
impl FromStr for i32[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<i32, ParseIntError>[src]
impl FromStr for i64[src]
impl FromStr for i64[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<i64, ParseIntError>[src]
impl FromStr for i128[src]
impl FromStr for i128[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<i128, ParseIntError>[src]
impl FromStr for isize[src]
impl FromStr for isize[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<isize, ParseIntError>[src]
impl FromStr for u8[src]
impl FromStr for u8[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<u8, ParseIntError>[src]
impl FromStr for u16[src]
impl FromStr for u16[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<u16, ParseIntError>[src]
impl FromStr for u32[src]
impl FromStr for u32[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<u32, ParseIntError>[src]
impl FromStr for u64[src]
impl FromStr for u64[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<u64, ParseIntError>[src]
impl FromStr for u128[src]
impl FromStr for u128[src]type Err = ParseIntError
pub fn from_str(src: &str) -> Result<u128, ParseIntError>[src]
impl FromStr for usize[src]
impl FromStr for usize[src]