Início / coding / Perguntas / 77221233
Accepted
Pioneer_11
Asked: 2023-10-03 17:53:01 +0800 CST

Como o mapa assume propriedade parcial por meio de uma referência imutável

  • 772

Estou tentando escrever uma função para encontrar o valor de uma mão de cartas. Como parte disso, preciso verificar se a mão é flush. Meu código para fazer isso é:

use itertools::Itertools;     // allows use of .all_equal()

fn find_hand_value(player_hand: Hand) {
    let is_flush: &bool = &player_hand.cards.map(|card| card.suit).iter().all_equal();
    // ... further checks
    println!("{:?}", player_hand)    // print takes ownership to represent further use of the hand
    // return hand value
}

No entanto, se você tentar executar este código, encontrará um erro mostrando que player_hand.cardsfoi parcialmente movido devido à chamada do método para map. Considerando que o mapa é solicitado a um empréstimo imutável de, player_handsnão entendo como isso é possível, pois parece estar em contradição direta com as regras de empréstimo da ferrugem.

Alguém poderia explicar o que está acontecendo aqui e como/por que isso é possível? Obrigado,

Para contexto:

#[derive(Debug)]
struct Hand {
    cards: [Card; 5],
}

#[derive(Debug)]
struct Card {
    suit: Suit,
    value: Value,
}

#[derive(Debug, PartialEq, Eq)]
enum Suit {
    Hearts,
    Diamonds,
    Spades,
    Clubs,
}

#[derive(Debug, Ord, PartialOrd, Eq, PartialEq)]
enum Value {
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
    Jack,
    Queen,
    King,
    Ace,
}
dictionary

1 respostas

  1. Best Answer

    Considerando que o mapa é chamado por um empréstimo imutável de player_hand

    Isso simplesmente não é verdade. O find_hand_valuepossui o player_hande a mapfunção nos arrays assume a propriedade do array:

    impl<T, const N: usize> [T; N]

pub fn map<F, U>(self, f: F) -> [U; N]
where
    F: FnMut(T) -> U,

    Há duas coisas que podem ser confusas aqui.

    Você não está pedindo emprestado

    Primeiro, você pode estar pensando nesta linha:

    &player_hand.cards.map(|card| card.suit).iter().all_equal()

    pega um empréstimo player_hands.cardse mapo cobra. Mas não é assim que isso é analisado, na verdade é:

    &(player_hand.cards.map(|card| card.suit).iter().all_equal())

    então apenas um empréstimo (inútil) do boolvalor retornado. Você pode escrever explicitamente:

    (&player_hand.cards).map(|card| card.suit).iter().all_equal())

    e então você receberá um erro diferente, informando que map não pode ser solicitado um empréstimo:

    error[E0508]: cannot move out of type `[Card; 5]`, a non-copy array
 --> src/main.rs:5:20
  |
5 |     let is_flush = (&player_hand.cards).map(|card| card.suit).iter().all_equal();
  |                    ^^^^^^^^^^^^^^^^^^^^^---------------------
  |                    |                    |
  |                    |                    value moved due to this method call
  |                    cannot move out of here
  |                    move occurs because value has type `[Card; 5]`, which does not implement the `Copy` trait
  |
note: `array::<impl [T; N]>::map` takes ownership of the receiver `self`, which moves value

    Erradomap

    A outra coisa é que existe o mapcom o qual a maioria das pessoas está familiarizada que pode ser chamado em um Iterator, que pode ser obtido de uma fatia emprestada com iter. A solução aqui é... mover as chamadas e começar com iter:

    player_hand.cards.iter().map(|card| card.suit).all_equal()

    Isso ainda não compila, porque Suitnão é copiado, então o mapa tenta movê-lo, mas este é bastante simples, apenas derive(Clone, Copy)em Suit.

    • 2

relate perguntas