alloc::str::FromStr - Rust
Description: API documentation for the Rust `FromStr` trait in crate `alloc`.
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>;
    }

A trait to abstract the idea of creating a new instance of a type from a string.

`FromStr`'s `from_str` method is often used implicitly, through `str`'s `parse` method. See `parse`'s documentation for examples.

# 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

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

## Implementors

- `impl FromStr for isize type Err = ParseIntError;` | [src]

- `impl FromStr for i8 type Err = ParseIntError;` | [src]

- `impl FromStr for i16 type Err = ParseIntError;` | [src]

- `impl FromStr for f64 type Err = ParseFloatError;` | [src]

- `impl FromStr for usize type Err = ParseIntError;` | [src]

- `impl FromStr for i32 type Err = ParseIntError;` | [src]

- `impl FromStr for u16 type Err = ParseIntError;` | [src]

- `impl FromStr for f32 type Err = ParseFloatError;` | [src]

- `impl FromStr for char type Err = ParseCharError;` | [src]

- `impl FromStr for u128 type Err = ParseIntError;` | [src]

- `impl FromStr for i64 type Err = ParseIntError;` | [src]

- `impl FromStr for u64 type Err = ParseIntError;` | [src]

- `impl FromStr for i128 type Err = ParseIntError;` | [src]

- `impl FromStr for u8 type Err = ParseIntError;` | [src]

- `impl FromStr for u32 type Err = ParseIntError;` | [src]

- `impl FromStr for bool type Err = ParseBoolError;` | [src]

- `impl FromStr for String type Err = ParseError;` | [src]

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)