Trait sp_std::str::FromStr1.0.0[][src]

pub trait FromStr {
    type Err;
    pub 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.

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} )

Associated Types

type Err[src]

The associated error which can be returned from parsing.

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);
Loading content...

Implementations on Foreign Types

impl FromStr for SocketAddr[src]

impl FromStr for OsString[src]

impl FromStr for IpAddr[src]

impl FromStr for SocketAddrV4[src]

impl FromStr for PathBuf[src]

impl FromStr for Ipv6Addr[src]

impl FromStr for Ipv4Addr[src]

impl FromStr for SocketAddrV6[src]

impl FromStr for i64[src]

impl FromStr for u64[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 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());

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 = 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 u16[src]

impl FromStr for u32[src]

impl FromStr for i16[src]

impl FromStr for i8[src]

impl FromStr for i128[src]

impl FromStr for i32[src]

impl FromStr for usize[src]

impl FromStr for u128[src]

impl FromStr for u8[src]

impl FromStr for isize[src]

impl FromStr for String[src]

Loading content...

Implementors

impl FromStr for NonZeroI81.35.0[src]

impl FromStr for NonZeroI161.35.0[src]

impl FromStr for NonZeroI321.35.0[src]

impl FromStr for NonZeroI641.35.0[src]

impl FromStr for NonZeroI1281.35.0[src]

impl FromStr for NonZeroIsize1.35.0[src]

impl FromStr for NonZeroU81.35.0[src]

impl FromStr for NonZeroU161.35.0[src]

impl FromStr for NonZeroU321.35.0[src]

impl FromStr for NonZeroU641.35.0[src]

impl FromStr for NonZeroU1281.35.0[src]

impl FromStr for NonZeroUsize1.35.0[src]

Loading content...