How can I get a random number in Rust 1.0?

问题:

I tried

use std::rand::{task_rng, Rng};

fn main() {
    // a number from [-40.0, 13000.0)
    let num: f64 = task_rng().gen_range(-40.0, 1.3e4);
    println!("{}", num);
}

but this gives

error[E0432]: unresolved import `std::rand::task_rng`
 --> rand.rs:1:17
  |
1 | use std::rand::{task_rng, Rng};
  |                 ^^^^^^^^ no `task_rng` in `rand`

error[E0432]: unresolved import `std::rand::Rng`
 --> rand.rs:1:27
  |
1 | use std::rand::{task_rng, Rng};
  |                           ^^^ no `Rng` in `rand`

error[E0603]: module `rand` is private
 --> rand.rs:1:17
  |
1 | use std::rand::{task_rng, Rng};
  |                 ^^^^^^^^

error[E0603]: module `rand` is private
 --> rand.rs:1:27
  |
1 | use std::rand::{task_rng, Rng};
  |                           ^^^

and I tried

extern crate rand;
use rand::Rng;

fn main() {
    let mut rng = rand::thread_rng();
    if rng.gen() {
        // random bool
        println!("i32: {}, u32: {}", rng.gen::<i32>(), rng.gen::<u32>())
    }
    let tuple = rand::random::<(f64, char)>();
    println!("{:?}", tuple)
}

and got

error[E0425]: cannot find function `thread_rng` in module `rand`
 --> rand.rs:5:29
  |
5 |         let mut rng = rand::thread_rng();
  |                             ^^^^^^^^^^ not found in `rand`
  |
help: possible candidate is found in another module, you can import it into scope
  |     use std::__rand::thread_rng;

error[E0425]: cannot find function `random` in module `rand`
  --> rand.rs:10:27
   |
10 |         let tuple = rand::random::<(f64, char)>();
   |                           ^^^^^^ not found in `rand`

error: use of unstable library feature 'rand': use `rand` from crates.io (see issue #27703)
 --> rand.rs:1:5
  |
1 |     extern crate rand;
  |     ^^^^^^^^^^^^^^^^^^

error: use of unstable library feature 'rand': use `rand` from crates.io (see issue #27703)
 --> rand.rs:2:9
  |
2 |     use rand::Rng;
  |         ^^^^^^^^^

回答1:

In the far past, the rand crate was part of the standard library but has long since been extracted to a crate. This crate should be the one you use:

Specify a Cargo.toml:

[package]
name = "stackoverflow"
version = "0.0.1"
authors = ["A. Developer <[e-mail]>"]

[dependencies]
rand = "0.6.0" # Or a newer version

Then your example code works:

extern crate rand; // 0.6.0

use rand::Rng;

fn main() {
    let mut rng = rand::thread_rng();
    if rng.gen() { // random bool
        println!("i32: {}, u32: {}", rng.gen::<i32>(), rng.gen::<u32>())
    }
    let tuple = rand::random::<(f64, char)>();
    println!("{:?}", tuple)
}

With the output:

$ cargo run
     Running `target/debug/so`
i32: 1819776837, u32: 3293137459
(0.6052759716514547, '\u{69a69}')

$ cargo run
     Running `target/debug/so`
(0.23882541338214436, '\u{10deee}')

Why were these useful functions removed from stdlib?

Rust has a philosophy of placing as much as possible into crates instead of the standard library. This allows each piece of code to grow and evolve at a different rate than the standard library and also allows the code to stop being used without forcing it to be maintained forever.

A common example is the sequence of HTTP libraries in Python. There are multiple packages that all do the same thing in different ways and the Python maintainers have to keep all of them to provide backwards compatibility.

Crates allow this particular outcome to be avoided. If a crate truly stabilizes for a long time, I'm sure it could be re-added to the standard library.