laminate 0.1.0

Progressive data shaping for Rust — type coercion, format detection, and fault-tolerant deserialization built on serde
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

//! Example: Consuming a messy REST API response
//!
//! Demonstrates: type coercion, path navigation, derive macro with overflow,
//! and diagnostics for auditing what was coerced.

use laminate::{FlexValue, Laminate};
use std::collections::HashMap;

#[derive(Debug, Laminate)]
struct User {
    name: String,
    #[laminate(coerce)]
    age: u32,
    #[laminate(coerce)]
    verified: bool,
    #[laminate(coerce, default)]
    score: f64,
    #[laminate(overflow)]
    extra: HashMap<String, serde_json::Value>,
}

fn main() {
    // Simulated API response — types are messy (strings where numbers expected)
    let api_response = r#"{
        "name": "Alice",
        "age": "28",
        "verified": "true",
        "score": "95.5",
        "department": "engineering",
        "start_date": "2024-01-15"
    }"#;

    // Parse and shape into typed struct
    let (user, diagnostics) = User::from_json(api_response).unwrap();

    println!("User: {} (age {})", user.name, user.age);
    println!("Verified: {}", user.verified);
    println!("Score: {}", user.score);
    println!(
        "Extra fields preserved: {:?}",
        user.extra.keys().collect::<Vec<_>>()
    );

    // Every coercion is recorded — nothing is silent
    println!("\nDiagnostics ({} total):", diagnostics.len());
    for d in &diagnostics {
        println!("  {}", d);
    }

    // Round-trip: extra fields survive serialization
    let value = user.to_value();
    println!("\nRound-trip JSON:");
    println!("{}", serde_json::to_string_pretty(&value).unwrap());
}