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;
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} )
RunAssociated Types
Required methods
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);
RunImplementations on Foreign Types
sourceimpl FromStr for u64
impl FromStr for u64
type Err = ParseIntError
fn from_str(src: &str) -> Result<u64, ParseIntError>
sourceimpl FromStr for bool
impl FromStr for bool
sourcefn from_str(s: &str) -> Result<bool, ParseBoolError>
fn from_str(s: &str) -> Result<bool, ParseBoolError>
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());
RunNote, 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());
Runtype Err = ParseBoolError
1.35.0 · sourceimpl FromStr for NonZeroI64
impl FromStr for NonZeroI64
type Err = ParseIntError
fn from_str(src: &str) -> Result<NonZeroI64, <NonZeroI64 as FromStr>::Err>
sourceimpl FromStr for u32
impl FromStr for u32
type Err = ParseIntError
fn from_str(src: &str) -> Result<u32, ParseIntError>
sourceimpl FromStr for i16
impl FromStr for i16
type Err = ParseIntError
fn from_str(src: &str) -> Result<i16, ParseIntError>
1.35.0 · sourceimpl FromStr for NonZeroI16
impl FromStr for NonZeroI16
type Err = ParseIntError
fn from_str(src: &str) -> Result<NonZeroI16, <NonZeroI16 as FromStr>::Err>
1.35.0 · sourceimpl FromStr for NonZeroIsize
impl FromStr for NonZeroIsize
type Err = ParseIntError
fn from_str(src: &str) -> Result<NonZeroIsize, <NonZeroIsize as FromStr>::Err>
1.35.0 · sourceimpl FromStr for NonZeroU64
impl FromStr for NonZeroU64
type Err = ParseIntError
fn from_str(src: &str) -> Result<NonZeroU64, <NonZeroU64 as FromStr>::Err>
sourceimpl FromStr for u8
impl FromStr for u8
type Err = ParseIntError
fn from_str(src: &str) -> Result<u8, ParseIntError>
1.35.0 · sourceimpl FromStr for NonZeroUsize
impl FromStr for NonZeroUsize
type Err = ParseIntError
fn from_str(src: &str) -> Result<NonZeroUsize, <NonZeroUsize as FromStr>::Err>
sourceimpl FromStr for u16
impl FromStr for u16
type Err = ParseIntError
fn from_str(src: &str) -> Result<u16, ParseIntError>
sourceimpl FromStr for f32
impl FromStr for f32
sourcefn from_str(src: &str) -> Result<f32, ParseFloatError>
fn from_str(src: &str) -> Result<f32, ParseFloatError>
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’, ‘+infinity’, ‘NaN’
Note that alphabetical characters are not case-sensitive.
Leading and trailing whitespace represent an error.
Grammar
All strings that adhere to the following EBNF grammar when
lowercased will result in an Ok
being returned:
Float ::= Sign? ( 'inf' | 'infinity' | 'nan' | Number )
Number ::= ( Digit+ |
'.' Digit* |
Digit+ '.' Digit* |
Digit* '.' Digit+ ) Exp?
Exp ::= 'e' Sign? Digit+
Sign ::= [+-]
Digit ::= [0-9]
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
.
type Err = ParseFloatError
sourceimpl FromStr for i32
impl FromStr for i32
type Err = ParseIntError
fn from_str(src: &str) -> Result<i32, ParseIntError>
1.35.0 · sourceimpl FromStr for NonZeroI32
impl FromStr for NonZeroI32
type Err = ParseIntError
fn from_str(src: &str) -> Result<NonZeroI32, <NonZeroI32 as FromStr>::Err>
sourceimpl FromStr for i8
impl FromStr for i8
type Err = ParseIntError
fn from_str(src: &str) -> Result<i8, ParseIntError>
1.35.0 · sourceimpl FromStr for NonZeroU16
impl FromStr for NonZeroU16
type Err = ParseIntError
fn from_str(src: &str) -> Result<NonZeroU16, <NonZeroU16 as FromStr>::Err>
1.35.0 · sourceimpl FromStr for NonZeroU128
impl FromStr for NonZeroU128
type Err = ParseIntError
fn from_str(src: &str) -> Result<NonZeroU128, <NonZeroU128 as FromStr>::Err>
sourceimpl FromStr for u128
impl FromStr for u128
type Err = ParseIntError
fn from_str(src: &str) -> Result<u128, ParseIntError>
sourceimpl FromStr for isize
impl FromStr for isize
type Err = ParseIntError
fn from_str(src: &str) -> Result<isize, ParseIntError>
sourceimpl FromStr for usize
impl FromStr for usize
type Err = ParseIntError
fn from_str(src: &str) -> Result<usize, ParseIntError>
1.35.0 · sourceimpl FromStr for NonZeroI128
impl FromStr for NonZeroI128
type Err = ParseIntError
fn from_str(src: &str) -> Result<NonZeroI128, <NonZeroI128 as FromStr>::Err>
sourceimpl FromStr for f64
impl FromStr for f64
sourcefn from_str(src: &str) -> Result<f64, ParseFloatError>
fn from_str(src: &str) -> Result<f64, ParseFloatError>
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’, ‘+infinity’, ‘NaN’
Note that alphabetical characters are not case-sensitive.
Leading and trailing whitespace represent an error.
Grammar
All strings that adhere to the following EBNF grammar when
lowercased will result in an Ok
being returned:
Float ::= Sign? ( 'inf' | 'infinity' | 'nan' | Number )
Number ::= ( Digit+ |
'.' Digit* |
Digit+ '.' Digit* |
Digit* '.' Digit+ ) Exp?
Exp ::= 'e' Sign? Digit+
Sign ::= [+-]
Digit ::= [0-9]
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
.