async-result-ext 0.1.0

Async extensions for Result<T, E> with async closures.
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

# async-result-ext

Async extensions for Rust’s [`Result<T, E>`].  
This crate provides asynchronous counterparts of the standard `Result` methods (`map`, `and_then`, `map_err`, `inspect`), allowing you to use async closures seamlessly.

---

## ✨ Motivation

The standard library’s `Result` methods (`map`, `and_then`, etc.) only work with **synchronous** closures.  
When writing async code, you often need to `.await` inside these transformations. This crate fills that gap.

Instead of:

```rust
let res: Result<i32, &str> = Ok(5);

let mapped = match res {
    Ok(v) => Ok(async { v * 2 }.await),
    Err(e) => Err(e),
};
```

You can just write:

```rust
use async_result_ext::AsyncResultExt;

let res: Result<i32, &str> = Ok(5);
let mapped = res.async_map(|v| async move { v * 2 }).await;

assert_eq!(mapped, Ok(10));
```

---

## 📦 Installation

Add this to your `Cargo.toml`:

```toml
[dependencies]
async-result-ext = "0.1.0"
```

---

## 🚀 Usage

```rust
use async_result_ext::AsyncResultExt;

#[tokio::main]
async fn main() {
    let r: Result<i32, &str> = Ok(2);

    // async_map: transform Ok values asynchronously
    let doubled = r.async_map(|v| async move { v * 2 }).await;
    assert_eq!(doubled, Ok(4));

    // async_and_then: chain async computations returning Result
    let chained = doubled.async_and_then(|v| async move { Ok(v + 3) }).await;
    assert_eq!(chained, Ok(7));

    // async_map_or: provide a default for Err cases
    let res = Err::<i32, &str>("fail");
    let fallback = res.async_map_or(100, |v| async move { v * 10 }).await;
    assert_eq!(fallback, 100);

    // async_map_err: transform errors asynchronously
    let err: Result<i32, &str> = Err("oops");
    let mapped_err = err.async_map_err(|e| async move { e.len() }).await;
    assert_eq!(mapped_err, Err(4));

    // async_inspect & async_inspect_err: peek into values without changing them
    let ok: Result<i32, &str> = Ok(42);
    ok.async_inspect(|v| async move {
        println!("Got value: {v}");
    }).await;

    let err: Result<i32, &str> = Err("fail");
    err.async_inspect_err(|e| async move {
        eprintln!("Error: {e}");
    }).await;
}
```

---

## 📖 Provided Methods

- `async_map` – async version of [`Result::map`]
- `async_and_then` – async version of [`Result::and_then`]
- `async_map_or` – async version of [`Result::map_or`]
- `async_map_or_else` – async version of [`Result::map_or_else`]
- `async_map_err` – async version of [`Result::map_err`]
- `async_inspect` – async version of [`Result::inspect`]
- `async_inspect_err` – async version of [`Result::inspect_err`]

---

## ⚡ Features

- Minimal and lightweight  
- No dependencies (except your async runtime, e.g. Tokio or async-std)  
- Familiar API – mirrors the standard library’s `Result` methods  

---

## 🔧 License

MIT License. See [LICENSE](LICENSE.txt) for details.