Enum Extracted 

pub enum Extracted<T> {
    Found(T),
    NotFound,
    Defaulted(T),
}

The outcome of attempting to extract a single date component (day, month, or year).

Variants

Found(T)

The value was found directly in the input.

NotFound

No value could be found and no default was configured.

Defaulted(T)

The value was not found in the input but a default was applied.

Implementations

impl<T> Extracted<T>

pub fn is_found(&self) -> bool

Returns true if the value was found in the input.

Examples found in repository

examples/all_examples.rs (line 586)

fn example_21_fuzzy_month_name() {
    println!("2️⃣1️⃣  FUZZY MONTH MATCHING: Misspellings");
    println!("   Testing Levenshtein distance fuzzy matching\n");

    let cases = vec![
        ("25 Januray 2024", "Januray (transposition)"),
        ("15 Decmber 2024", "Decmber (missing letter)"),
        ("31 Ocotber 2024", "Ocotber (swap)"),
    ];

    for (input_str, description) in cases {
        let input = Input {
            utterance: input_str.to_string(),
            config: None,
        };
        let result = extract(input);
        println!(
            "   {} → {:?} {}",
            description,
            result.month.name,
            if result.month.number.is_found() {
                "✓"
            } else {
                "✗"
            }
        );
    }
    println!();
}

pub fn is_not_found(&self) -> bool

Returns true if no value was found and no default applied.

pub fn is_defaulted(&self) -> bool

Returns true if the value was defaulted.

pub fn value(&self) -> Option<&T>

Returns the inner value regardless of whether it was found or defaulted. Returns None if NotFound.

Trait Implementations

impl<T: Clone> Clone for Extracted<T>

fn clone(&self) -> Extracted<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Extracted<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Extracted<T>

fn eq(&self, other: &Extracted<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for Extracted<T>

impl<T> StructuralPartialEq for Extracted<T>