Rand v0.6.0

The Rng::shuffle method is now deprecated; rand::seq::SliceRandom trait should be used. It provides the shuffle() method on all slices, which accepts an Rng instance:

// Rust edition 2018 no longer needs extern crate

use rand::thread_rng;
use rand::seq::SliceRandom;

fn main() {
    let mut vec: Vec<u32> = (0..10).collect();
    vec.shuffle(&mut thread_rng());
    println!("{:?}", vec);
}

See it on Playground.

Original answer

You're very close. This should work:

extern crate rand;

use rand::{thread_rng, Rng};

fn main() {
    let mut vec: Vec<u32> = (0..10).collect();
    let slice: &mut [u32] = &mut vec;

    thread_rng().shuffle(slice);
}

&mut [T] is implicitly coercible to &[T], and you annotated the slice variable with &[u32], so the slice became immutable: &mut [u32] was coerced to &[u32]. mut on the variable is not relevant here because slices are just borrows into data owned by someone else, so they do not have inherited mutability - their mutability is encoded in their types.

In fact, you don't need an annotation on slice at all. This works as well:

extern crate rand;

use rand::{thread_rng, Rng};

fn main() {
    let mut vec: Vec<u32> = (0..10).collect();
    let slice = vec.as_mut_slice();

    thread_rng().shuffle(slice);
}

You don't even need the intermediate variable:

extern crate rand;

use rand::{thread_rng, Rng};

fn main() {
    let mut vec: Vec<u32> = (0..10).collect();
    thread_rng().shuffle(&mut vec);
}

You should read The Rust Programming Language as it explains the concepts of ownership and borrowing and how they interact with mutability.

The key points are:

• bring into scope the required traits for shuffling (SliceRandom for rand version 0.7).
• bring into scope the required types for the enum::iter()

Cargo.toml:

[package]
name = "mcve"
version = "0.1.0"
authors = ["Svetlin Zarev <[email protected]>"]
edition = "2018"

[dependencies]
strum = "0.15"
strum_macros = "0.15"
rand = "0.7.0"

main.rs:

use strum_macros::EnumIter; // etc.
use strum::IntoEnumIterator;
use rand::thread_rng;
use rand::seq::SliceRandom;

#[derive(Debug, Copy, Clone,EnumIter)]
enum Suit {
    DIAMONDS,
    HEARTS,
    CLUBS,
    SPADES,
}

#[derive(Debug, Copy, Clone, EnumIter)]
enum Rank {
    Ace,
    King,
    Queen,
    Jack,
}

#[derive(Debug)]
struct Card {
    suit: Suit,
    rank: Rank,
}

impl Card {
    fn new(suit: Suit, rank: Rank) -> Card {
        Card { suit, rank }
    }
}

fn main() {
    let mut cards = Vec::<Card>::new();

    for r in Rank::iter() {
        for s in Suit::iter() {
            cards.push(Card::new(s, r));
        }
    }

    let mut rng = thread_rng();
    cards.shuffle(&mut rng);

    println!("{:?}", cards);
}

As you can see, it's almost as if in Java. The only difference is that some methods do not come from the structs, but from the interfaces (in Rust these are called traits) and you have to import them in order to be able to use them.