Trait nom::lib::std::str::FromStr

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

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[−]

The associated error which can be returned from parsing.

Required methods

pub 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.

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

Implementations on Foreign Types

impl FromStr for IpAddr

[+] Show hidden undocumented items

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<IpAddr, AddrParseError>

impl FromStr for OsString

[+] Show hidden undocumented items

type Err = Infallible

pub fn from_str(s: &str) -> Result<OsString, <OsString as FromStr>::Err>

impl FromStr for Ipv6Addr

[+] Show hidden undocumented items

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError>

impl FromStr for PathBuf

[+] Show hidden undocumented items

type Err = Infallible

pub fn from_str(s: &str) -> Result<PathBuf, <PathBuf as FromStr>::Err>

impl FromStr for SocketAddr

[+] Show hidden undocumented items

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<SocketAddr, AddrParseError>

impl FromStr for Ipv4Addr

[+] Show hidden undocumented items

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError>

impl FromStr for SocketAddrV4

[+] Show hidden undocumented items

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<SocketAddrV4, AddrParseError>

impl FromStr for SocketAddrV6

[+] Show hidden undocumented items

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<SocketAddrV6, AddrParseError>

impl FromStr for NonZeroI16

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroI16, <NonZeroI16 as FromStr>::Err>

impl FromStr for NonZeroU32

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroU32, <NonZeroU32 as FromStr>::Err>

impl FromStr for u64

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<u64, ParseIntError>

impl FromStr for NonZeroI8

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroI8, <NonZeroI8 as FromStr>::Err>

impl FromStr for f32

type Err = ParseFloatError

pub 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’, ‘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 NonZeroI32

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroI32, <NonZeroI32 as FromStr>::Err>

impl FromStr for u8

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<u8, ParseIntError>

impl FromStr for NonZeroI64

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroI64, <NonZeroI64 as FromStr>::Err>

impl FromStr for NonZeroU128

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroU128, <NonZeroU128 as FromStr>::Err>

impl FromStr for NonZeroU16

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroU16, <NonZeroU16 as FromStr>::Err>

impl FromStr for u128

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<u128, ParseIntError>

impl FromStr for u16

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<u16, ParseIntError>

impl FromStr for NonZeroI128

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroI128, <NonZeroI128 as FromStr>::Err>

impl FromStr for i8

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<i8, ParseIntError>

impl FromStr for isize

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<isize, ParseIntError>

impl FromStr for bool

type Err = ParseBoolError

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

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

[+] Show hidden undocumented items

type Err = ParseCharError

pub fn from_str(s: &str) -> Result<char, <char as FromStr>::Err>

impl FromStr for NonZeroUsize

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(
    src: &str
) -> Result<NonZeroUsize, <NonZeroUsize as FromStr>::Err>

impl FromStr for NonZeroU8

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroU8, <NonZeroU8 as FromStr>::Err>

impl FromStr for i16

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<i16, ParseIntError>

impl FromStr for NonZeroU64

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroU64, <NonZeroU64 as FromStr>::Err>

impl FromStr for i32

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<i32, ParseIntError>

impl FromStr for u32

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<u32, ParseIntError>

impl FromStr for i64

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<i64, ParseIntError>

impl FromStr for usize

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<usize, ParseIntError>

impl FromStr for NonZeroIsize

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(
    src: &str
) -> Result<NonZeroIsize, <NonZeroIsize as FromStr>::Err>

impl FromStr for f64

type Err = ParseFloatError

pub 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’, ‘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 i128

[+] Show hidden undocumented items

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<i128, ParseIntError>

Implementors

impl FromStr for String

[+] Show hidden undocumented items

type Err = Infallible

pub fn from_str(s: &str) -> Result<String, <String as FromStr>::Err>

impl FromStr for NaiveDate

impl FromStr for NaiveDateTime

impl FromStr for NaiveTime

impl FromStr for DateTime<Utc>

impl FromStr for DateTime<Local>

impl FromStr for DateTime<FixedOffset>

impl FromStr for Weekday

impl FromStr for Month

impl FromStr for Block

impl FromStr for bf16

impl FromStr for f16

impl FromStr for RenameRule

impl FromStr for Level

impl FromStr for LevelFilter

impl<T> FromStr for Complex<T> where     T: FromStr + Num + Clone,

impl<T: FromStr + Clone + Integer> FromStr for Ratio<T>

impl FromStr for TokenStream

impl FromStr for Regex

impl FromStr for Regex

impl FromStr for Version

impl FromStr for VersionReq

impl FromStr for Op

impl FromStr for Number

impl FromStr for Value

impl FromStr for Value

impl FromStr for Datetime