[][src]Trait turtle::rand::Random

pub trait Random {
    fn random() -> Self;
}

This trait represents any type that can have random values generated for it.

Tip: There is a list later on this page that shows many of the types that implement this trait.

Example

To implement this trait for your own types, call random() or random_range() for each field. For enums, generate a random number and pick a variant of your enum based on that. You can then use random() or random_range() to pick values for that variant's fields (if necessary).

use turtle::rand::{
    random,
    random_range,
    Random,
    RandomRange,
};

#[derive(Debug, Clone)]
struct Product {
    price: f64,
    quantity: u32,
}

impl Random for Product {
    fn random() -> Self {
        Self {
            // Prices sure are fluctuating!
            price: Random::random(),
            // This will generate a value between 1 and 15 (inclusive)
            quantity: RandomRange::random_range(0, 15),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Door {
    Open,
    Closed,
    Locked,
}

impl Random for Door {
    fn random() -> Self {
        use Door::*;
        // Pick a variant of `Door` based on a number.
        // Notice the type in the numeric literal so Rust knows what to generate
        match RandomRange::random_range(0u8, 3) {
            0 => Open,
            1 => Closed,
            2 => Locked,
            // Even though we know that the value will be between 0 and 2, the compiler does
            // not, so we instruct it to panic if this case ever occurs.
            _ => unreachable!(),
        }
    }
}

fn main() {
    // These types can now be used with the `random()` function!
    let product: Product = random();
    let door: Door = random();

    // ...
}

Required methods

fn random() -> Self

Generate a single random value.

Example

use turtle::{Color, Speed, rand::random};

// Need to annotate the type so Rust knows what you want it to generate
let x: f32 = random();
let y: f32 = random();

// Works with turtle specific types too!
let color: Color = random();
let speed: Speed = random();
Loading content...

Implementations on Foreign Types

impl Random for f32[src]

impl Random for f64[src]

impl Random for u8[src]

impl Random for u16[src]

impl Random for u32[src]

impl Random for u64[src]

impl Random for u128[src]

impl Random for usize[src]

impl Random for i8[src]

impl Random for i16[src]

impl Random for i32[src]

impl Random for i64[src]

impl Random for i128[src]

impl Random for isize[src]

impl Random for char[src]

impl Random for bool[src]

impl Random for ()[src]

impl<A: Random> Random for (A,)[src]

impl<A: Random, B: Random> Random for (A, B)[src]

impl<A: Random, B: Random, C: Random> Random for (A, B, C)[src]

impl<A: Random, B: Random, C: Random, D: Random> Random for (A, B, C, D)[src]

impl<A: Random, B: Random, C: Random, D: Random, E: Random> Random for (A, B, C, D, E)[src]

impl<A: Random, B: Random, C: Random, D: Random, E: Random, F: Random> Random for (A, B, C, D, E, F)[src]

impl<A: Random, B: Random, C: Random, D: Random, E: Random, F: Random, G: Random> Random for (A, B, C, D, E, F, G)[src]

impl<A: Random, B: Random, C: Random, D: Random, E: Random, F: Random, G: Random, H: Random> Random for (A, B, C, D, E, F, G, H)[src]

impl<A: Random, B: Random, C: Random, D: Random, E: Random, F: Random, G: Random, H: Random, I: Random> Random for (A, B, C, D, E, F, G, H, I)[src]

impl<A: Random, B: Random, C: Random, D: Random, E: Random, F: Random, G: Random, H: Random, I: Random, J: Random> Random for (A, B, C, D, E, F, G, H, I, J)[src]

impl<A: Random, B: Random, C: Random, D: Random, E: Random, F: Random, G: Random, H: Random, I: Random, J: Random, K: Random> Random for (A, B, C, D, E, F, G, H, I, J, K)[src]

impl<A: Random, B: Random, C: Random, D: Random, E: Random, F: Random, G: Random, H: Random, I: Random, J: Random, K: Random, L: Random> Random for (A, B, C, D, E, F, G, H, I, J, K, L)[src]

impl<T: Random> Random for [T; 0][src]

impl<T: Random> Random for [T; 1][src]

impl<T: Random> Random for [T; 2][src]

impl<T: Random> Random for [T; 3][src]

impl<T: Random> Random for [T; 4][src]

impl<T: Random> Random for [T; 5][src]

impl<T: Random> Random for [T; 6][src]

impl<T: Random> Random for [T; 7][src]

impl<T: Random> Random for [T; 8][src]

impl<T: Random> Random for [T; 9][src]

impl<T: Random> Random for [T; 10][src]

impl<T: Random> Random for [T; 11][src]

impl<T: Random> Random for [T; 12][src]

impl<T: Random> Random for [T; 13][src]

impl<T: Random> Random for [T; 14][src]

impl<T: Random> Random for [T; 15][src]

impl<T: Random> Random for [T; 16][src]

impl<T: Random> Random for [T; 17][src]

impl<T: Random> Random for [T; 18][src]

impl<T: Random> Random for [T; 19][src]

impl<T: Random> Random for [T; 20][src]

impl<T: Random> Random for [T; 21][src]

impl<T: Random> Random for [T; 22][src]

impl<T: Random> Random for [T; 23][src]

impl<T: Random> Random for [T; 24][src]

impl<T: Random> Random for [T; 25][src]

impl<T: Random> Random for [T; 26][src]

impl<T: Random> Random for [T; 27][src]

impl<T: Random> Random for [T; 28][src]

impl<T: Random> Random for [T; 29][src]

impl<T: Random> Random for [T; 30][src]

impl<T: Random> Random for [T; 31][src]

impl<T: Random> Random for [T; 32][src]

impl<T: Random> Random for Option<T>[src]

impl<T: Random> Random for Wrapping<T>[src]

Loading content...

Implementors

impl Random for Color[src]

impl Random for Point[src]

impl Random for Speed[src]

fn random() -> Self[src]

Generates a random speed within the valid range of speed levels

Loading content...