"errore: i limiti dei tratti non sono consentiti nelle definizioni di struttura" quando si tenta di utilizzare il polimorfismo

Question

Editor's note: This question was asked before Rust 1.0 and before certain features were implemented. The code as-is works today.

Sto scrivendo un gioco da tavolo AI in Rust. Ci sono più set di regole per il gioco e mi piacerebbe avere la logica delle regole separata dal layout della scheda (sono attualmente misti). In una lingua come Ruby, avrei le serie di regole separate implementare la stessa interfaccia. In Rust ho pensato di utilizzare un tratto e di parametrizzare lo Board con il set di regole che voglio utilizzare (ad esempio Board<Rules1>::new()).

Il salvataggio di un oggetto che implementa questo tratto in una struttura (come Board) non è consentito. Potrei trasformare lo Rules in un enum, ma mi sembra un po 'disordinato perché non riesco a definire implementazioni separate per i membri dell'enum. L'uso della corrispondenza del modello potrebbe funzionare, ma ciò divide la funzionalità lungo l'asse della funzione e non lungo l'asse della struttura. È solo qualcosa con cui devo vivere o in qualche modo?

Il codice che segue è quello che mi piacerebbe usare:

pub struct Rules1; 
pub struct Rules2; 

trait Rules { 
    fn move_allowed() -> bool; 
} 

impl Rules for Rules1 { 
    fn move_allowed() -> bool { 
     true 
    } 
} 

impl Rules for Rules2 { 
    fn move_allowed() -> bool { 
     false 
    } 
} 

struct Board<R: Rules> { 
    rules: R 
} 

fn main() {} 

Produce il seguente errore:

test.rs:20:1: 22:2 error: trait bounds are not allowed in structure definitions 
test.rs:20 struct Board<R: Rules> { 
test.rs:21  rules: R 
test.rs:22 } 
error: aborting due to previous error 

Answer 1

Il codice di cui la questione funziona su tutte le versioni recenti di Rust, i limiti di tratto sulle strutture sono ora consentiti. Anche la risposta originale è ancora valida.

---

È necessario ridefinirlo nell'implementazione dei tratti, non nella definizione di struct.

pub struct Rules1; 
pub struct Rules2; 

trait Rules { 
    fn move_allowed(&self) -> bool; 
} 

impl Rules for Rules1 { 
    fn move_allowed(&self) -> bool { 
     true 
    } 
} 

impl Rules for Rules2 { 
    fn move_allowed(&self) -> bool { 
     false 
    } 
} 

struct Board<R> { 
    rules: R, 
} 

impl<R: Rules> Board<R> { 
    fn move_allowed(&self) -> bool { 
     self.rules.move_allowed() 
    } 
} 

fn main() { 
    let board = Board { rules: Rules2 }; 
    assert!(!board.move_allowed()); 
}