Struct Category 

pub struct Category<'a> {
    pub name: &'a str,
    pub words: &'a [String],
}

One discovered category and the words it claims.

Fields

name: &'a str

the category name, which is also its query stem: name/*

words: &'a [String]

the words in the text that put a document in this category

Implementations

impl Category<'_>

pub fn wildcard(&self) -> String

The wildcard that matches every value in this category.

Examples found in repository

examples/quickstart.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let docs = [
        "Morty Shade defeated Wallace Gale at Ecruteak City during the Indigo Invitational in 2025.",
        "Bea Strike defeated Iris Draco at Ecruteak City during the Indigo Invitational in 2025.",
        "Juan Tide defeated Cynthia Ward at Ecruteak City during the Indigo Invitational in 2026.",
        "A habitat survey recorded Aggron near Sootopolis City at an elevation of 1082 m.",
        "A habitat survey recorded Salamence near Sootopolis City at an elevation of 2369 m.",
        "A habitat survey recorded Milotic near Sootopolis City at an elevation of 340 m.",
        "Milotic is not permitted in Series 1 play for the 2025 season.",
        "Metagross is permitted in Series 4 play for the 2026 season.",
    ];

    let db = SteelDb::ingest(docs)?;
    println!("indexed {} situations", db.len());

    println!("\nyou can ask about:");
    for c in db.categories() {
        println!("  {:<14} {}", c.wildcard(), c.words.iter().take(4).cloned().collect::<Vec<_>>().join(", "));
    }

    // use a category the corpus actually produced — see the list printed above
    let q = "(and elevation/* (not state/negated))";
    match db.query(q) {
        Ok(a) => {
            println!("\n{q}  ->  {} situations", a.len());
            for (id, text) in db.resolve(&a).take(2) {
                // chars(), not a byte slice: `&text[..n]` panics mid-character
                println!("  [{id}] {}", text.chars().take(56).collect::<String>());
            }
        }
        Err(r) => println!("\n{r}"),
    }

    // a category this corpus does not have — refused, not answered with an empty list
    match db.query("survey/*") {
        Ok(_) => println!("\nunexpected: survey is not a category here"),
        Err(r) => println!("\n{r}"),
    }

    match db.query("gene/brca1") {
        Ok(_) => println!("\nunexpected: that should not exist"),
        Err(r) => println!("\n{r}"),
    }

    println!("\nbelief in a denied claim: {}", db.belief("state/negated"));
    Ok(())
}

Trait Implementations

impl<'a> Clone for Category<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for Category<'a>

impl<'a> Debug for Category<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.