lling-llang 0.1.0

WFST framework for text normalization and grammar correction
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

//! liblevenshtein integration for lling-llang.
//!
//! This module provides a bridge between liblevenshtein's Levenshtein automata
//! and lling-llang's WFST framework, enabling efficient fuzzy string matching
//! in correction pipelines.
//!
//! # Overview
//!
//! The integration provides:
//!
//! - **Dictionary Types**: Access to liblevenshtein's dictionary implementations
//! - **Edit Semiring Adapters**: Convert between `TropicalWeight` and `EditWeight`
//! - **Fuzzy Lookup**: High-level APIs for dictionary-based correction
//!
//! # Architecture
//!
//! ```text
//! ┌────────────────────────────────────────────────────────────────────┐
//! │                    lling-llang WFST Framework                       │
//! ├────────────────────────────────────────────────────────────────────┤
//! │  fuzzy_lookup()  → liblevenshtein Transducer × Dictionary          │
//! │       │                                                            │
//! │       ↓                                                            │
//! │  EditWeight → Explainable corrections with operations              │
//! └────────────────────────────────────────────────────────────────────┘
//! ```
//!
//! # Example
//!
//! ```rust,ignore
//! use lling_llang::integration::prelude::*;
//!
//! // Build a dictionary
//! let dict = DynamicDawgChar::<()>::from_terms(vec!["hello", "help", "world"]);
//!
//! // Fuzzy lookup with edit operations tracking
//! let results = fuzzy_lookup_with_edits(&dict, "helo", FuzzyConfig::new(2));
//!
//! for (correction, edit_weight) in results {
//!     println!("{}: cost={}, operations={:?}",
//!         correction,
//!         edit_weight.cost(),
//!         edit_weight.describe());
//! }
//! ```
//!
//! # Feature Gate
//!
//! This module requires the `levenshtein` feature:
//!
//! ```toml
//! [dependencies]
//! lling-llang = { version = "0.1", features = ["levenshtein"] }
//! ```

mod liblevenshtein_bridge;

pub use liblevenshtein_bridge::*;

/// Prelude for convenient imports.
pub mod prelude {
    // Re-export dictionary types
    pub use liblevenshtein::prelude::{
        Algorithm, Candidate, Dictionary, DictionaryBackend as DictBackend, DictionaryContainer,
        DictionaryFactory, DictionaryNode, DoubleArrayTrie, DynamicDawg, QueryBuilder,
        SuffixAutomaton, Transducer, TransducerBuilder,
    };

    // Re-export UTF-8 dictionary types
    pub use libdictenstein::double_array_trie_char::DoubleArrayTrieChar;
    pub use libdictenstein::dynamic_dawg_char::DynamicDawgChar;
    pub use libdictenstein::suffix_automaton_char::SuffixAutomatonChar;

    // Re-export PathMap dictionary when available
    #[cfg(feature = "pathmap-backend")]
    pub use liblevenshtein::prelude::PathMapDictionary;

    // Re-export WallBreaker for large error bounds
    pub use libdictenstein::scdawg::Scdawg;
    pub use libdictenstein::scdawg_char::ScdawgChar;
    pub use liblevenshtein::wallbreaker::{
        PatternPiece, PatternSplitter, WallBreaker, WallBreakerQuery, WallBreakerResult,
    };

    // Re-export our bridge types
    pub use super::{
        fuzzy_lookup, fuzzy_lookup_parallel, fuzzy_lookup_with_edits, EditCosts, EditTracker,
        EditTrackerBuilder, FuzzyConfig, FuzzyResult,
    };
}