Checked vs Unchecked Exceptions

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

// Java's Exception Hierarchy
// 
// Throwable (base class for all throwables)
// ├── Error (unchecked - JVM/system problems, not meant to be caught)
// │   ├── OutOfMemoryError
// │   ├── StackOverflowError
// │   └── ...
// └── Exception (base for application exceptions)
//     ├── RuntimeException (unchecked - programming errors)
//     │   ├── NullPointerException
//     │   ├── IllegalArgumentException
//     │   ├── IndexOutOfBoundsException
//     │   └── ...
//     └── [All other Exception subclasses] (checked)
//         ├── IOException
//         ├── SQLException  
//         ├── ParseException
//         └── ...
 
// CHECKED EXCEPTION - Must be declared and handled
public class FileService {
    
    // 'throws' clause is REQUIRED by compiler
    public String readFile(String path) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(path));
        try {
            return reader.readLine();
        } finally {
            reader.close();
        }
    }
    
    // CALLER MUST handle or propagate
    public void processFile(String path) {
        try {
            String content = readFile(path);  // Must handle IOException
            System.out.println(content);
        } catch (IOException e) {
            System.err.println("Failed to read file: " + e.getMessage());
        }
    }
    
    // Alternative: propagate to caller
    public void processFileOrThrow(String path) throws IOException {
        String content = readFile(path);  // Propagated
        System.out.println(content);
    }
}
 
// UNCHECKED EXCEPTION - No declaration required
public class Calculator {
    
    // No 'throws' clause needed
    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Cannot divide by zero");
        }
        return a / b;
    }
    
    // Caller may optionally handle
    public void calculate() {
        int result = divide(10, 0);  // Compiles fine, throws at runtime
    }
}
 
// MODERN JAVA (try-with-resources, multi-catch)
public class ModernJava {
    
    public void processMultipleResources(String path) {
        // try-with-resources handles cleanup automatically
        try (FileInputStream fis = new FileInputStream(path);
             BufferedReader reader = new BufferedReader(
                 new InputStreamReader(fis))) {
            
            String line;
            while ((line = reader.readLine()) != null) {
                process(line);
            }
            
        } catch (FileNotFoundException e) {
            // Handle specific exception
            handleMissingFile(path);
            
        } catch (IOException e) {
            // Handle more general exception
            handleIOError(e);
        }
    }
    
    // Multi-catch for similar handling
    public void handleMultipleExceptions() {
        try {
            riskyOperation();
        } catch (IOException | SQLException e) {
            // Handle both the same way
            logger.error("Operation failed", e);
        }
    }
}

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

// C# Exception Hierarchy
// All exceptions are unchecked - no compiler enforcement
 
// System.Exception (base class)
// ├── System.SystemException (system-level exceptions)
// │   ├── NullReferenceException
// │   ├── ArgumentException
// │   │   ├── ArgumentNullException
// │   │   └── ArgumentOutOfRangeException
// │   ├── InvalidOperationException
// │   └── ...
// ├── System.ApplicationException (deprecated legacy base)
// └── Custom application exceptions
 
// NO THROWS CLAUSE - all exceptions are unchecked
public class FileService
{
    // Documentation replaces compiler enforcement
    /// <summary>
    /// Reads the first line of a file.
    /// </summary>
    /// <param name="path">The file path to read.</param>
    /// <returns>The first line of the file.</returns>
    /// <exception cref="FileNotFoundException">
    /// Thrown when the specified file does not exist.
    /// </exception>
    /// <exception cref="IOException">
    /// Thrown when an I/O error occurs while reading.
    /// </exception>
    public string ReadFile(string path)
    {
        // No throws clause needed
        using var reader = new StreamReader(path);
        return reader.ReadLine();
    }
    
    // Caller optionally handles
    public void ProcessFile(string path)
    {
        try
        {
            string content = ReadFile(path);
            Console.WriteLine(content);
        }
        catch (FileNotFoundException)
        {
            Console.Error.WriteLine($"File not found: {path}");
        }
        catch (IOException e)
        {
            Console.Error.WriteLine($"IO error: {e.Message}");
        }
    }
    
    // Or doesn't handle - compiles fine
    public void ProcessFileUnsafely(string path)
    {
        string content = ReadFile(path);  // No compiler warning
        Console.WriteLine(content);
    }
}
 
// CUSTOM EXCEPTIONS in C#
public class OrderNotFoundException : Exception
{
    public string OrderId { get; }
    
    public OrderNotFoundException(string orderId)
        : base($"Order not found: {orderId}")
    {
        OrderId = orderId;
    }
    
    public OrderNotFoundException(string orderId, Exception inner)
        : base($"Order not found: {orderId}", inner)
    {
        OrderId = orderId;
    }
}
 
// MODERN C# PATTERNS
public class ModernCSharp
{
    // Pattern matching in catch (C# 6+)
    public void HandleWithPatternMatching()
    {
        try
        {
            RiskyOperation();
        }
        catch (HttpRequestException e) when (e.StatusCode == HttpStatusCode.NotFound)
        {
            HandleNotFound();
        }
        catch (HttpRequestException e) when (e.StatusCode == HttpStatusCode.Unauthorized)
        {
            HandleUnauthorized();
        }
        catch (HttpRequestException e)
        {
            HandleOtherHttpError(e);
        }
    }
    
    // Exception filters (when clause)
    public void RetryableExceptionHandling()
    {
        try
        {
            CallExternalService();
        }
        catch (ServiceException e) when (e.IsRetryable)
        {
            ScheduleRetry();
        }
        catch (ServiceException e)
        {
            ReportPermanentFailure(e);
        }
    }
}

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

// KOTLIN - All exceptions are unchecked
// No throws clause in method signatures
 
class FileService {
    
    // No throws clause needed - compiles without any exception handling
    fun readFile(path: String): String {
        return File(path).readText()  // Throws IOException - unchecked in Kotlin
    }
    
    // Caller may optionally handle
    fun processFile(path: String) {
        try {
            val content = readFile(path)
            println(content)
        } catch (e: FileNotFoundException) {
            println("File not found: $path")
        } catch (e: IOException) {
            println("IO error: ${e.message}")
        }
    }
    
    // Or not handle - compiles fine
    fun processFileUnsafe(path: String) {
        val content = readFile(path)  // No compiler warning
        println(content)
    }
}
 
// JAVA INTEROP with @Throws
// When Kotlin code is called from Java, use @Throws
 
class DatabaseService {
    
    // Without @Throws: Java caller won't know about exception
    fun queryUnsafe(): List<User> {
        // throws SQLException internally
        return executeQuery("SELECT * FROM users")
    }
    
    // With @Throws: Java caller will see throws clause
    @Throws(SQLException::class)
    fun query(): List<User> {
        return executeQuery("SELECT * FROM users")
    }
    
    // Multiple exception types
    @Throws(IOException::class, ParseException::class)
    fun loadConfiguration(path: String): Config {
        val content = File(path).readText()
        return parseConfig(content)
    }
}
 
// KOTLIN IDIOMATIC PATTERNS
// Prefer sealed classes and Result for expected failures
 
sealed class FileResult {
    data class Success(val content: String) : FileResult()
    data class NotFound(val path: String) : FileResult()
    data class AccessDenied(val path: String) : FileResult()
    data class Error(val exception: Exception) : FileResult()
}
 
class IdiomsService {
    
    // Return sealed class instead of throwing
    fun readFileSafe(path: String): FileResult {
        return try {
            FileResult.Success(File(path).readText())
        } catch (e: FileNotFoundException) {
            FileResult.NotFound(path)
        } catch (e: SecurityException) {
            FileResult.AccessDenied(path)
        } catch (e: Exception) {
            FileResult.Error(e)
        }
    }
    
    // Using Kotlin's Result type (since 1.3)
    fun readFileResult(path: String): Result<String> {
        return runCatching {
            File(path).readText()
        }
    }
    
    // Caller uses when/fold
    fun processWithResult(path: String) {
        val result = readFileResult(path)
        
        result.fold(
            onSuccess = { content ->
                println("Content: $content")
            },
            onFailure = { exception ->
                println("Failed: ${exception.message}")
            }
        )
        
        // Or with getOrNull/getOrElse
        val content = result.getOrElse { "default content" }
        
        // Or with getOrThrow (rethrow the exception)
        try {
            val strictContent = result.getOrThrow()
        } catch (e: Exception) {
            println("Rethrown: ${e.message}")
        }
    }
}
 
// EXTENSION FUNCTIONS for cleaner error handling
inline fun <T> tryOrNull(block: () -> T): T? {
    return try {
        block()
    } catch (e: Exception) {
        null
    }
}
 
// Usage
fun example() {
    val content = tryOrNull { File("config.json").readText() }
    if (content != null) {
        processContent(content)
    } else {
        useDefaults()
    }
}

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
144
145
146
147
148

# Python Exception Hierarchy (simplified)
#
# BaseException
# ├── SystemExit
# ├── KeyboardInterrupt
# ├── GeneratorExit
# └── Exception
#     ├── StopIteration
#     ├── ArithmeticError (ZeroDivisionError, OverflowError, ...)
#     ├── LookupError (IndexError, KeyError)
#     ├── AttributeError
#     ├── OSError (FileNotFoundError, PermissionError, ...)
#     ├── ValueError
#     ├── TypeError
#     └── ... many more
 
# BASIC EXCEPTION HANDLING
def read_file(path: str) -> str:
    """
    Read and return file contents.
    
    Args:
        path: Path to the file to read.
        
    Returns:
        The file contents as a string.
        
    Raises:
        FileNotFoundError: If the file doesn't exist.
        PermissionError: If access is denied.
        UnicodeDecodeError: If the file isn't valid UTF-8.
    """
    # No declaration in signature - documentation only
    with open(path, 'r', encoding='utf-8') as f:
        return f.read()
 
 
def process_file(path: str) -> None:
    """Process a file with error handling."""
    try:
        content = read_file(path)
        print(f"Content: {content[:100]}...")
        
    except FileNotFoundError:
        print(f"File not found: {path}")
        
    except PermissionError:
        print(f"Permission denied: {path}")
        
    except UnicodeDecodeError as e:
        print(f"Encoding error: {e}")
        
    except Exception as e:
        # Catch-all for unexpected exceptions
        print(f"Unexpected error: {type(e).__name__}: {e}")
        raise  # Re-raise to let caller handle
 
 
# EAFP vs LBYL (Easier to Ask Forgiveness vs Look Before You Leap)
 
# LBYL style (more common in other languages)
def get_value_lbyl(data: dict, key: str, default=None):
    if key in data:
        return data[key]
    return default
 
 
# EAFP style (Pythonic)
def get_value_eafp(data: dict, key: str, default=None):
    try:
        return data[key]
    except KeyError:
        return default
 
 
# CONTEXT MANAGERS (like try-with-resources)
from contextlib import contextmanager
 
@contextmanager
def managed_resource(name: str):
    """Context manager for automatic cleanup."""
    resource = acquire_resource(name)
    try:
        yield resource
    except Exception as e:
        log_error(f"Error with resource {name}: {e}")
        raise
    finally:
        release_resource(resource)
 
 
def use_managed_resource():
    with managed_resource("database") as db:
        db.execute("SELECT * FROM users")
    # Resource automatically released, even on exception
 
 
# CUSTOM EXCEPTIONS
class ApplicationError(Exception):
    """Base exception for application errors."""
    pass
 
 
class OrderError(ApplicationError):
    """Base exception for order-related errors."""
    def __init__(self, order_id: str, message: str):
        self.order_id = order_id
        super().__init__(f"Order {order_id}: {message}")
 
 
class OrderNotFoundException(OrderError):
    """Raised when an order cannot be found."""
    def __init__(self, order_id: str):
        super().__init__(order_id, "Order not found")
 
 
class OrderNotCancellableError(OrderError):
    """Raised when an order cannot be cancelled."""
    def __init__(self, order_id: str, status: str):
        self.status = status
        super().__init__(order_id, f"Cannot cancel order in status {status}")
 
 
# EXCEPTION CHAINING (Python 3)
def process_order(order_id: str) -> None:
    try:
        order = database.find_order(order_id)
    except DatabaseError as e:
        # Chain the original exception
        raise OrderError(order_id, "Database lookup failed") from e
 
 
# EXCEPTION GROUPS (Python 3.11+)
def process_multiple_items(items: list) -> None:
    """Process items, collecting all errors."""
    errors = []
    results = []
    
    for item in items:
        try:
            result = process_item(item)
            results.append(result)
        except Exception as e:
            errors.append(e)
    
    if errors:
        # Raise all errors together
        raise ExceptionGroup("Multiple processing errors", errors)

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
144
145

package main
 
import (
    "errors"
    "fmt"
    "io/ioutil"
    "os"
)
 
// GO ERROR HANDLING - Errors are values, not exceptions
 
// Functions return error as last value
func readFile(path string) (string, error) {
    // os.ReadFile returns ([]byte, error)
    data, err := ioutil.ReadFile(path)
    if err != nil {
        return "", err  // Return the error to caller
    }
    return string(data), nil  // Return nil error on success
}
 
// Caller must explicitly check error
func processFile(path string) {
    content, err := readFile(path)
    if err != nil {
        // Handle error - cannot ignore without explicit decision
        fmt.Printf("Error reading file: %v
", err)
        return
    }
    fmt.Printf("Content: %s
", content)
}
 
// IGNORING ERRORS - Explicit and obvious
func dangerouslyIgnoreError(path string) {
    content, _ := readFile(path)  // Underscore explicitly ignores error
    fmt.Println(content)          // May be empty if error occurred
}
 
 
// CUSTOM ERROR TYPES
// Simple error with errors.New
var ErrNotFound = errors.New("not found")
var ErrPermissionDenied = errors.New("permission denied")
 
// Error with context using fmt.Errorf
func findUser(id string) (*User, error) {
    user := database.FindByID(id)
    if user == nil {
        return nil, fmt.Errorf("user not found: %s", id)
    }
    return user, nil
}
 
// Custom error type for rich error handling
type OrderError struct {
    OrderID string
    Op      string
    Err     error
}
 
func (e *OrderError) Error() string {
    return fmt.Sprintf("order %s: %s: %v", e.OrderID, e.Op, e.Err)
}
 
func (e *OrderError) Unwrap() error {
    return e.Err
}
 
func cancelOrder(orderID string) error {
    order, err := findOrder(orderID)
    if err != nil {
        return &OrderError{
            OrderID: orderID,
            Op:      "cancel",
            Err:     err,
        }
    }
    
    if order.Status != "pending" {
        return &OrderError{
            OrderID: orderID,
            Op:      "cancel",
            Err:     fmt.Errorf("invalid status: %s", order.Status),
        }
    }
    
    return nil
}
 
 
// ERROR WRAPPING (Go 1.13+)
func processOrder(orderID string) error {
    order, err := findOrder(orderID)
    if err != nil {
        // Wrap error with context using %w
        return fmt.Errorf("processing order %s: %w", orderID, err)
    }
    return nil
}
 
// ERROR CHECKING with errors.Is and errors.As (Go 1.13+)
func handleOrderError(err error) {
    // Check for specific sentinel error
    if errors.Is(err, ErrNotFound) {
        fmt.Println("Order not found - create new one")
        return
    }
    
    // Extract specific error type
    var orderErr *OrderError
    if errors.As(err, &orderErr) {
        fmt.Printf("Order %s failed during %s
", 
            orderErr.OrderID, orderErr.Op)
        return
    }
    
    // Generic error
    fmt.Printf("Unknown error: %v
", err)
}
 
 
// PANIC/RECOVER - Only for truly exceptional cases
func mustReadConfig(path string) Config {
    config, err := readConfig(path)
    if err != nil {
        // Panic for unrecoverable startup failures
        panic(fmt.Sprintf("cannot read config: %v", err))
    }
    return config
}
 
// Recover from panic (typically in middleware/top-level)
func safeHandler(handler func()) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Recovered from panic: %v
", r)
        }
    }()
    handler()
}

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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

// RUST ERROR HANDLING - Type-safe with Result and Option
 
use std::fs::File;
use std::io::{self, Read, BufReader, BufRead};
use std::num::ParseIntError;
 
// Result<T, E> - Either success value T or error value E
// enum Result<T, E> {
//     Ok(T),
//     Err(E),
// }
 
// Functions return Result instead of throwing
fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;  // ? propagates error
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)  // Wrap success value in Ok
}
 
// PATTERN MATCHING for error handling
fn process_file(path: &str) {
    match read_file(path) {
        Ok(content) => {
            println!("Content: {}", content);
        }
        Err(e) => {
            // Pattern match on error kind
            match e.kind() {
                io::ErrorKind::NotFound => {
                    println!("File not found: {}", path);
                }
                io::ErrorKind::PermissionDenied => {
                    println!("Permission denied: {}", path);
                }
                _ => {
                    println!("IO error: {}", e);
                }
            }
        }
    }
}
 
// THE ? OPERATOR - Ergonomic error propagation
fn read_first_line(path: &str) -> Result<String, io::Error> {
    let file = File::open(path)?;      // Returns Err if open fails
    let reader = BufReader::new(file);
    let mut line = String::new();
    reader.lines()
        .next()
        .ok_or_else(|| io::Error::new(
            io::ErrorKind::UnexpectedEof, 
            "Empty file"
        ))??;                          // ? on Option, then on Result
    Ok(line)
}
 
// Equivalent without ? operator (verbose)
fn read_first_line_verbose(path: &str) -> Result<String, io::Error> {
    let file = match File::open(path) {
        Ok(f) => f,
        Err(e) => return Err(e),
    };
    // ... much more verbose
    todo!()
}
 
 
// CUSTOM ERROR TYPES
use std::fmt;
use std::error::Error;
 
#[derive(Debug)]
enum OrderError {
    NotFound(String),
    InvalidStatus { order_id: String, status: String },
    DatabaseError(String),
}
 
impl fmt::Display for OrderError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            OrderError::NotFound(id) => 
                write!(f, "Order not found: {}", id),
            OrderError::InvalidStatus { order_id, status } => 
                write!(f, "Order {} has invalid status: {}", order_id, status),
            OrderError::DatabaseError(msg) => 
                write!(f, "Database error: {}", msg),
        }
    }
}
 
impl Error for OrderError {}
 
// Using custom error
fn cancel_order(order_id: &str) -> Result<(), OrderError> {
    let order = find_order(order_id)
        .ok_or_else(|| OrderError::NotFound(order_id.to_string()))?;
    
    if order.status != "pending" {
        return Err(OrderError::InvalidStatus {
            order_id: order_id.to_string(),
            status: order.status.to_string(),
        });
    }
    
    Ok(())
}
 
 
// OPTION<T> for absence (like Optional/Maybe)
// enum Option<T> {
//     Some(T),
//     None,
// }
 
fn find_user(id: &str) -> Option<User> {
    // Returns Some(user) or None
    users.get(id).cloned()
}
 
fn process_user(id: &str) {
    match find_user(id) {
        Some(user) => println!("Found: {}", user.name),
        None => println!("User not found"),
    }
    
    // Or with combinators
    let name = find_user(id)
        .map(|u| u.name)
        .unwrap_or_else(|| "Unknown".to_string());
}
 
 
// THISERROR AND ANYHOW - Popular error handling crates
// thiserror - for library error types
use thiserror::Error;
 
#[derive(Error, Debug)]
enum PaymentError {
    #[error("insufficient funds: needed {needed}, available {available}")]
    InsufficientFunds { needed: u64, available: u64 },
    
    #[error("invalid card: {0}")]
    InvalidCard(String),
    
    #[error(transparent)]
    DatabaseError(#[from] DatabaseError),
}
 
// anyhow - for application error handling
use anyhow::{Context, Result as AnyhowResult};
 
fn load_config(path: &str) -> AnyhowResult<Config> {
    let content = std::fs::read_to_string(path)
        .context("Failed to read config file")?;
    
    let config: Config = serde_json::from_str(&content)
        .context("Failed to parse config JSON")?;
    
    Ok(config)
}

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

// SWIFT ERROR HANDLING - throws keyword without specific types
 
import Foundation
 
// Errors conform to Error protocol
enum FileError: Error {
    case notFound(path: String)
    case permissionDenied(path: String)
    case invalidEncoding
}
 
enum OrderError: Error {
    case notFound(orderId: String)
    case invalidStatus(orderId: String, status: String)
    case paymentFailed(reason: String)
}
 
// THROWING FUNCTIONS - marked with 'throws'
// Note: doesn't specify WHICH errors can be thrown
func readFile(path: String) throws -> String {
    guard FileManager.default.fileExists(atPath: path) else {
        throw FileError.notFound(path: path)
    }
    
    guard FileManager.default.isReadableFile(atPath: path) else {
        throw FileError.permissionDenied(path: path)
    }
    
    // This also throws, but any Error type
    return try String(contentsOfFile: path, encoding: .utf8)
}
 
// CALLING THROWING FUNCTIONS
 
// Option 1: do-catch (like try-catch)
func processFile(path: String) {
    do {
        let content = try readFile(path: path)
        print("Content: (content)")
    } catch FileError.notFound(let path) {
        print("File not found: (path)")
    } catch FileError.permissionDenied(let path) {
        print("Permission denied: (path)")
    } catch {
        // 'error' is implicitly available
        print("Unexpected error: (error)")
    }
}
 
// Option 2: try? - converts to optional (returns nil on error)
func processFileOptional(path: String) {
    if let content = try? readFile(path: path) {
        print("Content: (content)")
    } else {
        print("Failed to read file")
    }
}
 
// Option 3: try! - force unwrap (crashes on error)
func processFileForce(path: String) {
    // Only use when you're CERTAIN it won't fail
    let content = try! readFile(path: path)
    print(content)
}
 
 
// PROPAGATING ERRORS
// Just add 'throws' to your function
func processMultipleFiles(paths: [String]) throws -> [String] {
    var contents: [String] = []
    for path in paths {
        let content = try readFile(path: path)  // Propagates
        contents.append(content)
    }
    return contents
}
 
 
// RETHROWS - for higher-order functions
func withRetry<T>(attempts: Int, operation: () throws -> T) rethrows -> T {
    var lastError: Error?
    
    for _ in 0..<attempts {
        do {
            return try operation()
        } catch {
            lastError = error
        }
    }
    
    throw lastError!
}
 
 
// RESULT TYPE (Swift 5+) - Alternative to throwing
enum Result<Success, Failure: Error> {
    case success(Success)
    case failure(Failure)
}
 
func readFileResult(path: String) -> Result<String, FileError> {
    do {
        let content = try readFile(path: path)
        return .success(content)
    } catch let error as FileError {
        return .failure(error)
    } catch {
        return .failure(.invalidEncoding)
    }
}
 
func processWithResult(path: String) {
    let result = readFileResult(path: path)
    
    switch result {
    case .success(let content):
        print("Content: (content)")
    case .failure(let error):
        print("Error: (error)")
    }
    
    // Or with Result methods
    let content = result.map { $0.uppercased() }
    let safeContent = try? result.get()
}