sumtype 0.4.0

Generate zerocost anonymous sum types that implement common traits
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
137
138
139
140
141
142
143

use sumtype::sumtype;
use std::fmt;
use std::error::Error;

// Define custom error types for testing
#[derive(Debug)]
struct IoError(String);

impl fmt::Display for IoError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "IO Error: {}", self.0)
    }
}

impl std::error::Error for IoError {}

#[derive(Debug)]
struct ParseError(String);

impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Parse Error: {}", self.0)
    }
}

impl std::error::Error for ParseError {}

#[derive(Debug)]
struct NetworkError {
    code: u32,
    message: String,
}

impl fmt::Display for NetworkError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Network Error {}: {}", self.code, self.message)
    }
}

impl std::error::Error for NetworkError {}

// Test function that returns different error types
#[sumtype(sumtype::traits::Error)]
fn get_error(error_type: &str) -> impl std::error::Error {
    match error_type {
        "io" => sumtype!(IoError("Failed to read file".to_string())),
        "parse" => sumtype!(ParseError("Invalid JSON format".to_string())),
        "network" => sumtype!(NetworkError { 
            code: 404, 
            message: "Not Found".to_string() 
        }),
        _ => sumtype!(IoError("Unknown error".to_string())),
    }
}

// Test function that can be used where std::error::Error is expected
fn handle_error(e: impl std::error::Error) -> String {
    format!("Handled: {}", e)
}

// Test function that works with Error + Send + Sync bounds
#[allow(dead_code)]
fn handle_error_threadsafe(e: impl std::error::Error + Send + Sync) -> String {
    format!("Thread-safe handled: {}", e)
}

#[test]
fn test_error_display() {
    let io_err = get_error("io");
    assert_eq!(format!("{}", io_err), "IO Error: Failed to read file");
    
    let parse_err = get_error("parse");
    assert_eq!(format!("{}", parse_err), "Parse Error: Invalid JSON format");
    
    let network_err = get_error("network");
    assert_eq!(format!("{}", network_err), "Network Error 404: Not Found");
}

#[test]
fn test_error_debug() {
    let io_err = get_error("io");
    let debug_str = format!("{:?}", io_err);
    assert!(debug_str.contains("IoError"));
    
    let parse_err = get_error("parse");
    let debug_str = format!("{:?}", parse_err);
    assert!(debug_str.contains("ParseError"));
}

#[test]
fn test_error_handling() {
    let io_err = get_error("io");
    let result = handle_error(io_err);
    assert_eq!(result, "Handled: IO Error: Failed to read file");
    
    let parse_err = get_error("parse");
    let result = handle_error(parse_err);
    assert_eq!(result, "Handled: Parse Error: Invalid JSON format");
}

#[test]
fn test_error_source() {
    let io_err = get_error("io");
    // Test that source() method is available
    assert!(io_err.source().is_none());
    
    let parse_err = get_error("parse");
    assert!(parse_err.source().is_none());
}

#[test]
fn test_error_as_trait_object() {
    let error: Box<dyn std::error::Error> = Box::new(get_error("io"));
    assert_eq!(format!("{}", error), "IO Error: Failed to read file");
}

// Test with generic function that accepts Error trait
fn process_result<T, E: std::error::Error>(result: Result<T, E>) -> String {
    match result {
        Ok(_) => "Success".to_string(),
        Err(e) => format!("Error occurred: {}", e),
    }
}

#[test]
fn test_error_in_result() {
    let err = get_error("network");
    let result: Result<(), _> = Err(err);
    let processed = process_result(result);
    assert_eq!(processed, "Error occurred: Network Error 404: Not Found");
}

// Test with explicit type annotation
#[sumtype(sumtype::traits::Error)]
fn get_typed_error() -> sumtype!() {
    sumtype!(IoError("Explicit type".to_string()), IoError)
}

#[test]
fn test_explicit_type() {
    let err = get_typed_error();
    assert_eq!(format!("{}", err), "IO Error: Explicit type");
}