urge-core 0.1.2

URGE core: no_std Unicode semantic dictionary, AST, engine trait, and decision types
Documentation 
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

//! # urge-core
//!
//! The `no_std`-compatible kernel of the Universal Reasoning Governance Engine.
//!
//! ## Architecture
//!
//! URGE implements a Unicode semantic dictionary and multi-logic processing
//! architecture for modular reasoning systems. The core concept — the
//! **Figure 26** Adaptive Processing Workflow, named for the diagram in the
//! original design document — is a deterministic pipeline:
//!
//! ```text
//! Input
//!   │
//!   ▼
//! [Tokenizer]  ─── Unicode Semantic Dictionary ───► Operator symbols mapped to paradigms
//!   │
//!   ▼
//! [Paradigm Detector]  ──────────────────────────► Set of active LogicParadigms
//!   │
//!   ▼
//! [AST Builder]  ────────────────────────────────► Typed expression tree
//!   │
//!   ▼
//! [Engine Router / SWITCH]  ─────────────────────► Per-paradigm engine selected
//!   │
//!   ▼
//! [Cross-System Validator]  ─────────────────────► Contradiction detection
//!   │
//!   ▼
//! Verdict { valid, confidence, trace, formal_notation }
//! ```
//!
//! Each stage is fully auditable. Every routing and validation decision is captured
//! in the `LogicTrace`, making the entire reasoning chain inspectable after the fact.
//!
//! ## Deployment targets
//!
//! | Feature flags      | Target                                   |
//! |--------------------|------------------------------------------|
//! | (none / heapless)  | Bare-metal firmware, BIOS-like chip      |
//! | `alloc`            | RTOS, microkernel with allocator         |
//! | `std`              | Linux/macOS/Windows process              |
//!
//! The `alloc` feature enables heap-allocated AST nodes. Without it, expression
//! depth is bounded by the fixed-size `heapless` structures.

#![cfg_attr(not(feature = "std"), no_std)]

#[cfg(feature = "alloc")]
extern crate alloc;

pub mod ast;
pub mod decision;
pub mod engine;
pub mod symbol;

// Re-export the key public surface
pub use ast::{AstNode, Expr, Literal};
pub use decision::{Confidence, CrossValidation, LogicTrace, TraceEntry, Verdict};
pub use engine::{EngineError, EngineId, LogicEngine, Paradigm};
pub use symbol::{SemanticClass, Symbol, UnicodeSemanticDictionary};