Learning Rust und Dokumentation

Question

Ich arbeite an einer Exercism Übung und ich bin mit dieser konfrontiert:

fn test_no_allergies_means_not_allergic() { 
    let allergies = Allergies::new(0); 
    assert_eq!(false, allergies.is_allergic_to(&Allergen::Peanuts)); 
    assert_eq!(false, allergies.is_allergic_to(&Allergen::Cats)); 
    assert_eq!(false, allergies.is_allergic_to(&Allergen::Strawberries)); 
} 

Wenn ich Allergen::Peanuts aussehen, denke ich, dass dies ein Symbol wie Ruby ist, aber ich kann‘ In der Dokumentation finden Sie nichts anderes als die Idee von Kisten und Modulen. Ich kann nicht scheinen zu denken, dass Allergen ein Modul mit getrennten Kästen vor allem, weil die README führt mich dazu:

Die Liste der Elemente (und deren Wert), die getestet wurden, sind:

• Eier (1)
• Erdnüsse (2)
• Krustentiere (4)
• Erdbeeren (8)
• Tomaten (16)
• Schokolade (32)
• Pollen (64)
• Katzen (128)

Also, wenn Tom zu Erdnüssen und Schokolade allergisch ist, bekommt er eine Punktzahl von 34.

Es muss eine Art Enum mit jedem dieser Werte und irgendeiner Art von Bitmaske sein, aber ich kann einfach keine Dokumentation finden, um mir mehr über die Symbole zu zeigen. Ich bin nicht bereit aufzugeben und ich möchte so viel wie möglich über Rust lernen, aber die Dokumente scheinen zu fehlen.

Hat jemand irgendwelche Vorschläge in Bezug auf Enums, Objekte, Symbole, und wo kann ich mehr Dokumentation in Bezug auf Rust bekommen?

Answer 1

Rust hat keinen Bitflags-Typ in der Sprach- oder Standardbibliothek. Aber es gibt eine bitflags Kiste, die Sie schreiben konnte

#[macro_use] extern crate bitflags; 

bitflags! { 
    flags Allergies: u32 { 
     const ALLERGEN_EGGS = 1, 
     const ALLERGEN_PEANUTS = 2, 
     ... 
     const ALLERGEN_CATS = 128, 
    } 
} 

impl Allergies { 
    pub fn is_allergic_to(&self, other: &Allergies) -> bool { 
     self.intersects(*other) 
    } 
} 

let allergies = Allergies::empty(); 
assert!(!allergies.is_allergic_to(&ALLERGEN_CATS)); 
//^unfortunately we don't support associated constants 
// so we have to name it ALLERGEN_CATS instead of Allergies::CATS. 
assert_eq!((ALLERGEN_PEANUTS | ALLERGEN_CHOCOLATE).bits(), 34); 

nicht bitflags zum [dependency] Abschnitt in Ihrem Cargo.toml hinzuzufügen Vergessen.

---

Wenn Sie nicht auf einem externen Kiste hängen möchten, können Sie Ihre Art auf Integer-Typen zusammen mit den bitweise Operationen stützen. They are the same as Caußer, die wir ! anstelle von ~ für Bitwise-nicht verwenden.

Die Konstanten haben, die in einem separate module definiert werden:

#[allow(non_upper_case_globals)] // <- silence 8 warnings 
mod Allergen { 
    pub const Eggs: u32 = 1; // <- use a new type if you like 
    pub const Peanuts: u32 = 2; 
    ... 
    pub const Cats: u32 = 128; 
} 

oder als C-style ENUM (Associate ENUM-Mitglieder mit explicit discriminants):

enum Allergen { 
    Eggs = 1, 
    Peanuts = 2, 
    ... 
    Cats = 128, 
} 

let score = (Allergen::Peanuts as isize) | (Allergen::Chocolate as isize); 

Beide, die nicht vermitteln das Konzept, dass die Werte Bitflags bilden. Im Ernst, Sie sollten diese Bitflags-Workarounds vermeiden, wenn Sie externe Kisten verwenden könnten.