Rust application to total up a hand of cards

blackjack.rs

use lazy_static::lazy_static;
use std::collections::HashMap;

// Ace is worth 11, except if total >21, then it is equal to 1

#[derive(Debug, PartialEq, Eq, Hash)]
enum Card {
    SmallAce,
    Ace,
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
    Jack,
    Queen,
    King,
}

lazy_static! {
    static ref CARD_VALUES: HashMap<Card, usize> = {
        let mut map = HashMap::new();
        map.insert(Card::SmallAce, 1);
        map.insert(Card::Ace, 11);
        map.insert(Card::Two, 2);
        map.insert(Card::Three, 3);
        map.insert(Card::Four, 4);
        map.insert(Card::Five, 5);
        map.insert(Card::Six, 6);
        map.insert(Card::Seven, 7);
        map.insert(Card::Eight, 8);
        map.insert(Card::Nine, 9);
        map.insert(Card::Ten, 10);
        map.insert(Card::Jack, 10);
        map.insert(Card::Queen, 10);
        map.insert(Card::King, 10);
        map
    };
}

fn card_value(card: &Card) -> usize {
    *CARD_VALUES.get(card).unwrap_or(&0) // Return 0 for unknown cards
}

struct Hand {
    cards: Vec<Card>,
}

impl Hand {
    fn value(mut self) -> usize {
        loop {
            let total = self.cards.iter().map(|card| card_value(card)).sum();

            if total <= 21 {
                return total;
            }
            if let Some(index) = self.cards.iter().position(|card| *card == Card::Ace) {
                self.cards[index] = Card::SmallAce;
            } else {
                return total;
            }
        }
    }
}

fn main() {
    let hand = Hand {
        cards: vec![Card::Ace, Card::King],
    };
    println!("{}", hand.value());

    let hand = Hand {
        cards: vec![Card::Ace, Card::King, Card::Ace],
    };
    println!("{}", hand.value());

    let hand = Hand {
        cards: vec![Card::Ace, Card::Two, Card::Ace],
    };
    println!("{}", hand.value());

    let hand = Hand { cards: vec![] };
    println!("{}", hand.value());
}

output.txt

21
12
14
0