noml 0.9.0

High-performance dynamic configuration language with format preservation, environment variables, native types, string interpolation, and TOML compatibility. Blazing-fast parsing at 25µs with zero-copy architecture.
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
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

#![allow(clippy::uninlined_format_args)]

// TOML vs NOML Feature Comparison Analysis
// Focusing on READ-TIME functionality only

fn main() {
    println!("=== TOML vs NOML: Read-Time Feature Analysis ===\n");

    // Core TOML features that both support
    let toml_features = vec![
        "String values",
        "Integer values",
        "Float values",
        "Boolean values",
        "Arrays",
        "Tables (objects)",
        "Nested tables",
        "Array of tables",
        "Comments (preserved in AST)",
        "Unicode support",
        "Multi-line strings",
        "Literal strings",
        "Basic key-value access",
    ];

    // Additional NOML read-time features
    let noml_exclusive_features = vec![
        // Path-based access
        "Dot-notation path access (\"server.database.port\")",
        "Deep nesting without section syntax",
        // Native type system
        "Native size parsing (@size(\"10MB\") -> bytes)",
        "Native duration parsing (@duration(\"30s\") -> seconds)",
        "Native URL parsing (@url(\"https://...\") -> URL object)",
        "Native binary data (@base64(\"...\"))",
        // Dynamic resolution (at read-time)
        "Environment variable resolution (env(\"VAR\", \"default\"))",
        "String interpolation (\"Hello ${name}!\")",
        "Include file composition (include \"other.noml\")",
        // Advanced value access
        "Type coercion (string \"123\" -> integer 123)",
        "Boolean parsing (\"yes\"/\"true\"/\"1\" -> true)",
        "Flexible number parsing (\"3.14\" as int/float)",
        "Optional value access with defaults",
        // Source preservation for tooling
        "Exact source location tracking",
        "Format preservation (spacing, comments)",
        "Round-trip editing capability",
        // Error handling
        "Rich error messages with source context",
        "Path-based error reporting",
        "Type mismatch diagnostics",
    ];

    println!("📊 FEATURE INVENTORY");
    println!("TOML baseline features: {}", toml_features.len());
    println!("NOML exclusive features: {}", noml_exclusive_features.len());
    println!(
        "Total NOML features: {}",
        toml_features.len() + noml_exclusive_features.len()
    );

    let functionality_increase =
        (noml_exclusive_features.len() as f64 / toml_features.len() as f64) * 100.0;
    let total_advantage = ((toml_features.len() + noml_exclusive_features.len()) as f64
        / toml_features.len() as f64)
        * 100.0
        - 100.0;

    println!("\n📈 FUNCTIONALITY ANALYSIS");
    println!(
        "NOML adds {:.0}% more read-time functionality than TOML baseline",
        functionality_increase
    );
    println!(
        "NOML has {:.0}% more total read features than TOML",
        total_advantage
    );

    println!("\n🏆 FEATURE CATEGORIES");

    println!("\n✅ TOML Baseline Features (both support):");
    for (i, feature) in toml_features.iter().enumerate() {
        println!("  {}: {}", i + 1, feature);
    }

    println!("\n🚀 NOML Exclusive Read Features:");
    for (i, feature) in noml_exclusive_features.iter().enumerate() {
        println!("  {}: {}", i + 1, feature);
    }

    // Performance vs functionality trade-off analysis
    println!("\n📊 PERFORMANCE vs FUNCTIONALITY TRADE-OFF");
    println!("Performance cost: 2x slower than TOML");
    println!("Functionality gain: {:.0}% more features", total_advantage);
    println!(
        "Value ratio: {:.1}% functionality per 1% performance cost",
        total_advantage / 100.0
    );

    println!("\n🎯 POUND-FOR-POUND ASSESSMENT");
    println!("TOML: Fast, simple key-value with basic nesting");
    println!(
        "NOML: 2x cost for {}x functionality ({}% more features)",
        (total_advantage / 100.0) + 1.0,
        total_advantage
    );

    // Break down by impact
    println!("\n💥 HIGH-IMPACT EXCLUSIVE FEATURES");
    let high_impact = vec![
        "Path-based access (eliminates navigation boilerplate)",
        "Environment variables (eliminates manual getenv())",
        "Native types (eliminates custom parsing)",
        "String interpolation (eliminates manual templating)",
    ];

    for feature in high_impact {
        println!("  • {}", feature);
    }

    println!("\n🤔 THE VERDICT");
    println!("TOML: 13 core features, blazing fast");
    println!(
        "NOML: {} total features, 2x slower",
        toml_features.len() + noml_exclusive_features.len()
    );
    println!(
        "Trade-off: Pay 100% performance cost for {:.0}% more functionality",
        total_advantage
    );
    println!(
        "That's {:.1} features per performance point!",
        total_advantage / 100.0
    );
}