ordofp 0.1.0

OrdoFP: Functional programming in Rust with HList, Disiunctio, GAT traits, Optics, and Monad Transformers
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

use ordofp::Probatum;
use ordofp::prelude::*;

#[derive(Debug, PartialEq)]
struct Person {
    name: String,
    age: u32,
}

#[derive(Debug)]
enum ValidationError {
    NameTooShort,
    Underage,
}

fn validate_name(name: &str) -> Result<String, ValidationError> {
    if name.len() < 2 {
        Err(ValidationError::NameTooShort)
    } else {
        Ok(name.to_string())
    }
}

fn validate_age(age: u32) -> Result<u32, ValidationError> {
    if age < 18 {
        Err(ValidationError::Underage)
    } else {
        Ok(age)
    }
}

fn main() {
    println!("--- Example 04: Probatum (Accumulating Errors) ---");

    // Case 1: Success
    let v_name = validate_name("Bob").into_probatum();
    let v_age = validate_age(20).into_probatum();

    let result = Probatum::lift2(|name, age| Person { name, age }, v_name, v_age);

    println!("Success Case: {result:?}");
    assert!(result.is_valid());

    // Case 2: Multiple Errors
    let v_name_fail = validate_name("A").into_probatum(); // Too short
    let v_age_fail = validate_age(15).into_probatum(); // Underage

    let fail_result: Probatum<ValidationError, Person> =
        Probatum::lift2(|name, age| Person { name, age }, v_name_fail, v_age_fail);

    println!("Failure Case: {fail_result:?}");

    if let Probatum::Invalid(errors) = fail_result {
        println!("Errors found: {}", errors.len());
        assert_eq!(errors.len(), 2); // We got BOTH errors, not just the first one
    } else {
        panic!("Should have failed");
    }
}