rustica 0.12.0

Rustica is a functional programming library for the Rust language.
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

use rustica::error::{
    ErrorPipeline, accumulate_context, format_error_chain, with_context_result,
    wrap_in_composable_result_boxed,
};

fn parse_config(content: &str) -> Result<i32, &'static str> {
    content.parse::<i32>().map_err(|_| "Invalid number format")
}

fn connect_db(timeout_ms: i32) -> Result<String, &'static str> {
    if timeout_ms < 100 {
        Err("Connection timeout too short")
    } else {
        Ok("db_connection_handle".to_string())
    }
}

fn process_data(connection: String, value: i32) -> Result<String, &'static str> {
    if value % 2 == 0 {
        Ok(format!("Processed {} rows via {}", value, connection))
    } else {
        Err("Value must be even number")
    }
}

fn main() {
    println!("=== Example 1: Correct Context Accumulation ===\n");

    let config_str = "not_a_number";

    let result = ErrorPipeline::new(wrap_in_composable_result_boxed(parse_config(config_str)))
        .with_context("Failed to parse configuration file")
        .and_then(|cfg| {
            with_context_result(connect_db(cfg), "DB connection attempt failed")
                .map_err(|mut e| {
                    *e = e.with_context("Error occurred during DB connection".to_string());
                    e
                })
                .map(|conn| (conn, cfg))
        })
        .and_then(|(connection, cfg)| {
            with_context_result(
                process_data(connection, cfg),
                "Error during data processing",
            )
            .map_err(|mut e| {
                *e = e.with_context("Failed to complete data processing pipeline".to_string());
                e
            })
        })
        .recover(|mut boxed_e| {
            *boxed_e = boxed_e.with_context("Recovery attempt initiated".to_string());
            Err(boxed_e)
        })
        .finish();

    match result {
        Ok(message) => println!("Success: {}", message),
        Err(err) => {
            println!("Error occurred:\n{}\n", format_error_chain(&err));
        },
    }

    println!("=== Example 2: Successful Pipeline ===\n");

    let config_str = "200";

    let result = ErrorPipeline::new(wrap_in_composable_result_boxed(parse_config(config_str)))
        .with_context("Failed to parse configuration file")
        .and_then(|cfg| {
            with_context_result(connect_db(cfg), "DB connection attempt failed")
                .map_err(|mut e| {
                    *e = e.with_context("Error occurred during DB connection".to_string());
                    e
                })
                .map(|conn| (conn, cfg))
        })
        .and_then(|(connection, cfg)| {
            with_context_result(
                process_data(connection, cfg),
                "Error during data processing",
            )
            .map_err(|mut e| {
                *e = e.with_context("Failed to complete data processing pipeline".to_string());
                e
            })
        })
        .finish();

    match result {
        Ok(message) => println!("Success: {}\n", message),
        Err(err) => {
            println!("Error occurred:\n{}\n", format_error_chain(&err));
        },
    }

    println!("=== Example 3: Bulk Context Accumulation ===\n");

    let operation_contexts = vec![
        "Loading user preferences",
        "Validating authentication token",
        "Establishing secure connection",
        "Executing transaction",
    ];

    let chained_error = accumulate_context(
        "Transaction failed: insufficient permissions",
        operation_contexts,
    );

    println!(
        "Bulk accumulated error analysis:\n{}",
        format_error_chain(&chained_error)
    );
}