libgrammstein 0.1.0

Hybrid language model (N-gram + Embeddings) for WFST text 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

//! Programming paradigm indicator extraction.
//!
//! This module provides extraction of programming paradigm indicators from code,
//! detecting patterns characteristic of:
//!
//! - **Object-Oriented Programming (OOP)**: Classes, inheritance, encapsulation, polymorphism
//! - **Functional Programming (FP)**: Pure functions, immutability, higher-order functions, closures
//! - **Reactive Programming**: Observables, streams, event-driven patterns
//! - **Procedural Programming**: Sequential execution, mutable state, control flow
//!
//! # Architecture
//!
//! ```text
//! ┌─────────────────────────────────────────────────────────────────────────┐
//! │                    Paradigm Detection Pipeline                          │
//! ├─────────────────────────────────────────────────────────────────────────┤
//! │  Source Code → Token Stream → Indicator Matching → Paradigm Profile    │
//! │                                                                          │
//! │  Indicators:                                                             │
//! │  ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ ┌──────────────┐│
//! │  │ Class/struct  │ │ Lambda/fn     │ │ Observable    │ │ for/while    ││
//! │  │ extends/impl  │ │ map/filter    │ │ subscribe     │ │ mut state    ││
//! │  │ this/self     │ │ fold/reduce   │ │ stream/flux   │ │ goto/jump    ││
//! │  │ new/instance  │ │ compose       │ │ event/emit    │ │ side effects ││
//! │  └───────────────┘ └───────────────┘ └───────────────┘ └──────────────┘│
//! │       OOP               FP              Reactive          Procedural   │
//! └─────────────────────────────────────────────────────────────────────────┘
//! ```
//!
//! # Example
//!
//! ```ignore
//! use libgrammstein::topic::paradigm::{ParadigmDetector, ParadigmConfig, Paradigm};
//!
//! let config = ParadigmConfig::default();
//! let detector = ParadigmDetector::new(config);
//!
//! let code = "class Foo extends Bar { constructor() { this.x = 0; } }";
//! let profile = detector.analyze(code);
//!
//! assert!(profile.oop_score > profile.fp_score);
//! assert_eq!(profile.dominant_paradigm(), Some(Paradigm::ObjectOriented));
//! ```

mod api_patterns;
mod config;
mod detector;
mod domain_patterns;
mod indicators;

pub use api_patterns::{ApiPattern, ApiPatternConfig, ApiPatternMiner, MiningStats};
pub use config::{LanguageHints, ParadigmConfig, ParadigmWeights};
pub use detector::{DetectionResult, IndicatorMatch, ParadigmDetector};
pub use domain_patterns::{
    DomainPatternDetector, MettaPattern, MettaPatternCatalog, MettaPatternCategory,
    MettaPatternMatch, RholangPattern, RholangPatternCatalog, RholangPatternCategory,
    RholangPatternMatch,
};
pub use indicators::{
    FpIndicator, IndicatorCategory, OopIndicator, Paradigm, ParadigmIndicator, ParadigmProfile,
    ProceduralIndicator, ReactiveIndicator,
};