# 1.0.0[−][src]Trait core::str::FromStr

    pub trait FromStr: Sized {
        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`.

# 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

### `type Err`

The associated error which can be returned from parsing.

Loading content...

## Required methods

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

Run
Loading content...

## Implementors

### `impl FromStr for NonZeroI128`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroI16`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroI32`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroI64`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroI8`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroIsize`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroU128`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroU16`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroU32`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroU64`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroU8`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for NonZeroUsize`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for bool`[src]

#### `type Err = ParseBoolError`

#### `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 char`[src]

#### `type Err = ParseCharError`

#### `fn from_str(s: &str) -> Result<Self, Self::Err>`[src]

### `impl FromStr for f32`[src]

#### `type Err = ParseFloatError`

#### `fn from_str(src: &str) -> Result<Self, 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]

#### `type Err = ParseFloatError`

#### `fn from_str(src: &str) -> Result<Self, 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]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for i16`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for i32`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for i64`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for i128`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for isize`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for u8`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for u16`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for u32`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for u64`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for u128`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

### `impl FromStr for usize`[src]

#### `type Err = ParseIntError`

#### `fn from_str(src: &str) -> Result<Self, ParseIntError>`[src]

Loading content...