Trait Num

pub trait Num:
    PartialEq
    + Zero
    + One
    + NumOps {
    type FromStrRadixErr;

    // Required method
    fn from_str_radix(
        str: &str,
        radix: u32,
    ) -> Result<Self, Self::FromStrRadixErr>;
}

The base trait for numeric types, covering 0 and 1 values, comparisons, basic numeric operations, and string conversion.

Required Associated Types

type FromStrRadixErr

Required Methods

fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

Examples

use num_traits::Num;

let result = <i32 as Num>::from_str_radix("27", 10);
assert_eq!(result, Ok(27));

let result = <i32 as Num>::from_str_radix("foo", 10);
assert!(result.is_err());

Supported radices

The exact range of supported radices is at the discretion of each type implementation. For primitive integers, this is implemented by the inherent from_str_radix methods in the standard library, which panic if the radix is not in the range from 2 to 36. The implementation in this crate for primitive floats is similar.

For third-party types, it is suggested that implementations should follow suit and at least accept 2..=36 without panicking, but an Err may be returned for any unsupported radix. It’s possible that a type might not even support the common radix 10, nor any, if string parsing doesn’t make sense for that type.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Num for f32

type FromStrRadixErr = ParseFloatError

fn from_str_radix( src: &str, radix: u32, ) -> Result<f32, <f32 as Num>::FromStrRadixErr>

impl Num for f64

type FromStrRadixErr = ParseFloatError

fn from_str_radix( src: &str, radix: u32, ) -> Result<f64, <f64 as Num>::FromStrRadixErr>

impl Num for i8

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<i8, ParseIntError>

impl Num for i16

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<i16, ParseIntError>

impl Num for i32

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<i32, ParseIntError>

impl Num for i64

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<i64, ParseIntError>

impl Num for i128

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<i128, ParseIntError>

impl Num for isize

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<isize, ParseIntError>

impl Num for u8

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<u8, ParseIntError>

impl Num for u16

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<u16, ParseIntError>

impl Num for u32

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<u32, ParseIntError>

impl Num for u64

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<u64, ParseIntError>

impl Num for u128

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<u128, ParseIntError>

impl Num for usize

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, radix: u32) -> Result<usize, ParseIntError>

impl Num for BigInt

fn from_str_radix(s: &str, radix: u32) -> Result<BigInt, ParseBigIntError>

Creates and initializes a BigInt.

type FromStrRadixErr = ParseBigIntError

impl Num for BigUint

fn from_str_radix(s: &str, radix: u32) -> Result<BigUint, ParseBigIntError>

Creates and initializes a BigUint.

type FromStrRadixErr = ParseBigIntError

impl<T> Num for Wrapping<T>

where T: Num, Wrapping<T>: NumOps,

type FromStrRadixErr = <T as Num>::FromStrRadixErr

fn from_str_radix( str: &str, radix: u32, ) -> Result<Wrapping<T>, <Wrapping<T> as Num>::FromStrRadixErr>

Implementors

impl Num for BigDecimal

type FromStrRadixErr = ParseBigDecimalError