generate a random number with given bit size in Rust

I am trying to generate a random number with aribitorary bit size in Rust using Rug. I create a function like this:

fn bit_str(bitlen: usize) -> String {
    let vs = vec!['0','1'];
    let mut nums = vec!['0'; bitlen];
    for i in 0..bitlen {
        nums[i] = *vs.choose(&mut rand::thread_rng()).unwrap();
    }
    return nums.into_iter().collect::<String>();
}
let bin = bit_str(1_000_000);
let mut random_number = Integer::new();
random_number.assign(Integer::parse_radix(bin,2).unwrap());

But this is slow. In my environment, it took 30 seconds to generate 100 random numbers with 1m bits. Is there any way to generate such random numbers faster?

This answer is akin to apilat's, but uses rug and generates as big of chunks as possible (at most 32 bits, which is the maximum rug::rand::RandState::bits supports):

/*
[dependencies]
rug = "*"
*/

fn rand(mut bits: u32) -> rug::Integer {
    let mut rand = rug::rand::RandState::new();

    let mut res = rug::Integer::with_capacity(bits as usize);

    while bits > 0 {
        let generate = bits.min(32);

        res = (res << generate) + rand.bits(generate);
        
        bits -= generate;
    }

    res
}

fn main() {
    println!("{:b}", rand(1_000_000));
}

Rustexplorer.

In general, working with integers directly is much faster than working with strings and then converting.
The operation of appending a bit b at the end of an existing number x
can be implemented by bit-shifting x one to the left and then adding b: (x << 1) + b.
This is the principle behind the implementation below.

I couldn't figure out where your Integer type comes from so the example (playground) uses num::BigInt instead.
You could make this code even faster by generating bits in larger chunks (for example 32 or 64 bits) at the cost of some implementation complexity.

use num::BigInt;
use rand::{Rng, thread_rng};

fn randint(bits: usize) -> BigInt {
    let mut rng = thread_rng();
    let mut x = BigInt::default();
    for _ in 0..bits {
        x <<= 1;
        x += rng.gen_range(0..=1);
    }
    x
}

fn main() {
    let x = randint(10);
    let y = randint(1000);
    println!("{x}");
    println!("{y}");
}