FromStr in alloc::str - Rust
Description: Parse a value from a string
Keywords: rust, rustlang, rust-lang, FromStr

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

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

Run

## Associated Types

[src]

#### type Err

The associated error which can be returned from parsing.

## Required methods

[src]

#### 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

## Implementations on Foreign Types

1.35.0[src]

### impl FromStr for NonZeroUsize

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroI32

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroI64

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroU16

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroI16

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroU128

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroIsize

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroI128

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroI8

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroU8

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroU64

#### type Err = ParseIntError

[src]

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

1.35.0[src]

### impl FromStr for NonZeroU32

#### type Err = ParseIntError

[src]

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

## Implementors

[src]

### impl FromStr for String

#### type Err = Infallible

[src]

### impl FromStr for bool

#### type Err = ParseBoolError

1.20.0[src]

### impl FromStr for char

#### type Err = ParseCharError

[src]

### impl FromStr for f32

#### type Err = ParseFloatError

[src]

### impl FromStr for f64

#### type Err = ParseFloatError

[src]

### impl FromStr for i8

#### type Err = ParseIntError

[src]

### impl FromStr for i16

#### type Err = ParseIntError

[src]

### impl FromStr for i32

#### type Err = ParseIntError

[src]

### impl FromStr for i64

#### type Err = ParseIntError

[src]

### impl FromStr for i128

#### type Err = ParseIntError

[src]

### impl FromStr for isize

#### type Err = ParseIntError

[src]

### impl FromStr for u8

#### type Err = ParseIntError

[src]

### impl FromStr for u16

#### type Err = ParseIntError

[src]

### impl FromStr for u32

#### type Err = ParseIntError

[src]

### impl FromStr for u64

#### type Err = ParseIntError

[src]

### impl FromStr for u128

#### type Err = ParseIntError

[src]

### impl FromStr for usize

#### type Err = ParseIntError