# Reqw
> **⚠️ Warning:** This crate is only published to provide documentation on [docs.rs](https://docs.rs/reqw).
> It is **not intended to be used via `cargo add`**.
> Please copy the code manually into your project.
> **Note:** This is not a library — just a _code snippet_ you can copy-paste into your project.
> Why? Because Rust treats each crate version as a unique type.
> If this helper were a real library and depended on `reqwest`, it would only work when your project uses **exactly** the same version of `reqwest`.
> Supporting every version would require releasing multiple versions of this crate — which is overkill for a tiny helper like this.
> So instead, it’s just a clean, dependency-free snippet you can drop into your own codebase.
---
## How to use
Save the following code as reqw.rs somewhere in your project (e.g., in src/utils/reqw.rs):
````rust
pub enum Error {
Http(reqwest::Response),
Transport(reqwest::Error),
}
/// This function is re-estimates response of reqwest
///
/// - Returns `Ok(reqwest::Response)` if status code is 200-299
/// - Returns `Err(Error::Http)` if the status code is not 2xx
/// - Returns `Err(Error::Transport)` if there was a transport error
///
/// # Examples
///
/// ```rust
/// async fn run() {
/// let result = reqw::est(reqwest::get("https://example.com").await);
/// assert!(result.is_ok());
/// }
/// ```
pub fn est(result: Result<reqwest::Response, reqwest::Error>) -> Result<reqwest::Response, Error> {
match result {
Ok(r) if r.status().is_success() => Ok(r),
Ok(r) => Err(Error::Http(r)),
Err(e) => Err(Error::Transport(e)),
}
}
````
Then, use it like this:
```rust
mod utils;
use utils::reqw;
#[tokio::main]
async fn main() {
match reqw::est(reqwest::get("https://example.com").await) {
Ok(res) => println!("✅ Success! Status: {}", res.status()),
Err(reqw::Error::Http(res)) => eprintln!("❌ HTTP error: {}", res.status()),
Err(reqw::Error::Transport(err)) => eprintln!("💥 Transport error: {}", err),
}
}
```
## What `Reqw::est()` does
`Reqw::est()` stands for **"estimate"** — it redefines how to interpret [`reqwest`](https://docs.rs/reqwest)'s `Result<Response, Error>`
by re-estimating the outcome of an HTTP request into a simpler, cleaner success/error model that better fits real-world application logic.
In `reqwest`, the result of an HTTP request looks like this:
```rust
Result<reqwest::Response, reqwest::Error>
```
This has three possible real-world meanings:
- ✅ Ok(res) where res.status().is_success() (e.g., 200 OK)
- ✅ Ok(res) where res.status() is an error (e.g., 404, 500)
- ❌ Err(e) for transport-level failures (e.g., timeout, DNS failure)
By default, reqwest treats all Ok(Response) as "success",
even if the server returned a 500 Internal Server Error — because the HTTP protocol worked.
`Reqw::est()` reinterprets that like this:
```rust
Result<reqwest::Response, reqw::Error>
```
With:
- ✅ Ok(res) → only if the response is a 2xx success
- ❌ Err(reqw::Error::Http(reqwest::Response)) → if response is non-2xx
- ❌ Err(reqw::Error::Transport(reqwest::Error)) → if the request itself failed (network error, timeout, etc.)
This way, you can treat HTTP error responses in the same way as transport errors — making your control flow simpler and more idiomatic in Rust.