Trait Bounded

pub trait Bounded {
    // Required methods
    fn min_value() -> Self;
    fn max_value() -> Self;
}

Numbers which have upper and lower bounds

Required Methods

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

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 Bounded for f32

fn min_value() -> f32

fn max_value() -> f32

impl Bounded for f64

fn min_value() -> f64

fn max_value() -> f64

impl Bounded for i8

fn min_value() -> i8

fn max_value() -> i8

impl Bounded for i16

fn min_value() -> i16

fn max_value() -> i16

impl Bounded for i32

fn min_value() -> i32

fn max_value() -> i32

impl Bounded for i64

fn min_value() -> i64

fn max_value() -> i64

impl Bounded for i128

fn min_value() -> i128

fn max_value() -> i128

impl Bounded for isize

fn min_value() -> isize

fn max_value() -> isize

impl Bounded for u8

fn min_value() -> u8

fn max_value() -> u8

impl Bounded for u16

fn min_value() -> u16

fn max_value() -> u16

impl Bounded for u32

fn min_value() -> u32

fn max_value() -> u32

impl Bounded for u64

fn min_value() -> u64

fn max_value() -> u64

impl Bounded for u128

fn min_value() -> u128

fn max_value() -> u128

impl Bounded for ()

fn min_value()

fn max_value()

impl Bounded for usize

fn min_value() -> usize

fn max_value() -> usize

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where A: Bounded, B: Bounded, C: Bounded, D: Bounded, E: Bounded, F: Bounded, G: Bounded, H: Bounded, I: Bounded, J: Bounded, K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where B: Bounded, C: Bounded, D: Bounded, E: Bounded, F: Bounded, G: Bounded, H: Bounded, I: Bounded, J: Bounded, K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where C: Bounded, D: Bounded, E: Bounded, F: Bounded, G: Bounded, H: Bounded, I: Bounded, J: Bounded, K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where D: Bounded, E: Bounded, F: Bounded, G: Bounded, H: Bounded, I: Bounded, J: Bounded, K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where E: Bounded, F: Bounded, G: Bounded, H: Bounded, I: Bounded, J: Bounded, K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where F: Bounded, G: Bounded, H: Bounded, I: Bounded, J: Bounded, K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where G: Bounded, H: Bounded, I: Bounded, J: Bounded, K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (H, I, J, K, L, M, N, O, P, Q, R, S, T)

where H: Bounded, I: Bounded, J: Bounded, K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (H, I, J, K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (I, J, K, L, M, N, O, P, Q, R, S, T)

where I: Bounded, J: Bounded, K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (I, J, K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (I, J, K, L, M, N, O, P, Q, R, S, T)

impl<J, K, L, M, N, O, P, Q, R, S, T> Bounded for (J, K, L, M, N, O, P, Q, R, S, T)

where J: Bounded, K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (J, K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (J, K, L, M, N, O, P, Q, R, S, T)

impl<K, L, M, N, O, P, Q, R, S, T> Bounded for (K, L, M, N, O, P, Q, R, S, T)

where K: Bounded, L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (K, L, M, N, O, P, Q, R, S, T)

fn max_value() -> (K, L, M, N, O, P, Q, R, S, T)

impl<L, M, N, O, P, Q, R, S, T> Bounded for (L, M, N, O, P, Q, R, S, T)

where L: Bounded, M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (L, M, N, O, P, Q, R, S, T)

fn max_value() -> (L, M, N, O, P, Q, R, S, T)

impl<M, N, O, P, Q, R, S, T> Bounded for (M, N, O, P, Q, R, S, T)

where M: Bounded, N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (M, N, O, P, Q, R, S, T)

fn max_value() -> (M, N, O, P, Q, R, S, T)

impl<N, O, P, Q, R, S, T> Bounded for (N, O, P, Q, R, S, T)

where N: Bounded, O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (N, O, P, Q, R, S, T)

fn max_value() -> (N, O, P, Q, R, S, T)

impl<O, P, Q, R, S, T> Bounded for (O, P, Q, R, S, T)

where O: Bounded, P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (O, P, Q, R, S, T)

fn max_value() -> (O, P, Q, R, S, T)

impl<P, Q, R, S, T> Bounded for (P, Q, R, S, T)

where P: Bounded, Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (P, Q, R, S, T)

fn max_value() -> (P, Q, R, S, T)

impl<Q, R, S, T> Bounded for (Q, R, S, T)

where Q: Bounded, R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (Q, R, S, T)

fn max_value() -> (Q, R, S, T)

impl<R, S, T> Bounded for (R, S, T)

where R: Bounded, S: Bounded, T: Bounded,

fn min_value() -> (R, S, T)

fn max_value() -> (R, S, T)

impl<S, T> Bounded for (S, T)

where S: Bounded, T: Bounded,

fn min_value() -> (S, T)

fn max_value() -> (S, T)

impl<T> Bounded for (T,)

where T: Bounded,

fn min_value() -> (T,)

fn max_value() -> (T,)

impl<T> Bounded for Wrapping<T>

where T: Bounded,

fn min_value() -> Wrapping<T>

fn max_value() -> Wrapping<T>

Implementors