diff --git a/.cargo/config.toml b/.cargo/config.toml
index 0bab205cd..0cf09f710 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,7 +1,8 @@
 [alias]
-chk = "hack check --workspace --all-features --tests --examples"
-lint = "hack --clean-per-run clippy --workspace --tests --examples"
+chk = "check --workspace --all-features --tests --examples --bins"
+lint = "clippy --workspace --tests --examples"
 ci-min = "hack check --workspace --no-default-features"
 ci-min-test = "hack check --workspace --no-default-features --tests --examples"
 ci-default = "hack check --workspace"
 ci-full = "check --workspace --bins --examples --tests"
+ci-test = "test --workspace --all-features --no-fail-fast"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3aac6efa8..c57db463a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -86,7 +86,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: -v --workspace --all-features --no-fail-fast -- --nocapture
+          args: --workspace --all-features --no-fail-fast -- --nocapture
             --skip=test_h2_content_length
             --skip=test_reading_deflate_encoding_large_random_rustls
 
@@ -123,5 +123,5 @@ jobs:
 
       - name: Clear the cargo caches
         run: |
-          cargo install cargo-cache --no-default-features --features ci-autoclean
+          cargo install cargo-cache --version 0.6.2 --no-default-features --features ci-autoclean
           cargo-cache
diff --git a/CHANGES.md b/CHANGES.md
index bea9ab935..17ae711d6 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,36 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+### Changed
+* Change compression algorithm features flags. [#2250]
+
+[#2250]: https://github.com/actix/actix-web/pull/2250
+
+
+## 4.0.0-beta.7 - 2021-06-17
+### Added
+* `HttpServer::worker_max_blocking_threads` for setting block thread pool. [#2200]
+
+### Changed
+* Adjusted default JSON payload limit to 2MB (from 32kb) and included size and limits in the `JsonPayloadError::Overflow` error variant. [#2162]
+[#2162]: (https://github.com/actix/actix-web/pull/2162)
+* `ServiceResponse::error_response` now uses body type of `Body`. [#2201]
+* `ServiceResponse::checked_expr` now returns a `Result`. [#2201]
+* Update `language-tags` to `0.3`.
+* `ServiceResponse::take_body`. [#2201]
+* `ServiceResponse::map_body` closure receives and returns `B` instead of `ResponseBody<B>` types. [#2201]
+* All error trait bounds in server service builders have changed from `Into<Error>` to `Into<Response<AnyBody>>`. [#2253]
+* All error trait bounds in message body and stream impls changed from `Into<Error>` to `Into<Box<dyn std::error::Error>>`. [#2253]
+* `HttpServer::{listen_rustls(), bind_rustls()}` now honor the ALPN protocols in the configuation parameter. [#2226]
+* `middleware::normalize` now will not try to normalize URIs with no valid path [#2246]
+
+### Removed
+* `HttpResponse::take_body` and old `HttpResponse::into_body` method that casted body type. [#2201]
+
+[#2200]: https://github.com/actix/actix-web/pull/2200
+[#2201]: https://github.com/actix/actix-web/pull/2201
+[#2253]: https://github.com/actix/actix-web/pull/2253
+[#2246]: https://github.com/actix/actix-web/pull/2246
 
 
 ## 4.0.0-beta.6 - 2021-04-17
diff --git a/Cargo.toml b/Cargo.toml
index e482dec27..770c9a050 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "4.0.0-beta.6"
+version = "4.0.0-beta.7"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
 keywords = ["actix", "http", "web", "framework", "async"]
@@ -17,7 +17,7 @@ edition = "2018"
 
 [package.metadata.docs.rs]
 # features that docs.rs will build with
-features = ["openssl", "rustls", "compress", "cookies", "secure-cookies"]
+features = ["openssl", "rustls", "compress-brotli", "compress-gzip", "compress-zstd", "cookies", "secure-cookies"]
 
 [lib]
 name = "actix_web"
@@ -39,10 +39,14 @@ members = [
 # resolver = "2"
 
 [features]
-default = ["compress", "cookies"]
+default = ["compress-brotli", "compress-gzip", "compress-zstd", "cookies"]
 
-# content-encoding support
-compress = ["actix-http/compress"]
+# Brotli algorithm content-encoding support
+compress-brotli = ["actix-http/compress-brotli", "__compress"]
+# Gzip and deflate algorithms content-encoding support
+compress-gzip = ["actix-http/compress-gzip", "__compress"]
+# Zstd algorithm content-encoding support
+compress-zstd = ["actix-http/compress-zstd", "__compress"]
 
 # support for cookies
 cookies = ["cookie"]
@@ -56,9 +60,13 @@ openssl = ["actix-http/openssl", "actix-tls/accept", "actix-tls/openssl"]
 # rustls
 rustls = ["actix-http/rustls", "actix-tls/accept", "actix-tls/rustls"]
 
+# Internal (PRIVATE!) features used to aid testing and cheking feature status.
+# Don't rely on these whatsoever. They may disappear at anytime.
+__compress = []
+
 [dependencies]
-actix-codec = "0.4.0-beta.1"
-actix-macros = "0.2.0"
+actix-codec = "0.4.0"
+actix-macros = "0.2.1"
 actix-router = "0.2.7"
 actix-rt = "2.2"
 actix-server = "2.0.0-beta.3"
@@ -67,10 +75,11 @@ actix-utils = "3.0.0"
 actix-tls = { version = "3.0.0-beta.5", default-features = false, optional = true }
 
 actix-web-codegen = "0.5.0-beta.2"
-actix-http = "3.0.0-beta.6"
+actix-http = "3.0.0-beta.7"
 
 ahash = "0.7"
 bytes = "1"
+cfg-if = "1"
 cookie = { version = "0.15", features = ["percent-encode"], optional = true }
 derive_more = "0.99.5"
 either = "1.5.3"
@@ -78,10 +87,11 @@ encoding_rs = "0.8"
 futures-core = { version = "0.3.7", default-features = false }
 futures-util = { version = "0.3.7", default-features = false }
 itoa = "0.4"
-language-tags = "0.2"
+language-tags = "0.3"
 once_cell = "1.5"
 log = "0.4"
 mime = "0.3"
+paste = "1"
 pin-project = "1.0.0"
 regex = "1.4"
 serde = { version = "1.0", features = ["derive"] }
@@ -94,12 +104,13 @@ url = "2.1"
 
 [dev-dependencies]
 actix-test = { version = "0.1.0-beta.2", features = ["openssl", "rustls"] }
-awc = { version = "3.0.0-beta.5", features = ["openssl"] }
+awc = { version = "3.0.0-beta.6", features = ["openssl"] }
 
 brotli2 = "0.3.2"
 criterion = "0.3"
 env_logger = "0.8"
 flate2 = "1.0.13"
+zstd = "0.7"
 rand = "0.8"
 rcgen = "0.8"
 serde_derive = "1.0"
@@ -124,15 +135,15 @@ awc = { path = "awc" }
 
 [[test]]
 name = "test_server"
-required-features = ["compress", "cookies"]
+required-features = ["compress-brotli", "compress-gzip", "compress-zstd", "cookies"]
 
 [[example]]
 name = "basic"
-required-features = ["compress"]
+required-features = ["compress-gzip"]
 
 [[example]]
 name = "uds"
-required-features = ["compress"]
+required-features = ["compress-gzip"]
 
 [[example]]
 name = "on_connect"
diff --git a/MIGRATION.md b/MIGRATION.md
index e01702868..9c29b8db9 100644
--- a/MIGRATION.md
+++ b/MIGRATION.md
@@ -10,6 +10,18 @@
 
   Alternatively, explicitly require trailing slashes: `NormalizePath::new(TrailingSlash::Always)`.
 
+* Feature flag `compress` has been split into its supported algorithm (brotli, gzip, zstd).
+  By default all compression algorithms are enabled.
+  To select algorithm you want to include with `middleware::Compress` use following flags:
+  - `compress-brotli`
+  - `compress-gzip`
+  - `compress-zstd`
+  If you have set in your `Cargo.toml` dedicated `actix-web` features and you still want
+  to have compression enabled. Please change features selection like bellow:
+
+  Before: `"compress"`
+  After: `"compress-brotli", "compress-gzip", "compress-zstd"`
+
 
 ## 3.0.0
 
diff --git a/README.md b/README.md
index c85c0652f..d9048a06b 100644
--- a/README.md
+++ b/README.md
@@ -6,10 +6,10 @@
   <p>
 
 [![crates.io](https://img.shields.io/crates/v/actix-web?label=latest)](https://crates.io/crates/actix-web)
-[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.5)](https://docs.rs/actix-web/4.0.0-beta.5)
+[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.7)](https://docs.rs/actix-web/4.0.0-beta.7)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-web.svg)
-[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.5/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.5)
+[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.7/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.7)
 <br />
 [![build status](https://github.com/actix/actix-web/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-web/actions)
 [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) 
@@ -25,13 +25,13 @@
 * Streaming and pipelining
 * Keep-alive and slow requests handling
 * Client/server [WebSockets](https://actix.rs/docs/websockets/) support
-* Transparent content compression/decompression (br, gzip, deflate)
+* Transparent content compression/decompression (br, gzip, deflate, zstd)
 * Powerful [request routing](https://actix.rs/docs/url-dispatch/)
 * Multipart streams
 * Static assets
 * SSL support using OpenSSL or Rustls
 * Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
-* Includes an async [HTTP client](https://docs.rs/actix-web/latest/actix_web/client/index.html)
+* Includes an async [HTTP client](https://docs.rs/awc/)
 * Runs on stable Rust 1.46+
 
 ## Documentation
diff --git a/actix-files/CHANGES.md b/actix-files/CHANGES.md
index 6c28e42d0..bec67dd4e 100644
--- a/actix-files/CHANGES.md
+++ b/actix-files/CHANGES.md
@@ -1,16 +1,28 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+
+
+## 0.6.0-beta.5 - 2021-06-17
 * `NamedFile` now implements `ServiceFactory` and `HttpServiceFactory` making it much more useful in routing. For example, it can be used directly as a default service. [#2135]
 * For symbolic links, `Content-Disposition` header no longer shows the filename of the original file. [#2156]
+* `Files::redirect_to_slash_directory()` now works as expected when used with `Files::show_files_listing()`. [#2225]
+* `application/{javascript, json, wasm}` mime type now have `inline` disposition by default. [#2257]
+* `Files::show_files_listing()` can now be used with `Files::index_file()` to show files listing as a fallback when the index file is not found. [#2228]
 
 [#2135]: https://github.com/actix/actix-web/pull/2135
 [#2156]: https://github.com/actix/actix-web/pull/2156
+[#2225]: https://github.com/actix/actix-web/pull/2225
+[#2257]: https://github.com/actix/actix-web/pull/2257
+[#2228]: https://github.com/actix/actix-web/pull/2228
 
 
 ## 0.6.0-beta.4 - 2021-04-02
 * No notable changes.
 
+* Add support for `.guard` in `Files` to selectively filter `Files` services. [#2046]
+
+[#2046]: https://github.com/actix/actix-web/pull/2046
 
 ## 0.6.0-beta.3 - 2021-03-09
 * No notable changes.
diff --git a/actix-files/Cargo.toml b/actix-files/Cargo.toml
index b97badd3e..44c29dc92 100644
--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.6.0-beta.4"
+version = "0.6.0-beta.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static file serving for Actix Web"
 readme = "README.md"
@@ -17,7 +17,8 @@ name = "actix_files"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = { version = "4.0.0-beta.6", default-features = false }
+actix-web = { version = "4.0.0-beta.7", default-features = false }
+actix-http = "3.0.0-beta.7"
 actix-service = "2.0.0"
 actix-utils = "3.0.0"
 
@@ -34,5 +35,5 @@ percent-encoding = "2.1"
 
 [dev-dependencies]
 actix-rt = "2.2"
-actix-web = "4.0.0-beta.6"
+actix-web = "4.0.0-beta.7"
 actix-test = "0.1.0-beta.2"
diff --git a/actix-files/README.md b/actix-files/README.md
index 895d5e687..524f5c38e 100644
--- a/actix-files/README.md
+++ b/actix-files/README.md
@@ -3,11 +3,11 @@
 > Static file serving for Actix Web
 
 [![crates.io](https://img.shields.io/crates/v/actix-files?label=latest)](https://crates.io/crates/actix-files)
-[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.0-beta.4)](https://docs.rs/actix-files/0.6.0-beta.4)
+[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.0-beta.5)](https://docs.rs/actix-files/0.6.0-beta.5)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![License](https://img.shields.io/crates/l/actix-files.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.4/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.4)
+[![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.5/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.5)
 [![Download](https://img.shields.io/crates/d/actix-files.svg)](https://crates.io/crates/actix-files)
 [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
diff --git a/actix-files/src/files.rs b/actix-files/src/files.rs
index 9b24c4b21..c48cf59a7 100644
--- a/actix-files/src/files.rs
+++ b/actix-files/src/files.rs
@@ -37,7 +37,8 @@ pub struct Files {
     renderer: Rc<DirectoryRenderer>,
     mime_override: Option<Rc<MimeOverride>>,
     file_flags: named::Flags,
-    guards: Option<Rc<dyn Guard>>,
+    use_guards: Option<Rc<dyn Guard>>,
+    guards: Vec<Rc<dyn Guard>>,
     hidden_files: bool,
 }
 
@@ -59,6 +60,7 @@ impl Clone for Files {
             file_flags: self.file_flags,
             path: self.path.clone(),
             mime_override: self.mime_override.clone(),
+            use_guards: self.use_guards.clone(),
             guards: self.guards.clone(),
             hidden_files: self.hidden_files,
         }
@@ -80,10 +82,9 @@ impl Files {
     /// If the mount path is set as the root path `/`, services registered after this one will
     /// be inaccessible. Register more specific handlers and services first.
     ///
-    /// `Files` uses a threadpool for blocking filesystem operations. By default, the pool uses a
-    /// max number of threads equal to `512 * HttpServer::worker`. Real time thread count are
-    /// adjusted with work load. More threads would spawn when need and threads goes idle for a
-    /// period of time would be de-spawned.
+    /// `Files` utilizes the existing Tokio thread-pool for blocking filesystem operations.
+    /// The number of running threads is adjusted over time as needed, up to a maximum of 512 times
+    /// the number of server [workers](actix_web::HttpServer::workers), by default.
     pub fn new<T: Into<PathBuf>>(mount_path: &str, serve_from: T) -> Files {
         let orig_dir = serve_from.into();
         let dir = match orig_dir.canonicalize() {
@@ -104,7 +105,8 @@ impl Files {
             renderer: Rc::new(directory_listing),
             mime_override: None,
             file_flags: named::Flags::default(),
-            guards: None,
+            use_guards: None,
+            guards: Vec::new(),
             hidden_files: false,
         }
     }
@@ -112,6 +114,9 @@ impl Files {
     /// Show files listing for directories.
     ///
     /// By default show files listing is disabled.
+    ///
+    /// When used with [`Files::index_file()`], files listing is shown as a fallback
+    /// when the index file is not found.
     pub fn show_files_listing(mut self) -> Self {
         self.show_index = true;
         self
@@ -146,8 +151,11 @@ impl Files {
 
     /// Set index file
     ///
-    /// Shows specific index file for directory "/" instead of
+    /// Shows specific index file for directories instead of
     /// showing files listing.
+    ///
+    /// If the index file is not found, files listing is shown as a fallback if
+    /// [`Files::show_files_listing()`] is set.
     pub fn index_file<T: Into<String>>(mut self, index: T) -> Self {
         self.index = Some(index.into());
         self
@@ -156,7 +164,6 @@ impl Files {
     /// Specifies whether to use ETag or not.
     ///
     /// Default is true.
-    #[inline]
     pub fn use_etag(mut self, value: bool) -> Self {
         self.file_flags.set(named::Flags::ETAG, value);
         self
@@ -165,7 +172,6 @@ impl Files {
     /// Specifies whether to use Last-Modified or not.
     ///
     /// Default is true.
-    #[inline]
     pub fn use_last_modified(mut self, value: bool) -> Self {
         self.file_flags.set(named::Flags::LAST_MD, value);
         self
@@ -174,25 +180,55 @@ impl Files {
     /// Specifies whether text responses should signal a UTF-8 encoding.
     ///
     /// Default is false (but will default to true in a future version).
-    #[inline]
     pub fn prefer_utf8(mut self, value: bool) -> Self {
         self.file_flags.set(named::Flags::PREFER_UTF8, value);
         self
     }
 
-    /// Specifies custom guards to use for directory listings and files.
+    /// Adds a routing guard.
     ///
-    /// Default behaviour allows GET and HEAD.
-    #[inline]
-    pub fn use_guards<G: Guard + 'static>(mut self, guards: G) -> Self {
-        self.guards = Some(Rc::new(guards));
+    /// Use this to allow multiple chained file services that respond to strictly different
+    /// properties of a request. Due to the way routing works, if a guard check returns true and the
+    /// request starts being handled by the file service, it will not be able to back-out and try
+    /// the next service, you will simply get a 404 (or 405) error response.
+    ///
+    /// To allow `POST` requests to retrieve files, see [`Files::use_guards`].
+    ///
+    /// # Examples
+    /// ```
+    /// use actix_web::{guard::Header, App};
+    /// use actix_files::Files;
+    ///
+    /// App::new().service(
+    ///     Files::new("/","/my/site/files")
+    ///         .guard(Header("Host", "example.com"))
+    /// );
+    /// ```
+    pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
+        self.guards.push(Rc::new(guard));
         self
     }
 
+    /// Specifies guard to check before fetching directory listings or files.
+    ///
+    /// Note that this guard has no effect on routing; it's main use is to guard on the request's
+    /// method just before serving the file, only allowing `GET` and `HEAD` requests by default.
+    /// See [`Files::guard`] for routing guards.
+    pub fn method_guard<G: Guard + 'static>(mut self, guard: G) -> Self {
+        self.use_guards = Some(Rc::new(guard));
+        self
+    }
+
+    #[doc(hidden)]
+    #[deprecated(since = "0.6.0", note = "Renamed to `method_guard`.")]
+    /// See [`Files::method_guard`].
+    pub fn use_guards<G: Guard + 'static>(self, guard: G) -> Self {
+        self.method_guard(guard)
+    }
+
     /// Disable `Content-Disposition` header.
     ///
     /// By default Content-Disposition` header is enabled.
-    #[inline]
     pub fn disable_content_disposition(mut self) -> Self {
         self.file_flags.remove(named::Flags::CONTENT_DISPOSITION);
         self
@@ -200,8 +236,9 @@ impl Files {
 
     /// Sets default handler which is used when no matched file could be found.
     ///
-    /// For example, you could set a fall back static file handler:
-    /// ```rust
+    /// # Examples
+    /// Setting a fallback static file handler:
+    /// ```
     /// use actix_files::{Files, NamedFile};
     ///
     /// # fn run() -> Result<(), actix_web::Error> {
@@ -230,7 +267,6 @@ impl Files {
     }
 
     /// Enables serving hidden files and directories, allowing a leading dots in url fragments.
-    #[inline]
     pub fn use_hidden_files(mut self) -> Self {
         self.hidden_files = true;
         self
@@ -238,7 +274,19 @@ impl Files {
 }
 
 impl HttpServiceFactory for Files {
-    fn register(self, config: &mut AppService) {
+    fn register(mut self, config: &mut AppService) {
+        let guards = if self.guards.is_empty() {
+            None
+        } else {
+            let guards = std::mem::take(&mut self.guards);
+            Some(
+                guards
+                    .into_iter()
+                    .map(|guard| -> Box<dyn Guard> { Box::new(guard) })
+                    .collect::<Vec<_>>(),
+            )
+        };
+
         if self.default.borrow().is_none() {
             *self.default.borrow_mut() = Some(config.default_service());
         }
@@ -249,7 +297,7 @@ impl HttpServiceFactory for Files {
             ResourceDef::prefix(&self.path)
         };
 
-        config.register_service(rdef, None, self, None)
+        config.register_service(rdef, guards, self, None)
     }
 }
 
@@ -271,7 +319,7 @@ impl ServiceFactory<ServiceRequest> for Files {
             renderer: self.renderer.clone(),
             mime_override: self.mime_override.clone(),
             file_flags: self.file_flags,
-            guards: self.guards.clone(),
+            guards: self.use_guards.clone(),
             hidden_files: self.hidden_files,
         };
 
diff --git a/actix-files/src/lib.rs b/actix-files/src/lib.rs
index 34b02581e..c9cc79193 100644
--- a/actix-files/src/lib.rs
+++ b/actix-files/src/lib.rs
@@ -279,6 +279,22 @@ mod tests {
         );
     }
 
+    #[actix_rt::test]
+    async fn test_named_file_javascript() {
+        let file = NamedFile::open("tests/test.js").unwrap();
+
+        let req = TestRequest::default().to_http_request();
+        let resp = file.respond_to(&req).await.unwrap();
+        assert_eq!(
+            resp.headers().get(header::CONTENT_TYPE).unwrap(),
+            "application/javascript"
+        );
+        assert_eq!(
+            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+            "inline; filename=\"test.js\""
+        );
+    }
+
     #[actix_rt::test]
     async fn test_named_file_image_attachment() {
         let cd = ContentDisposition {
@@ -532,7 +548,7 @@ mod tests {
     #[actix_rt::test]
     async fn test_files_guards() {
         let srv = test::init_service(
-            App::new().service(Files::new("/", ".").use_guards(guard::Post())),
+            App::new().service(Files::new("/", ".").method_guard(guard::Post())),
         )
         .await;
 
@@ -632,7 +648,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_redirect_to_slash_directory() {
-        // should not redirect if no index
+        // should not redirect if no index and files listing is disabled
         let srv = test::init_service(
             App::new().service(Files::new("/", ".").redirect_to_slash_directory()),
         )
@@ -654,6 +670,19 @@ mod tests {
         let resp = test::call_service(&srv, req).await;
         assert_eq!(resp.status(), StatusCode::FOUND);
 
+        // should redirect if files listing is enabled
+        let srv = test::init_service(
+            App::new().service(
+                Files::new("/", ".")
+                    .show_files_listing()
+                    .redirect_to_slash_directory(),
+            ),
+        )
+        .await;
+        let req = TestRequest::with_uri("/tests").to_request();
+        let resp = test::call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::FOUND);
+
         // should not redirect if the path is wrong
         let req = TestRequest::with_uri("/not_existing").to_request();
         let resp = test::call_service(&srv, req).await;
@@ -843,4 +872,33 @@ mod tests {
             "inline; filename=\"symlink-test.png\""
         );
     }
+
+    #[actix_rt::test]
+    async fn test_index_with_show_files_listing() {
+        let service = Files::new(".", ".")
+            .index_file("lib.rs")
+            .show_files_listing()
+            .new_service(())
+            .await
+            .unwrap();
+
+        // Serve the index if exists
+        let req = TestRequest::default().uri("/src").to_srv_request();
+        let resp = test::call_service(&service, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        assert_eq!(
+            resp.headers().get(header::CONTENT_TYPE).unwrap(),
+            "text/x-rust"
+        );
+
+        // Show files listing, otherwise.
+        let req = TestRequest::default().uri("/tests").to_srv_request();
+        let resp = test::call_service(&service, req).await;
+        assert_eq!(
+            resp.headers().get(header::CONTENT_TYPE).unwrap(),
+            "text/html; charset=utf-8"
+        );
+        let bytes = test::read_body(resp).await;
+        assert!(format!("{:?}", bytes).contains("/tests/test.png"));
+    }
 }
diff --git a/actix-files/src/named.rs b/actix-files/src/named.rs
index 519234f0d..37f8def3e 100644
--- a/actix-files/src/named.rs
+++ b/actix-files/src/named.rs
@@ -120,6 +120,11 @@ impl NamedFile {
 
             let disposition = match ct.type_() {
                 mime::IMAGE | mime::TEXT | mime::VIDEO => DispositionType::Inline,
+                mime::APPLICATION => match ct.subtype() {
+                    mime::JAVASCRIPT | mime::JSON => DispositionType::Inline,
+                    name if name == "wasm" => DispositionType::Inline,
+                    _ => DispositionType::Attachment,
+                },
                 _ => DispositionType::Attachment,
             };
 
@@ -213,9 +218,11 @@ impl NamedFile {
 
     /// Set the Content-Disposition for serving this file. This allows
     /// changing the inline/attachment disposition as well as the filename
-    /// sent to the peer. By default the disposition is `inline` for text,
-    /// image, and video content types, and `attachment` otherwise, and
-    /// the filename is taken from the path provided in the `open` method
+    /// sent to the peer.
+    ///
+    /// By default the disposition is `inline` for `text/*`, `image/*`, `video/*` and
+    /// `application/{javascript, json, wasm}` mime types, and `attachment` otherwise,
+    /// and the filename is taken from the path provided in the `open` method
     /// after converting it to UTF-8 using.
     /// [`std::ffi::OsStr::to_string_lossy`]
     #[inline]
@@ -235,6 +242,8 @@ impl NamedFile {
     }
 
     /// Set content encoding for serving this file
+    ///
+    /// Must be used with [`actix_web::middleware::Compress`] to take effect.
     #[inline]
     pub fn set_content_encoding(mut self, enc: ContentEncoding) -> Self {
         self.encoding = Some(enc);
diff --git a/actix-files/src/service.rs b/actix-files/src/service.rs
index dc51ada18..64938e5ef 100644
--- a/actix-files/src/service.rs
+++ b/actix-files/src/service.rs
@@ -89,37 +89,33 @@ impl Service<ServiceRequest> for FilesService {
         }
 
         if path.is_dir() {
-            if let Some(ref redir_index) = self.index {
-                if self.redirect_to_slash && !req.path().ends_with('/') {
-                    let redirect_to = format!("{}/", req.path());
+            if self.redirect_to_slash
+                && !req.path().ends_with('/')
+                && (self.index.is_some() || self.show_index)
+            {
+                let redirect_to = format!("{}/", req.path());
 
-                    return Box::pin(ok(req.into_response(
-                        HttpResponse::Found()
-                            .insert_header((header::LOCATION, redirect_to))
-                            .body("")
-                            .into_body(),
-                    )));
+                return Box::pin(ok(req.into_response(
+                    HttpResponse::Found()
+                        .insert_header((header::LOCATION, redirect_to))
+                        .finish(),
+                )));
+            }
+
+            let serve_named_file = |req: ServiceRequest, mut named_file: NamedFile| {
+                if let Some(ref mime_override) = self.mime_override {
+                    let new_disposition = mime_override(&named_file.content_type.type_());
+                    named_file.content_disposition.disposition = new_disposition;
                 }
+                named_file.flags = self.file_flags;
 
-                let path = path.join(redir_index);
+                let (req, _) = req.into_parts();
+                let res = named_file.into_response(&req);
+                Box::pin(ok(ServiceResponse::new(req, res)))
+            };
 
-                match NamedFile::open(path) {
-                    Ok(mut named_file) => {
-                        if let Some(ref mime_override) = self.mime_override {
-                            let new_disposition =
-                                mime_override(&named_file.content_type.type_());
-                            named_file.content_disposition.disposition = new_disposition;
-                        }
-                        named_file.flags = self.file_flags;
-
-                        let (req, _) = req.into_parts();
-                        let res = named_file.into_response(&req);
-                        Box::pin(ok(ServiceResponse::new(req, res)))
-                    }
-                    Err(err) => self.handle_err(err, req),
-                }
-            } else if self.show_index {
-                let dir = Directory::new(self.directory.clone(), path);
+            let show_index = |req: ServiceRequest| {
+                let dir = Directory::new(self.directory.clone(), path.clone());
 
                 let (req, _) = req.into_parts();
                 let x = (self.renderer)(&dir, &req);
@@ -128,11 +124,19 @@ impl Service<ServiceRequest> for FilesService {
                     Ok(resp) => ok(resp),
                     Err(err) => ok(ServiceResponse::from_err(err, req)),
                 })
-            } else {
-                Box::pin(ok(ServiceResponse::from_err(
+            };
+
+            match self.index {
+                Some(ref index) => match NamedFile::open(path.join(index)) {
+                    Ok(named_file) => serve_named_file(req, named_file),
+                    Err(_) if self.show_index => show_index(req),
+                    Err(err) => self.handle_err(err, req),
+                },
+                None if self.show_index => show_index(req),
+                _ => Box::pin(ok(ServiceResponse::from_err(
                     FilesError::IsDirectory,
                     req.into_parts().0,
-                )))
+                ))),
             }
         } else {
             match NamedFile::open(path) {
diff --git a/actix-files/tests/fixtures/guards/first/index.txt b/actix-files/tests/fixtures/guards/first/index.txt
new file mode 100644
index 000000000..fe4f02ad0
--- /dev/null
+++ b/actix-files/tests/fixtures/guards/first/index.txt
@@ -0,0 +1 @@
+first
\ No newline at end of file
diff --git a/actix-files/tests/fixtures/guards/second/index.txt b/actix-files/tests/fixtures/guards/second/index.txt
new file mode 100644
index 000000000..2147e4188
--- /dev/null
+++ b/actix-files/tests/fixtures/guards/second/index.txt
@@ -0,0 +1 @@
+second
\ No newline at end of file
diff --git a/actix-files/tests/guard.rs b/actix-files/tests/guard.rs
new file mode 100644
index 000000000..8b1785e7f
--- /dev/null
+++ b/actix-files/tests/guard.rs
@@ -0,0 +1,36 @@
+use actix_files::Files;
+use actix_web::{
+    guard::Host,
+    http::StatusCode,
+    test::{self, TestRequest},
+    App,
+};
+use bytes::Bytes;
+
+#[actix_rt::test]
+async fn test_guard_filter() {
+    let srv = test::init_service(
+        App::new()
+            .service(Files::new("/", "./tests/fixtures/guards/first").guard(Host("first.com")))
+            .service(
+                Files::new("/", "./tests/fixtures/guards/second").guard(Host("second.com")),
+            ),
+    )
+    .await;
+
+    let req = TestRequest::with_uri("/index.txt")
+        .append_header(("Host", "first.com"))
+        .to_request();
+    let res = test::call_service(&srv, req).await;
+
+    assert_eq!(res.status(), StatusCode::OK);
+    assert_eq!(test::read_body(res).await, Bytes::from("first"));
+
+    let req = TestRequest::with_uri("/index.txt")
+        .append_header(("Host", "second.com"))
+        .to_request();
+    let res = test::call_service(&srv, req).await;
+
+    assert_eq!(res.status(), StatusCode::OK);
+    assert_eq!(test::read_body(res).await, Bytes::from("second"));
+}
diff --git a/actix-files/tests/test.js b/actix-files/tests/test.js
new file mode 100644
index 000000000..2ee135561
--- /dev/null
+++ b/actix-files/tests/test.js
@@ -0,0 +1 @@
+// this file is empty.
diff --git a/actix-http-test/Cargo.toml b/actix-http-test/Cargo.toml
index 05a0e022a..5d797aaa9 100644
--- a/actix-http-test/Cargo.toml
+++ b/actix-http-test/Cargo.toml
@@ -30,12 +30,12 @@ openssl = ["tls-openssl", "awc/openssl"]
 
 [dependencies]
 actix-service = "2.0.0"
-actix-codec = "0.4.0-beta.1"
+actix-codec = "0.4.0"
 actix-tls = "3.0.0-beta.5"
 actix-utils = "3.0.0"
 actix-rt = "2.2"
 actix-server = "2.0.0-beta.3"
-awc = { version = "3.0.0-beta.5", default-features = false }
+awc = { version = "3.0.0-beta.6", default-features = false }
 
 base64 = "0.13"
 bytes = "1"
@@ -51,5 +51,5 @@ time = { version = "0.2.23", default-features = false, features = ["std"] }
 tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
 
 [dev-dependencies]
-actix-web = { version = "4.0.0-beta.6", default-features = false, features = ["cookies"] }
-actix-http = "3.0.0-beta.6"
+actix-web = { version = "4.0.0-beta.7", default-features = false, features = ["cookies"] }
+actix-http = "3.0.0-beta.7"
diff --git a/actix-http/CHANGES.md b/actix-http/CHANGES.md
index e89208748..c8d65e393 100644
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@@ -1,19 +1,55 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+### Changed
+* Change compression algorithm features flags. [#2250]
+
+[#2250]: https://github.com/actix/actix-web/pull/2250
+
+
+## 3.0.0-beta.7 - 2021-06-17
 ### Added
+* Alias `body::Body` as `body::AnyBody`. [#2215]
+* `BoxAnyBody`: a boxed message body with boxed errors. [#2183]
 * Re-export `http` crate's `Error` type as `error::HttpError`. [#2171]
 * Re-export `StatusCode`, `Method`, `Version` and `Uri` at the crate root. [#2171]
 * Re-export `ContentEncoding` and `ConnectionType` at the crate root. [#2171]
+* `Response::into_body` that consumes response and returns body type. [#2201]
+* `impl Default` for `Response`. [#2201]
+* Add zstd support for `ContentEncoding`. [#2244]
 
 ### Changed
+* The `MessageBody` trait now has an associated `Error` type. [#2183]
+* All error trait bounds in server service builders have changed from `Into<Error>` to `Into<Response<AnyBody>>`. [#2253]
+* All error trait bounds in message body and stream impls changed from `Into<Error>` to `Into<Box<dyn std::error::Error>>`. [#2253]
+* Places in `Response` where `ResponseBody<B>` was received or returned now simply use `B`. [#2201]
 * `header` mod is now public. [#2171]
 * `uri` mod is now public. [#2171]
+* Update `language-tags` to `0.3`.
+* Reduce the level from `error` to `debug` for the log line that is emitted when a `500 Internal Server Error` is built using `HttpResponse::from_error`. [#2201]
+* `ResponseBuilder::message_body` now returns a `Result`. [#2201]
+* Remove `Unpin` bound on `ResponseBuilder::streaming`. [#2253]
+* `HttpServer::{listen_rustls(), bind_rustls()}` now honor the ALPN protocols in the configuation parameter. [#2226]
 
 ### Removed
 * Stop re-exporting `http` crate's `HeaderMap` types in addition to ours. [#2171]
+* Down-casting for `MessageBody` types. [#2183]
+* `error::Result` alias. [#2201]
+* Error field from `Response` and `Response::error`. [#2205]
+* `impl Future` for `Response`. [#2201]
+* `Response::take_body` and old `Response::into_body` method that casted body type. [#2201]
+* `InternalError` and all the error types it constructed. [#2215]
+* Conversion (`impl Into`) of `Response<Body>` and `ResponseBuilder` to `Error`. [#2215]
 
 [#2171]: https://github.com/actix/actix-web/pull/2171
+[#2183]: https://github.com/actix/actix-web/pull/2183
+[#2196]: https://github.com/actix/actix-web/pull/2196
+[#2201]: https://github.com/actix/actix-web/pull/2201
+[#2205]: https://github.com/actix/actix-web/pull/2205
+[#2215]: https://github.com/actix/actix-web/pull/2215
+[#2253]: https://github.com/actix/actix-web/pull/2253
+[#2244]: https://github.com/actix/actix-web/pull/2244
+
 
 
 ## 3.0.0-beta.6 - 2021-04-17
diff --git a/actix-http/Cargo.toml b/actix-http/Cargo.toml
index 61f60b79e..35ea89862 100644
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "3.0.0-beta.6"
+version = "3.0.0-beta.7"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "HTTP primitives for the Actix ecosystem"
 readme = "README.md"
@@ -16,7 +16,7 @@ edition = "2018"
 
 [package.metadata.docs.rs]
 # features that docs.rs will build with
-features = ["openssl", "rustls", "compress"]
+features = ["openssl", "rustls", "compress-brotli", "compress-gzip", "compress-zstd"]
 
 [lib]
 name = "actix_http"
@@ -32,14 +32,20 @@ openssl = ["actix-tls/openssl"]
 rustls = ["actix-tls/rustls"]
 
 # enable compression support
-compress = ["flate2", "brotli2"]
+compress-brotli = ["brotli2", "__compress"]
+compress-gzip = ["flate2", "__compress"]
+compress-zstd = ["zstd", "__compress"]
 
 # trust-dns as client dns resolver
 trust-dns = ["trust-dns-resolver"]
 
+# Internal (PRIVATE!) features used to aid testing and cheking feature status.
+# Don't rely on these whatsoever. They may disappear at anytime.
+__compress = []
+
 [dependencies]
 actix-service = "2.0.0"
-actix-codec = "0.4.0-beta.1"
+actix-codec = "0.4.0"
 actix-utils = "3.0.0"
 actix-rt = "2.2"
 actix-tls = { version = "3.0.0-beta.5", features = ["accept", "connect"] }
@@ -57,12 +63,11 @@ h2 = "0.3.1"
 http = "0.2.2"
 httparse = "1.3"
 itoa = "0.4"
-language-tags = "0.2"
+language-tags = "0.3"
 local-channel = "0.1"
 once_cell = "1.5"
 log = "0.4"
 mime = "0.3"
-paste = "1"
 percent-encoding = "2.1"
 pin-project = "1.0.0"
 pin-project-lite = "0.2"
@@ -77,6 +82,7 @@ tokio = { version = "1.2", features = ["sync"] }
 # compression
 brotli2 = { version="0.3.2", optional = true }
 flate2 = { version = "1.0.13", optional = true }
+zstd = { version = "0.7", optional = true }
 
 trust-dns-resolver = { version = "0.20.0", optional = true }
 
@@ -84,13 +90,15 @@ trust-dns-resolver = { version = "0.20.0", optional = true }
 actix-server = "2.0.0-beta.3"
 actix-http-test = { version = "3.0.0-beta.4", features = ["openssl"] }
 actix-tls = { version = "3.0.0-beta.5", features = ["openssl"] }
-criterion = "0.3"
+async-stream = "0.3"
+criterion = { version = "0.3", features = ["html_reports"] }
 env_logger = "0.8"
 rcgen = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 tls-openssl = { version = "0.10", package = "openssl" }
 tls-rustls = { version = "0.19", package = "rustls" }
+webpki = { version = "0.21.0" }
 
 [[example]]
 name = "ws"
diff --git a/actix-http/README.md b/actix-http/README.md
index 87eb38e5d..5271d8738 100644
--- a/actix-http/README.md
+++ b/actix-http/README.md
@@ -3,11 +3,11 @@
 > HTTP primitives for the Actix ecosystem.
 
 [![crates.io](https://img.shields.io/crates/v/actix-http?label=latest)](https://crates.io/crates/actix-http)
-[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.6)](https://docs.rs/actix-http/3.0.0-beta.6)
+[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.7)](https://docs.rs/actix-http/3.0.0-beta.7)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.6/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.6)
+[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.7/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.7)
 [![Download](https://img.shields.io/crates/d/actix-http.svg)](https://crates.io/crates/actix-http)
 [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
diff --git a/actix-http/examples/echo.rs b/actix-http/examples/echo.rs
index b2cdb0be1..6cfe3a675 100644
--- a/actix-http/examples/echo.rs
+++ b/actix-http/examples/echo.rs
@@ -1,19 +1,17 @@
-use std::{env, io};
+use std::io;
 
 use actix_http::{http::StatusCode, Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
 use futures_util::StreamExt as _;
 use http::header::HeaderValue;
-use log::info;
 
 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "echo=info");
-    env_logger::init();
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
 
     Server::build()
-        .bind("echo", "127.0.0.1:8080", || {
+        .bind("echo", ("127.0.0.1", 8080), || {
             HttpService::build()
                 .client_timeout(1000)
                 .client_disconnect(1000)
@@ -23,7 +21,8 @@ async fn main() -> io::Result<()> {
                         body.extend_from_slice(&item?);
                     }
 
-                    info!("request body: {:?}", body);
+                    log::info!("request body: {:?}", body);
+
                     Ok::<_, Error>(
                         Response::build(StatusCode::OK)
                             .insert_header((
diff --git a/actix-http/examples/echo2.rs b/actix-http/examples/echo2.rs
index 9acf4bbae..db195d65b 100644
--- a/actix-http/examples/echo2.rs
+++ b/actix-http/examples/echo2.rs
@@ -1,11 +1,10 @@
-use std::{env, io};
+use std::io;
 
 use actix_http::{body::Body, http::HeaderValue, http::StatusCode};
 use actix_http::{Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
 use futures_util::StreamExt as _;
-use log::info;
 
 async fn handle_request(mut req: Request) -> Result<Response<Body>, Error> {
     let mut body = BytesMut::new();
@@ -13,7 +12,8 @@ async fn handle_request(mut req: Request) -> Result<Response<Body>, Error> {
         body.extend_from_slice(&item?)
     }
 
-    info!("request body: {:?}", body);
+    log::info!("request body: {:?}", body);
+
     Ok(Response::build(StatusCode::OK)
         .insert_header(("x-head", HeaderValue::from_static("dummy value!")))
         .body(body))
@@ -21,11 +21,10 @@ async fn handle_request(mut req: Request) -> Result<Response<Body>, Error> {
 
 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "echo=info");
-    env_logger::init();
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
 
     Server::build()
-        .bind("echo", "127.0.0.1:8080", || {
+        .bind("echo", ("127.0.0.1", 8080), || {
             HttpService::build().finish(handle_request).tcp()
         })?
         .run()
diff --git a/actix-http/examples/hello-world.rs b/actix-http/examples/hello-world.rs
index 85994556d..9a593c66a 100644
--- a/actix-http/examples/hello-world.rs
+++ b/actix-http/examples/hello-world.rs
@@ -1,29 +1,28 @@
-use std::{env, io};
+use std::{convert::Infallible, io};
 
 use actix_http::{http::StatusCode, HttpService, Response};
 use actix_server::Server;
-use actix_utils::future;
 use http::header::HeaderValue;
-use log::info;
 
 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "hello_world=info");
-    env_logger::init();
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
 
     Server::build()
-        .bind("hello-world", "127.0.0.1:8080", || {
+        .bind("hello-world", ("127.0.0.1", 8080), || {
             HttpService::build()
                 .client_timeout(1000)
                 .client_disconnect(1000)
-                .finish(|_req| {
-                    info!("{:?}", _req);
+                .finish(|req| async move {
+                    log::info!("{:?}", req);
+
                     let mut res = Response::build(StatusCode::OK);
                     res.insert_header((
                         "x-head",
                         HeaderValue::from_static("dummy value!"),
                     ));
-                    future::ok::<_, ()>(res.body("Hello world!"))
+
+                    Ok::<_, Infallible>(res.body("Hello world!"))
                 })
                 .tcp()
         })?
diff --git a/actix-http/examples/streaming-error.rs b/actix-http/examples/streaming-error.rs
new file mode 100644
index 000000000..3988cbac2
--- /dev/null
+++ b/actix-http/examples/streaming-error.rs
@@ -0,0 +1,40 @@
+//! Example showing response body (chunked) stream erroring.
+//!
+//! Test using `nc` or `curl`.
+//! ```sh
+//! $ curl -vN 127.0.0.1:8080
+//! $ echo 'GET / HTTP/1.1\n\n' | nc 127.0.0.1 8080
+//! ```
+
+use std::{convert::Infallible, io, time::Duration};
+
+use actix_http::{body::BodyStream, HttpService, Response};
+use actix_server::Server;
+use async_stream::stream;
+use bytes::Bytes;
+
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    Server::build()
+        .bind("streaming-error", ("127.0.0.1", 8080), || {
+            HttpService::build()
+                .finish(|req| async move {
+                    log::info!("{:?}", req);
+                    let res = Response::ok();
+
+                    Ok::<_, Infallible>(res.set_body(BodyStream::new(stream! {
+                        yield Ok(Bytes::from("123"));
+                        yield Ok(Bytes::from("456"));
+
+                        actix_rt::time::sleep(Duration::from_millis(1000)).await;
+
+                        yield Err(io::Error::new(io::ErrorKind::Other, ""));
+                    })))
+                })
+                .tcp()
+        })?
+        .run()
+        .await
+}
diff --git a/actix-http/examples/ws.rs b/actix-http/examples/ws.rs
index af66f7d71..d3cedf870 100644
--- a/actix-http/examples/ws.rs
+++ b/actix-http/examples/ws.rs
@@ -4,7 +4,7 @@
 extern crate tls_rustls as rustls;
 
 use std::{
-    env, io,
+    io,
     pin::Pin,
     task::{Context, Poll},
     time::Duration,
@@ -20,8 +20,7 @@ use futures_core::{ready, Stream};
 
 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "actix=info,h2_ws=info");
-    env_logger::init();
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
 
     Server::build()
         .bind("tcp", ("127.0.0.1", 8080), || {
@@ -41,7 +40,7 @@ async fn handler(req: Request) -> Result<Response<BodyStream<Heartbeat>>, Error>
     // handshake will always fail under HTTP/2
 
     log::info!("responding");
-    Ok(res.message_body(BodyStream::new(Heartbeat::new(ws::Codec::new()))))
+    Ok(res.message_body(BodyStream::new(Heartbeat::new(ws::Codec::new())))?)
 }
 
 struct Heartbeat {
diff --git a/actix-http/src/body/body.rs b/actix-http/src/body/body.rs
index 4fe18338a..f04837d07 100644
--- a/actix-http/src/body/body.rs
+++ b/actix-http/src/body/body.rs
@@ -1,20 +1,22 @@
 use std::{
     borrow::Cow,
+    error::Error as StdError,
     fmt, mem,
     pin::Pin,
     task::{Context, Poll},
 };
 
 use bytes::{Bytes, BytesMut};
-use futures_core::Stream;
+use futures_core::{ready, Stream};
 
 use crate::error::Error;
 
-use super::{BodySize, BodyStream, MessageBody, SizedStream};
+use super::{BodySize, BodyStream, MessageBody, MessageBodyMapErr, SizedStream};
+
+pub type Body = AnyBody;
 
 /// Represents various types of HTTP message body.
-// #[deprecated(since = "4.0.0", note = "Use body types directly.")]
-pub enum Body {
+pub enum AnyBody {
     /// Empty response. `Content-Length` header is not set.
     None,
 
@@ -25,39 +27,45 @@ pub enum Body {
     Bytes(Bytes),
 
     /// Generic message body.
-    Message(Pin<Box<dyn MessageBody>>),
+    Message(BoxAnyBody),
 }
 
-impl Body {
+impl AnyBody {
     /// Create body from slice (copy)
-    pub fn from_slice(s: &[u8]) -> Body {
-        Body::Bytes(Bytes::copy_from_slice(s))
+    pub fn from_slice(s: &[u8]) -> Self {
+        Self::Bytes(Bytes::copy_from_slice(s))
     }
 
     /// Create body from generic message body.
-    pub fn from_message<B: MessageBody + 'static>(body: B) -> Body {
-        Body::Message(Box::pin(body))
+    pub fn from_message<B>(body: B) -> Self
+    where
+        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError + 'static>>,
+    {
+        Self::Message(BoxAnyBody::from_body(body))
     }
 }
 
-impl MessageBody for Body {
+impl MessageBody for AnyBody {
+    type Error = Error;
+
     fn size(&self) -> BodySize {
         match self {
-            Body::None => BodySize::None,
-            Body::Empty => BodySize::Empty,
-            Body::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
-            Body::Message(ref body) => body.size(),
+            AnyBody::None => BodySize::None,
+            AnyBody::Empty => BodySize::Empty,
+            AnyBody::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
+            AnyBody::Message(ref body) => body.size(),
         }
     }
 
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         match self.get_mut() {
-            Body::None => Poll::Ready(None),
-            Body::Empty => Poll::Ready(None),
-            Body::Bytes(ref mut bin) => {
+            AnyBody::None => Poll::Ready(None),
+            AnyBody::Empty => Poll::Ready(None),
+            AnyBody::Bytes(ref mut bin) => {
                 let len = bin.len();
                 if len == 0 {
                     Poll::Ready(None)
@@ -65,104 +73,161 @@ impl MessageBody for Body {
                     Poll::Ready(Some(Ok(mem::take(bin))))
                 }
             }
-            Body::Message(body) => body.as_mut().poll_next(cx),
+
+            // TODO: MSRV 1.51: poll_map_err
+            AnyBody::Message(body) => match ready!(body.as_pin_mut().poll_next(cx)) {
+                Some(Err(err)) => {
+                    Poll::Ready(Some(Err(Error::new_body().with_cause(err))))
+                }
+                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                None => Poll::Ready(None),
+            },
         }
     }
 }
 
-impl PartialEq for Body {
+impl PartialEq for AnyBody {
     fn eq(&self, other: &Body) -> bool {
         match *self {
-            Body::None => matches!(*other, Body::None),
-            Body::Empty => matches!(*other, Body::Empty),
-            Body::Bytes(ref b) => match *other {
-                Body::Bytes(ref b2) => b == b2,
+            AnyBody::None => matches!(*other, AnyBody::None),
+            AnyBody::Empty => matches!(*other, AnyBody::Empty),
+            AnyBody::Bytes(ref b) => match *other {
+                AnyBody::Bytes(ref b2) => b == b2,
                 _ => false,
             },
-            Body::Message(_) => false,
+            AnyBody::Message(_) => false,
         }
     }
 }
 
-impl fmt::Debug for Body {
+impl fmt::Debug for AnyBody {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            Body::None => write!(f, "Body::None"),
-            Body::Empty => write!(f, "Body::Empty"),
-            Body::Bytes(ref b) => write!(f, "Body::Bytes({:?})", b),
-            Body::Message(_) => write!(f, "Body::Message(_)"),
+            AnyBody::None => write!(f, "AnyBody::None"),
+            AnyBody::Empty => write!(f, "AnyBody::Empty"),
+            AnyBody::Bytes(ref b) => write!(f, "AnyBody::Bytes({:?})", b),
+            AnyBody::Message(_) => write!(f, "AnyBody::Message(_)"),
         }
     }
 }
 
-impl From<&'static str> for Body {
+impl From<&'static str> for AnyBody {
     fn from(s: &'static str) -> Body {
-        Body::Bytes(Bytes::from_static(s.as_ref()))
+        AnyBody::Bytes(Bytes::from_static(s.as_ref()))
     }
 }
 
-impl From<&'static [u8]> for Body {
+impl From<&'static [u8]> for AnyBody {
     fn from(s: &'static [u8]) -> Body {
-        Body::Bytes(Bytes::from_static(s))
+        AnyBody::Bytes(Bytes::from_static(s))
     }
 }
 
-impl From<Vec<u8>> for Body {
+impl From<Vec<u8>> for AnyBody {
     fn from(vec: Vec<u8>) -> Body {
-        Body::Bytes(Bytes::from(vec))
+        AnyBody::Bytes(Bytes::from(vec))
     }
 }
 
-impl From<String> for Body {
+impl From<String> for AnyBody {
     fn from(s: String) -> Body {
         s.into_bytes().into()
     }
 }
 
-impl From<&'_ String> for Body {
+impl From<&'_ String> for AnyBody {
     fn from(s: &String) -> Body {
-        Body::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
+        AnyBody::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
     }
 }
 
-impl From<Cow<'_, str>> for Body {
+impl From<Cow<'_, str>> for AnyBody {
     fn from(s: Cow<'_, str>) -> Body {
         match s {
-            Cow::Owned(s) => Body::from(s),
+            Cow::Owned(s) => AnyBody::from(s),
             Cow::Borrowed(s) => {
-                Body::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(s)))
+                AnyBody::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(s)))
             }
         }
     }
 }
 
-impl From<Bytes> for Body {
+impl From<Bytes> for AnyBody {
     fn from(s: Bytes) -> Body {
-        Body::Bytes(s)
+        AnyBody::Bytes(s)
     }
 }
 
-impl From<BytesMut> for Body {
+impl From<BytesMut> for AnyBody {
     fn from(s: BytesMut) -> Body {
-        Body::Bytes(s.freeze())
+        AnyBody::Bytes(s.freeze())
     }
 }
 
-impl<S> From<SizedStream<S>> for Body
-where
-    S: Stream<Item = Result<Bytes, Error>> + 'static,
-{
-    fn from(s: SizedStream<S>) -> Body {
-        Body::from_message(s)
-    }
-}
-
-impl<S, E> From<BodyStream<S>> for Body
+impl<S, E> From<SizedStream<S>> for AnyBody
 where
     S: Stream<Item = Result<Bytes, E>> + 'static,
-    E: Into<Error> + 'static,
+    E: Into<Box<dyn StdError>> + 'static,
 {
-    fn from(s: BodyStream<S>) -> Body {
-        Body::from_message(s)
+    fn from(s: SizedStream<S>) -> Body {
+        AnyBody::from_message(s)
+    }
+}
+
+impl<S, E> From<BodyStream<S>> for AnyBody
+where
+    S: Stream<Item = Result<Bytes, E>> + 'static,
+    E: Into<Box<dyn StdError>> + 'static,
+{
+    fn from(s: BodyStream<S>) -> Body {
+        AnyBody::from_message(s)
+    }
+}
+
+/// A boxed message body with boxed errors.
+pub struct BoxAnyBody(Pin<Box<dyn MessageBody<Error = Box<dyn StdError + 'static>>>>);
+
+impl BoxAnyBody {
+    /// Boxes a `MessageBody` and any errors it generates.
+    pub fn from_body<B>(body: B) -> Self
+    where
+        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError + 'static>>,
+    {
+        let body = MessageBodyMapErr::new(body, Into::into);
+        Self(Box::pin(body))
+    }
+
+    /// Returns a mutable pinned reference to the inner message body type.
+    pub fn as_pin_mut(
+        &mut self,
+    ) -> Pin<&mut (dyn MessageBody<Error = Box<dyn StdError + 'static>>)> {
+        self.0.as_mut()
+    }
+}
+
+impl fmt::Debug for BoxAnyBody {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("BoxAnyBody(dyn MessageBody)")
+    }
+}
+
+impl MessageBody for BoxAnyBody {
+    type Error = Error;
+
+    fn size(&self) -> BodySize {
+        self.0.size()
+    }
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        // TODO: MSRV 1.51: poll_map_err
+        match ready!(self.0.as_mut().poll_next(cx)) {
+            Some(Err(err)) => Poll::Ready(Some(Err(Error::new_body().with_cause(err)))),
+            Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+            None => Poll::Ready(None),
+        }
     }
 }
diff --git a/actix-http/src/body/body_stream.rs b/actix-http/src/body/body_stream.rs
index b81aeb4c1..f726f4475 100644
--- a/actix-http/src/body/body_stream.rs
+++ b/actix-http/src/body/body_stream.rs
@@ -1,4 +1,5 @@
 use std::{
+    error::Error as StdError,
     pin::Pin,
     task::{Context, Poll},
 };
@@ -7,8 +8,6 @@ use bytes::Bytes;
 use futures_core::{ready, Stream};
 use pin_project_lite::pin_project;
 
-use crate::error::Error;
-
 use super::{BodySize, MessageBody};
 
 pin_project! {
@@ -24,7 +23,7 @@ pin_project! {
 impl<S, E> BodyStream<S>
 where
     S: Stream<Item = Result<Bytes, E>>,
-    E: Into<Error>,
+    E: Into<Box<dyn StdError>> + 'static,
 {
     pub fn new(stream: S) -> Self {
         BodyStream { stream }
@@ -34,8 +33,10 @@ where
 impl<S, E> MessageBody for BodyStream<S>
 where
     S: Stream<Item = Result<Bytes, E>>,
-    E: Into<Error>,
+    E: Into<Box<dyn StdError>> + 'static,
 {
+    type Error = E;
+
     fn size(&self) -> BodySize {
         BodySize::Stream
     }
@@ -48,13 +49,13 @@ where
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         loop {
             let stream = self.as_mut().project().stream;
 
             let chunk = match ready!(stream.poll_next(cx)) {
                 Some(Ok(ref bytes)) if bytes.is_empty() => continue,
-                opt => opt.map(|res| res.map_err(Into::into)),
+                opt => opt,
             };
 
             return Poll::Ready(chunk);
@@ -64,9 +65,16 @@ where
 
 #[cfg(test)]
 mod tests {
-    use actix_rt::pin;
+    use std::{convert::Infallible, time::Duration};
+
+    use actix_rt::{
+        pin,
+        time::{sleep, Sleep},
+    };
     use actix_utils::future::poll_fn;
-    use futures_util::stream;
+    use derive_more::{Display, Error};
+    use futures_core::ready;
+    use futures_util::{stream, FutureExt as _};
 
     use super::*;
     use crate::body::to_bytes;
@@ -76,7 +84,7 @@ mod tests {
         let body = BodyStream::new(stream::iter(
             ["1", "", "2"]
                 .iter()
-                .map(|&v| Ok(Bytes::from(v)) as Result<Bytes, ()>),
+                .map(|&v| Ok::<_, Infallible>(Bytes::from(v))),
         ));
         pin!(body);
 
@@ -101,9 +109,63 @@ mod tests {
         let body = BodyStream::new(stream::iter(
             ["1", "", "2"]
                 .iter()
-                .map(|&v| Ok(Bytes::from(v)) as Result<Bytes, ()>),
+                .map(|&v| Ok::<_, Infallible>(Bytes::from(v))),
         ));
 
         assert_eq!(to_bytes(body).await.ok(), Some(Bytes::from("12")));
     }
+    #[derive(Debug, Display, Error)]
+    #[display(fmt = "stream error")]
+    struct StreamErr;
+
+    #[actix_rt::test]
+    async fn stream_immediate_error() {
+        let body = BodyStream::new(stream::once(async { Err(StreamErr) }));
+        assert!(matches!(to_bytes(body).await, Err(StreamErr)));
+    }
+
+    #[actix_rt::test]
+    async fn stream_delayed_error() {
+        let body =
+            BodyStream::new(stream::iter(vec![Ok(Bytes::from("1")), Err(StreamErr)]));
+        assert!(matches!(to_bytes(body).await, Err(StreamErr)));
+
+        #[pin_project::pin_project(project = TimeDelayStreamProj)]
+        #[derive(Debug)]
+        enum TimeDelayStream {
+            Start,
+            Sleep(Pin<Box<Sleep>>),
+            Done,
+        }
+
+        impl Stream for TimeDelayStream {
+            type Item = Result<Bytes, StreamErr>;
+
+            fn poll_next(
+                mut self: Pin<&mut Self>,
+                cx: &mut Context<'_>,
+            ) -> Poll<Option<Self::Item>> {
+                match self.as_mut().get_mut() {
+                    TimeDelayStream::Start => {
+                        let sleep = sleep(Duration::from_millis(1));
+                        self.as_mut().set(TimeDelayStream::Sleep(Box::pin(sleep)));
+                        cx.waker().wake_by_ref();
+                        Poll::Pending
+                    }
+
+                    TimeDelayStream::Sleep(ref mut delay) => {
+                        ready!(delay.poll_unpin(cx));
+                        self.set(TimeDelayStream::Done);
+                        cx.waker().wake_by_ref();
+                        Poll::Pending
+                    }
+
+                    TimeDelayStream::Done => Poll::Ready(Some(Err(StreamErr))),
+                }
+            }
+        }
+
+        let body = BodyStream::new(TimeDelayStream::Start);
+        assert!(matches!(to_bytes(body).await, Err(StreamErr)));
+    }
 }
diff --git a/actix-http/src/body/message_body.rs b/actix-http/src/body/message_body.rs
index 894a5fa98..2d2642ba7 100644
--- a/actix-http/src/body/message_body.rs
+++ b/actix-http/src/body/message_body.rs
@@ -1,12 +1,15 @@
 //! [`MessageBody`] trait and foreign implementations.
 
 use std::{
+    convert::Infallible,
     mem,
     pin::Pin,
     task::{Context, Poll},
 };
 
 use bytes::{Bytes, BytesMut};
+use futures_core::ready;
+use pin_project_lite::pin_project;
 
 use crate::error::Error;
 
@@ -14,6 +17,8 @@ use super::BodySize;
 
 /// An interface for response bodies.
 pub trait MessageBody {
+    type Error;
+
     /// Body size hint.
     fn size(&self) -> BodySize;
 
@@ -21,14 +26,12 @@ pub trait MessageBody {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>>;
-
-    downcast_get_type_id!();
+    ) -> Poll<Option<Result<Bytes, Self::Error>>>;
 }
 
-downcast!(MessageBody);
-
 impl MessageBody for () {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Empty
     }
@@ -36,12 +39,18 @@ impl MessageBody for () {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         Poll::Ready(None)
     }
 }
 
-impl<T: MessageBody + Unpin> MessageBody for Box<T> {
+impl<B> MessageBody for Box<B>
+where
+    B: MessageBody + Unpin,
+    B::Error: Into<Error>,
+{
+    type Error = B::Error;
+
     fn size(&self) -> BodySize {
         self.as_ref().size()
     }
@@ -49,12 +58,18 @@ impl<T: MessageBody + Unpin> MessageBody for Box<T> {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         Pin::new(self.get_mut().as_mut()).poll_next(cx)
     }
 }
 
-impl<T: MessageBody> MessageBody for Pin<Box<T>> {
+impl<B> MessageBody for Pin<Box<B>>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = B::Error;
+
     fn size(&self) -> BodySize {
         self.as_ref().size()
     }
@@ -62,12 +77,14 @@ impl<T: MessageBody> MessageBody for Pin<Box<T>> {
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         self.as_mut().poll_next(cx)
     }
 }
 
 impl MessageBody for Bytes {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len() as u64)
     }
@@ -75,7 +92,7 @@ impl MessageBody for Bytes {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
@@ -85,6 +102,8 @@ impl MessageBody for Bytes {
 }
 
 impl MessageBody for BytesMut {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len() as u64)
     }
@@ -92,7 +111,7 @@ impl MessageBody for BytesMut {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
@@ -102,6 +121,8 @@ impl MessageBody for BytesMut {
 }
 
 impl MessageBody for &'static str {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len() as u64)
     }
@@ -109,7 +130,7 @@ impl MessageBody for &'static str {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
@@ -121,6 +142,8 @@ impl MessageBody for &'static str {
 }
 
 impl MessageBody for Vec<u8> {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len() as u64)
     }
@@ -128,7 +151,7 @@ impl MessageBody for Vec<u8> {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
@@ -138,6 +161,8 @@ impl MessageBody for Vec<u8> {
 }
 
 impl MessageBody for String {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len() as u64)
     }
@@ -145,7 +170,7 @@ impl MessageBody for String {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
@@ -155,3 +180,53 @@ impl MessageBody for String {
         }
     }
 }
+
+pin_project! {
+    pub(crate) struct MessageBodyMapErr<B, F> {
+        #[pin]
+        body: B,
+        mapper: Option<F>,
+    }
+}
+
+impl<B, F, E> MessageBodyMapErr<B, F>
+where
+    B: MessageBody,
+    F: FnOnce(B::Error) -> E,
+{
+    pub(crate) fn new(body: B, mapper: F) -> Self {
+        Self {
+            body,
+            mapper: Some(mapper),
+        }
+    }
+}
+
+impl<B, F, E> MessageBody for MessageBodyMapErr<B, F>
+where
+    B: MessageBody,
+    F: FnOnce(B::Error) -> E,
+{
+    type Error = E;
+
+    fn size(&self) -> BodySize {
+        self.body.size()
+    }
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        let this = self.as_mut().project();
+
+        match ready!(this.body.poll_next(cx)) {
+            Some(Err(err)) => {
+                let f = self.as_mut().project().mapper.take().unwrap();
+                let mapped_err = (f)(err);
+                Poll::Ready(Some(Err(mapped_err)))
+            }
+            Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+            None => Poll::Ready(None),
+        }
+    }
+}
diff --git a/actix-http/src/body/mod.rs b/actix-http/src/body/mod.rs
index f26d6a8cf..8a08dbd2b 100644
--- a/actix-http/src/body/mod.rs
+++ b/actix-http/src/body/mod.rs
@@ -15,9 +15,10 @@ mod response_body;
 mod size;
 mod sized_stream;
 
-pub use self::body::Body;
+pub use self::body::{AnyBody, Body, BoxAnyBody};
 pub use self::body_stream::BodyStream;
 pub use self::message_body::MessageBody;
+pub(crate) use self::message_body::MessageBodyMapErr;
 pub use self::response_body::ResponseBody;
 pub use self::size::BodySize;
 pub use self::sized_stream::SizedStream;
@@ -41,7 +42,7 @@ pub use self::sized_stream::SizedStream;
 /// assert_eq!(bytes, b"123"[..]);
 /// # }
 /// ```
-pub async fn to_bytes(body: impl MessageBody) -> Result<Bytes, crate::Error> {
+pub async fn to_bytes<B: MessageBody>(body: B) -> Result<Bytes, B::Error> {
     let cap = match body.size() {
         BodySize::None | BodySize::Empty | BodySize::Sized(0) => return Ok(Bytes::new()),
         BodySize::Sized(size) => size as usize,
@@ -85,15 +86,6 @@ mod tests {
         }
     }
 
-    impl ResponseBody<Body> {
-        pub(crate) fn get_ref(&self) -> &[u8] {
-            match *self {
-                ResponseBody::Body(ref b) => b.get_ref(),
-                ResponseBody::Other(ref b) => b.get_ref(),
-            }
-        }
-    }
-
     #[actix_rt::test]
     async fn test_static_str() {
         assert_eq!(Body::from("").size(), BodySize::Sized(0));
@@ -199,11 +191,15 @@ mod tests {
     }
 
     #[actix_rt::test]
-    async fn test_box() {
+    async fn test_box_and_pin() {
         let val = Box::new(());
         pin!(val);
         assert_eq!(val.size(), BodySize::Empty);
         assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
+
+        let mut val = Box::pin(());
+        assert_eq!(val.size(), BodySize::Empty);
+        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
     }
 
     #[actix_rt::test]
@@ -237,10 +233,13 @@ mod tests {
         );
     }
 
+    // down-casting used to be done with a method on MessageBody trait
+    // test is kept to demonstrate equivalence of Any trait
     #[actix_rt::test]
     async fn test_body_casting() {
         let mut body = String::from("hello cast");
-        let resp_body: &mut dyn MessageBody = &mut body;
+        // let mut resp_body: &mut dyn MessageBody<Error = Error> = &mut body;
+        let resp_body: &mut dyn std::any::Any = &mut body;
         let body = resp_body.downcast_ref::<String>().unwrap();
         assert_eq!(body, "hello cast");
         let body = &mut resp_body.downcast_mut::<String>().unwrap();
diff --git a/actix-http/src/body/response_body.rs b/actix-http/src/body/response_body.rs
index b27112475..855c742f2 100644
--- a/actix-http/src/body/response_body.rs
+++ b/actix-http/src/body/response_body.rs
@@ -5,7 +5,7 @@ use std::{
 };
 
 use bytes::Bytes;
-use futures_core::Stream;
+use futures_core::{ready, Stream};
 use pin_project::pin_project;
 
 use crate::error::Error;
@@ -43,7 +43,13 @@ impl<B: MessageBody> ResponseBody<B> {
     }
 }
 
-impl<B: MessageBody> MessageBody for ResponseBody<B> {
+impl<B> MessageBody for ResponseBody<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = Error;
+
     fn size(&self) -> BodySize {
         match self {
             ResponseBody::Body(ref body) => body.size(),
@@ -54,12 +60,16 @@ impl<B: MessageBody> MessageBody for ResponseBody<B> {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         Stream::poll_next(self, cx)
     }
 }
 
-impl<B: MessageBody> Stream for ResponseBody<B> {
+impl<B> Stream for ResponseBody<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
     type Item = Result<Bytes, Error>;
 
     fn poll_next(
@@ -67,7 +77,12 @@ impl<B: MessageBody> Stream for ResponseBody<B> {
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         match self.project() {
-            ResponseBodyProj::Body(body) => body.poll_next(cx),
+            // TODO: MSRV 1.51: poll_map_err
+            ResponseBodyProj::Body(body) => match ready!(body.poll_next(cx)) {
+                Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
+                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                None => Poll::Ready(None),
+            },
             ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
         }
     }
diff --git a/actix-http/src/body/sized_stream.rs b/actix-http/src/body/sized_stream.rs
index f0332fc8f..b6ceb32fe 100644
--- a/actix-http/src/body/sized_stream.rs
+++ b/actix-http/src/body/sized_stream.rs
@@ -1,4 +1,5 @@
 use std::{
+    error::Error as StdError,
     pin::Pin,
     task::{Context, Poll},
 };
@@ -7,15 +8,13 @@ use bytes::Bytes;
 use futures_core::{ready, Stream};
 use pin_project_lite::pin_project;
 
-use crate::error::Error;
-
 use super::{BodySize, MessageBody};
 
 pin_project! {
     /// Known sized streaming response wrapper.
     ///
-    /// This body implementation should be used if total size of stream is known. Data get sent as is
-    /// without using transfer encoding.
+    /// This body implementation should be used if total size of stream is known. Data is sent as-is
+    /// without using chunked transfer encoding.
     pub struct SizedStream<S> {
         size: u64,
         #[pin]
@@ -23,19 +22,23 @@ pin_project! {
     }
 }
 
-impl<S> SizedStream<S>
+impl<S, E> SizedStream<S>
 where
-    S: Stream<Item = Result<Bytes, Error>>,
+    S: Stream<Item = Result<Bytes, E>>,
+    E: Into<Box<dyn StdError>> + 'static,
 {
     pub fn new(size: u64, stream: S) -> Self {
         SizedStream { size, stream }
     }
 }
 
-impl<S> MessageBody for SizedStream<S>
+impl<S, E> MessageBody for SizedStream<S>
 where
-    S: Stream<Item = Result<Bytes, Error>>,
+    S: Stream<Item = Result<Bytes, E>>,
+    E: Into<Box<dyn StdError>> + 'static,
 {
+    type Error = E;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.size as u64)
     }
@@ -48,7 +51,7 @@ where
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         loop {
             let stream = self.as_mut().project().stream;
 
@@ -64,6 +67,8 @@ where
 
 #[cfg(test)]
 mod tests {
+    use std::convert::Infallible;
+
     use actix_rt::pin;
     use actix_utils::future::poll_fn;
     use futures_util::stream;
@@ -75,7 +80,11 @@ mod tests {
     async fn skips_empty_chunks() {
         let body = SizedStream::new(
             2,
-            stream::iter(["1", "", "2"].iter().map(|&v| Ok(Bytes::from(v)))),
+            stream::iter(
+                ["1", "", "2"]
+                    .iter()
+                    .map(|&v| Ok::<_, Infallible>(Bytes::from(v))),
+            ),
         );
 
         pin!(body);
@@ -101,7 +110,11 @@ mod tests {
     async fn read_to_bytes() {
         let body = SizedStream::new(
             2,
-            stream::iter(["1", "", "2"].iter().map(|&v| Ok(Bytes::from(v)))),
+            stream::iter(
+                ["1", "", "2"]
+                    .iter()
+                    .map(|&v| Ok::<_, Infallible>(Bytes::from(v))),
+            ),
         );
 
         assert_eq!(to_bytes(body).await.ok(), Some(Bytes::from("12")));
diff --git a/actix-http/src/builder.rs b/actix-http/src/builder.rs
index 623bfdda2..4e68dc920 100644
--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@@ -1,19 +1,16 @@
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::{fmt, net};
+use std::{error::Error as StdError, fmt, marker::PhantomData, net, rc::Rc};
 
 use actix_codec::Framed;
 use actix_service::{IntoServiceFactory, Service, ServiceFactory};
 
-use crate::body::MessageBody;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::Error;
-use crate::h1::{Codec, ExpectHandler, H1Service, UpgradeHandler};
-use crate::h2::H2Service;
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpService;
-use crate::{ConnectCallback, Extensions};
+use crate::{
+    body::{AnyBody, MessageBody},
+    config::{KeepAlive, ServiceConfig},
+    h1::{self, ExpectHandler, H1Service, UpgradeHandler},
+    h2::H2Service,
+    service::HttpService,
+    ConnectCallback, Extensions, Request, Response,
+};
 
 /// A HTTP service builder
 ///
@@ -34,7 +31,7 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler> {
 impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::InitError: fmt::Debug,
     <S::Service as Service<Request>>::Future: 'static,
 {
@@ -57,13 +54,13 @@ where
 impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::InitError: fmt::Debug,
     <S::Service as Service<Request>>::Future: 'static,
     X: ServiceFactory<Request, Config = (), Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
     X::InitError: fmt::Debug,
-    U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
+    U: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
     U::Error: fmt::Display,
     U::InitError: fmt::Debug,
 {
@@ -123,7 +120,7 @@ where
     where
         F: IntoServiceFactory<X1, Request>,
         X1: ServiceFactory<Request, Config = (), Response = Request>,
-        X1::Error: Into<Error>,
+        X1::Error: Into<Response<AnyBody>>,
         X1::InitError: fmt::Debug,
     {
         HttpServiceBuilder {
@@ -145,8 +142,8 @@ where
     /// and this service get called with original request and framed object.
     pub fn upgrade<F, U1>(self, upgrade: F) -> HttpServiceBuilder<T, S, X, U1>
     where
-        F: IntoServiceFactory<U1, (Request, Framed<T, Codec>)>,
-        U1: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
+        F: IntoServiceFactory<U1, (Request, Framed<T, h1::Codec>)>,
+        U1: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
         U1::Error: fmt::Display,
         U1::InitError: fmt::Debug,
     {
@@ -181,7 +178,7 @@ where
     where
         B: MessageBody,
         F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Error>,
+        S::Error: Into<Response<AnyBody>>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
     {
@@ -202,11 +199,13 @@ where
     /// Finish service configuration and create a HTTP service for HTTP/2 protocol.
     pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B>
     where
-        B: MessageBody + 'static,
         F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
+
+        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,
     {
         let cfg = ServiceConfig::new(
             self.keep_alive,
@@ -223,11 +222,13 @@ where
     /// Finish service configuration and create `HttpService` instance.
     pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U>
     where
-        B: MessageBody + 'static,
         F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
+
+        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,
     {
         let cfg = ServiceConfig::new(
             self.keep_alive,
diff --git a/actix-http/src/client/connection.rs b/actix-http/src/client/connection.rs
index 0e3e97f3f..a30f651ca 100644
--- a/actix-http/src/client/connection.rs
+++ b/actix-http/src/client/connection.rs
@@ -12,10 +12,10 @@ use bytes::Bytes;
 use futures_core::future::LocalBoxFuture;
 use h2::client::SendRequest;
 
-use crate::body::MessageBody;
 use crate::h1::ClientCodec;
 use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
+use crate::{body::MessageBody, Error};
 
 use super::error::SendRequestError;
 use super::pool::Acquired;
@@ -256,8 +256,9 @@ where
         body: RB,
     ) -> LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>
     where
-        RB: MessageBody + 'static,
         H: Into<RequestHeadType> + 'static,
+        RB: MessageBody + 'static,
+        RB::Error: Into<Error>,
     {
         Box::pin(async move {
             match self {
diff --git a/actix-http/src/client/error.rs b/actix-http/src/client/error.rs
index d27363456..34833503b 100644
--- a/actix-http/src/client/error.rs
+++ b/actix-http/src/client/error.rs
@@ -1,15 +1,16 @@
-use std::io;
+use std::{error::Error as StdError, fmt, io};
 
 use derive_more::{Display, From};
 
 #[cfg(feature = "openssl")]
 use actix_tls::accept::openssl::SslError;
 
-use crate::error::{Error, ParseError, ResponseError};
-use crate::http::{Error as HttpError, StatusCode};
+use crate::error::{Error, ParseError};
+use crate::http::Error as HttpError;
 
 /// A set of errors that can occur while connecting to an HTTP host
 #[derive(Debug, Display, From)]
+#[non_exhaustive]
 pub enum ConnectError {
     /// SSL feature is not enabled
     #[display(fmt = "SSL is not supported")]
@@ -64,6 +65,7 @@ impl From<actix_tls::connect::ConnectError> for ConnectError {
 }
 
 #[derive(Debug, Display, From)]
+#[non_exhaustive]
 pub enum InvalidUrl {
     #[display(fmt = "Missing URL scheme")]
     MissingScheme,
@@ -82,6 +84,7 @@ impl std::error::Error for InvalidUrl {}
 
 /// A set of errors that can occur during request sending and response reading
 #[derive(Debug, Display, From)]
+#[non_exhaustive]
 pub enum SendRequestError {
     /// Invalid URL
     #[display(fmt = "Invalid URL: {}", _0)]
@@ -115,25 +118,17 @@ pub enum SendRequestError {
 
     /// Error sending request body
     Body(Error),
+
+    /// Other errors that can occur after submitting a request.
+    #[display(fmt = "{:?}: {}", _1, _0)]
+    Custom(Box<dyn StdError>, Box<dyn fmt::Debug>),
 }
 
 impl std::error::Error for SendRequestError {}
 
-/// Convert `SendRequestError` to a server `Response`
-impl ResponseError for SendRequestError {
-    fn status_code(&self) -> StatusCode {
-        match *self {
-            SendRequestError::Connect(ConnectError::Timeout) => {
-                StatusCode::GATEWAY_TIMEOUT
-            }
-            SendRequestError::Connect(_) => StatusCode::BAD_REQUEST,
-            _ => StatusCode::INTERNAL_SERVER_ERROR,
-        }
-    }
-}
-
 /// A set of errors that can occur during freezing a request
 #[derive(Debug, Display, From)]
+#[non_exhaustive]
 pub enum FreezeRequestError {
     /// Invalid URL
     #[display(fmt = "Invalid URL: {}", _0)]
@@ -142,15 +137,20 @@ pub enum FreezeRequestError {
     /// HTTP error
     #[display(fmt = "{}", _0)]
     Http(HttpError),
+
+    /// Other errors that can occur after submitting a request.
+    #[display(fmt = "{:?}: {}", _1, _0)]
+    Custom(Box<dyn StdError>, Box<dyn fmt::Debug>),
 }
 
 impl std::error::Error for FreezeRequestError {}
 
 impl From<FreezeRequestError> for SendRequestError {
-    fn from(e: FreezeRequestError) -> Self {
-        match e {
-            FreezeRequestError::Url(e) => e.into(),
-            FreezeRequestError::Http(e) => e.into(),
+    fn from(err: FreezeRequestError) -> Self {
+        match err {
+            FreezeRequestError::Url(err) => err.into(),
+            FreezeRequestError::Http(err) => err.into(),
+            FreezeRequestError::Custom(err, msg) => SendRequestError::Custom(err, msg),
         }
     }
 }
diff --git a/actix-http/src/client/h1proto.rs b/actix-http/src/client/h1proto.rs
index fa4469d35..65a30748c 100644
--- a/actix-http/src/client/h1proto.rs
+++ b/actix-http/src/client/h1proto.rs
@@ -11,7 +11,6 @@ use bytes::{Bytes, BytesMut};
 use futures_core::{ready, Stream};
 use futures_util::SinkExt as _;
 
-use crate::error::PayloadError;
 use crate::h1;
 use crate::http::{
     header::{HeaderMap, IntoHeaderValue, EXPECT, HOST},
@@ -19,6 +18,7 @@ use crate::http::{
 };
 use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
+use crate::{error::PayloadError, Error};
 
 use super::connection::{ConnectionIo, H1Connection};
 use super::error::{ConnectError, SendRequestError};
@@ -32,6 +32,7 @@ pub(crate) async fn send_request<Io, B>(
 where
     Io: ConnectionIo,
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     // set request host header
     if !head.as_ref().headers.contains_key(HOST)
@@ -154,6 +155,7 @@ pub(crate) async fn send_body<Io, B>(
 where
     Io: ConnectionIo,
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     actix_rt::pin!(body);
 
@@ -161,9 +163,10 @@ where
     while !eof {
         while !eof && !framed.as_ref().is_write_buf_full() {
             match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
-                Some(result) => {
-                    framed.as_mut().write(h1::Message::Chunk(Some(result?)))?;
+                Some(Ok(chunk)) => {
+                    framed.as_mut().write(h1::Message::Chunk(Some(chunk)))?;
                 }
+                Some(Err(err)) => return Err(err.into().into()),
                 None => {
                     eof = true;
                     framed.as_mut().write(h1::Message::Chunk(None))?;
diff --git a/actix-http/src/client/h2proto.rs b/actix-http/src/client/h2proto.rs
index 8cb2e2522..cf423ef12 100644
--- a/actix-http/src/client/h2proto.rs
+++ b/actix-http/src/client/h2proto.rs
@@ -9,14 +9,19 @@ use h2::{
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http::{request::Request, Method, Version};
 
-use crate::body::{BodySize, MessageBody};
-use crate::header::HeaderMap;
-use crate::message::{RequestHeadType, ResponseHead};
-use crate::payload::Payload;
+use crate::{
+    body::{BodySize, MessageBody},
+    header::HeaderMap,
+    message::{RequestHeadType, ResponseHead},
+    payload::Payload,
+    Error,
+};
 
-use super::config::ConnectorConfig;
-use super::connection::{ConnectionIo, H2Connection};
-use super::error::SendRequestError;
+use super::{
+    config::ConnectorConfig,
+    connection::{ConnectionIo, H2Connection},
+    error::SendRequestError,
+};
 
 pub(crate) async fn send_request<Io, B>(
     mut io: H2Connection<Io>,
@@ -26,6 +31,7 @@ pub(crate) async fn send_request<Io, B>(
 where
     Io: ConnectionIo,
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     trace!("Sending client request: {:?} {:?}", head, body.size());
 
@@ -125,10 +131,14 @@ where
     Ok((head, payload))
 }
 
-async fn send_body<B: MessageBody>(
+async fn send_body<B>(
     body: B,
     mut send: SendStream<Bytes>,
-) -> Result<(), SendRequestError> {
+) -> Result<(), SendRequestError>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
     let mut buf = None;
     actix_rt::pin!(body);
     loop {
@@ -138,7 +148,7 @@ async fn send_body<B: MessageBody>(
                     send.reserve_capacity(b.len());
                     buf = Some(b);
                 }
-                Some(Err(e)) => return Err(e.into()),
+                Some(Err(e)) => return Err(e.into().into()),
                 None => {
                     if let Err(e) = send.send_data(Bytes::new(), true) {
                         return Err(e.into());
diff --git a/actix-http/src/encoding/decoder.rs b/actix-http/src/encoding/decoder.rs
index f0abae865..d3e304836 100644
--- a/actix-http/src/encoding/decoder.rs
+++ b/actix-http/src/encoding/decoder.rs
@@ -8,11 +8,18 @@ use std::{
 };
 
 use actix_rt::task::{spawn_blocking, JoinHandle};
-use brotli2::write::BrotliDecoder;
 use bytes::Bytes;
-use flate2::write::{GzDecoder, ZlibDecoder};
 use futures_core::{ready, Stream};
 
+#[cfg(feature = "compress-brotli")]
+use brotli2::write::BrotliDecoder;
+
+#[cfg(feature = "compress-gzip")]
+use flate2::write::{GzDecoder, ZlibDecoder};
+
+#[cfg(feature = "compress-zstd")]
+use zstd::stream::write::Decoder as ZstdDecoder;
+
 use crate::{
     encoding::Writer,
     error::{BlockingError, PayloadError},
@@ -36,15 +43,25 @@ where
     #[inline]
     pub fn new(stream: S, encoding: ContentEncoding) -> Decoder<S> {
         let decoder = match encoding {
+            #[cfg(feature = "compress-brotli")]
             ContentEncoding::Br => Some(ContentDecoder::Br(Box::new(
                 BrotliDecoder::new(Writer::new()),
             ))),
+            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Deflate => Some(ContentDecoder::Deflate(Box::new(
                 ZlibDecoder::new(Writer::new()),
             ))),
+            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Gzip => Some(ContentDecoder::Gzip(Box::new(
                 GzDecoder::new(Writer::new()),
             ))),
+            #[cfg(feature = "compress-zstd")]
+            ContentEncoding::Zstd => Some(ContentDecoder::Zstd(Box::new(
+                ZstdDecoder::new(Writer::new()).expect(
+                    "Failed to create zstd decoder. This is a bug. \
+                         Please report it to the actix-web repository.",
+                ),
+            ))),
             _ => None,
         };
 
@@ -141,14 +158,22 @@ where
 }
 
 enum ContentDecoder {
+    #[cfg(feature = "compress-gzip")]
     Deflate(Box<ZlibDecoder<Writer>>),
+    #[cfg(feature = "compress-gzip")]
     Gzip(Box<GzDecoder<Writer>>),
+    #[cfg(feature = "compress-brotli")]
     Br(Box<BrotliDecoder<Writer>>),
+    // We need explicit 'static lifetime here because ZstdDecoder need lifetime
+    // argument, and we use `spawn_blocking` in `Decoder::poll_next` that require `FnOnce() -> R + Send + 'static`
+    #[cfg(feature = "compress-zstd")]
+    Zstd(Box<ZstdDecoder<'static, Writer>>),
 }
 
 impl ContentDecoder {
     fn feed_eof(&mut self) -> io::Result<Option<Bytes>> {
         match self {
+            #[cfg(feature = "compress-brotli")]
             ContentDecoder::Br(ref mut decoder) => match decoder.flush() {
                 Ok(()) => {
                     let b = decoder.get_mut().take();
@@ -162,6 +187,7 @@ impl ContentDecoder {
                 Err(e) => Err(e),
             },
 
+            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Gzip(ref mut decoder) => match decoder.try_finish() {
                 Ok(_) => {
                     let b = decoder.get_mut().take();
@@ -175,6 +201,7 @@ impl ContentDecoder {
                 Err(e) => Err(e),
             },
 
+            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Deflate(ref mut decoder) => match decoder.try_finish() {
                 Ok(_) => {
                     let b = decoder.get_mut().take();
@@ -186,11 +213,25 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
+
+            #[cfg(feature = "compress-zstd")]
+            ContentDecoder::Zstd(ref mut decoder) => match decoder.flush() {
+                Ok(_) => {
+                    let b = decoder.get_mut().take();
+                    if !b.is_empty() {
+                        Ok(Some(b))
+                    } else {
+                        Ok(None)
+                    }
+                }
+                Err(e) => Err(e),
+            },
         }
     }
 
     fn feed_data(&mut self, data: Bytes) -> io::Result<Option<Bytes>> {
         match self {
+            #[cfg(feature = "compress-brotli")]
             ContentDecoder::Br(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
@@ -205,6 +246,7 @@ impl ContentDecoder {
                 Err(e) => Err(e),
             },
 
+            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Gzip(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
@@ -219,6 +261,7 @@ impl ContentDecoder {
                 Err(e) => Err(e),
             },
 
+            #[cfg(feature = "compress-gzip")]
             ContentDecoder::Deflate(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
@@ -232,6 +275,21 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
+
+            #[cfg(feature = "compress-zstd")]
+            ContentDecoder::Zstd(ref mut decoder) => match decoder.write_all(&data) {
+                Ok(_) => {
+                    decoder.flush()?;
+
+                    let b = decoder.get_mut().take();
+                    if !b.is_empty() {
+                        Ok(Some(b))
+                    } else {
+                        Ok(None)
+                    }
+                }
+                Err(e) => Err(e),
+            },
         }
     }
 }
diff --git a/actix-http/src/encoding/encoder.rs b/actix-http/src/encoding/encoder.rs
index add6ee980..1e69990a0 100644
--- a/actix-http/src/encoding/encoder.rs
+++ b/actix-http/src/encoding/encoder.rs
@@ -1,6 +1,7 @@
 //! Stream encoders.
 
 use std::{
+    error::Error as StdError,
     future::Future,
     io::{self, Write as _},
     pin::Pin,
@@ -8,14 +9,22 @@ use std::{
 };
 
 use actix_rt::task::{spawn_blocking, JoinHandle};
-use brotli2::write::BrotliEncoder;
 use bytes::Bytes;
-use flate2::write::{GzEncoder, ZlibEncoder};
+use derive_more::Display;
 use futures_core::ready;
 use pin_project::pin_project;
 
+#[cfg(feature = "compress-brotli")]
+use brotli2::write::BrotliEncoder;
+
+#[cfg(feature = "compress-gzip")]
+use flate2::write::{GzEncoder, ZlibEncoder};
+
+#[cfg(feature = "compress-zstd")]
+use zstd::stream::write::Encoder as ZstdEncoder;
+
 use crate::{
-    body::{Body, BodySize, MessageBody, ResponseBody},
+    body::{Body, BodySize, BoxAnyBody, MessageBody, ResponseBody},
     http::{
         header::{ContentEncoding, CONTENT_ENCODING},
         HeaderValue, StatusCode,
@@ -92,10 +101,16 @@ impl<B: MessageBody> Encoder<B> {
 enum EncoderBody<B> {
     Bytes(Bytes),
     Stream(#[pin] B),
-    BoxedStream(Pin<Box<dyn MessageBody>>),
+    BoxedStream(BoxAnyBody),
 }
 
-impl<B: MessageBody> MessageBody for EncoderBody<B> {
+impl<B> MessageBody for EncoderBody<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = EncoderError<B::Error>;
+
     fn size(&self) -> BodySize {
         match self {
             EncoderBody::Bytes(ref b) => b.size(),
@@ -107,7 +122,7 @@ impl<B: MessageBody> MessageBody for EncoderBody<B> {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         match self.project() {
             EncoderBodyProj::Bytes(b) => {
                 if b.is_empty() {
@@ -116,13 +131,30 @@ impl<B: MessageBody> MessageBody for EncoderBody<B> {
                     Poll::Ready(Some(Ok(std::mem::take(b))))
                 }
             }
-            EncoderBodyProj::Stream(b) => b.poll_next(cx),
-            EncoderBodyProj::BoxedStream(ref mut b) => b.as_mut().poll_next(cx),
+            // TODO: MSRV 1.51: poll_map_err
+            EncoderBodyProj::Stream(b) => match ready!(b.poll_next(cx)) {
+                Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Body(err)))),
+                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                None => Poll::Ready(None),
+            },
+            EncoderBodyProj::BoxedStream(ref mut b) => {
+                match ready!(b.as_pin_mut().poll_next(cx)) {
+                    Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Boxed(err)))),
+                    Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                    None => Poll::Ready(None),
+                }
+            }
         }
     }
 }
 
-impl<B: MessageBody> MessageBody for Encoder<B> {
+impl<B> MessageBody for Encoder<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = EncoderError<B::Error>;
+
     fn size(&self) -> BodySize {
         if self.encoder.is_none() {
             self.body.size()
@@ -134,7 +166,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         let mut this = self.project();
         loop {
             if *this.eof {
@@ -142,8 +174,9 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
             }
 
             if let Some(ref mut fut) = this.fut {
-                let mut encoder =
-                    ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
+                let mut encoder = ready!(Pin::new(fut).poll(cx))
+                    .map_err(|_| EncoderError::Blocking(BlockingError))?
+                    .map_err(EncoderError::Io)?;
 
                 let chunk = encoder.take();
                 *this.encoder = Some(encoder);
@@ -162,7 +195,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
                 Some(Ok(chunk)) => {
                     if let Some(mut encoder) = this.encoder.take() {
                         if chunk.len() < MAX_CHUNK_SIZE_ENCODE_IN_PLACE {
-                            encoder.write(&chunk)?;
+                            encoder.write(&chunk).map_err(EncoderError::Io)?;
                             let chunk = encoder.take();
                             *this.encoder = Some(encoder);
 
@@ -182,7 +215,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
 
                 None => {
                     if let Some(encoder) = this.encoder.take() {
-                        let chunk = encoder.finish()?;
+                        let chunk = encoder.finish().map_err(EncoderError::Io)?;
                         if chunk.is_empty() {
                             return Poll::Ready(None);
                         } else {
@@ -206,25 +239,40 @@ fn update_head(encoding: ContentEncoding, head: &mut ResponseHead) {
 }
 
 enum ContentEncoder {
+    #[cfg(feature = "compress-gzip")]
     Deflate(ZlibEncoder<Writer>),
+    #[cfg(feature = "compress-gzip")]
     Gzip(GzEncoder<Writer>),
+    #[cfg(feature = "compress-brotli")]
     Br(BrotliEncoder<Writer>),
+    // We need explicit 'static lifetime here because ZstdEncoder need lifetime
+    // argument, and we use `spawn_blocking` in `Encoder::poll_next` that require `FnOnce() -> R + Send + 'static`
+    #[cfg(feature = "compress-zstd")]
+    Zstd(ZstdEncoder<'static, Writer>),
 }
 
 impl ContentEncoder {
     fn encoder(encoding: ContentEncoding) -> Option<Self> {
         match encoding {
+            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Deflate => Some(ContentEncoder::Deflate(ZlibEncoder::new(
                 Writer::new(),
                 flate2::Compression::fast(),
             ))),
+            #[cfg(feature = "compress-gzip")]
             ContentEncoding::Gzip => Some(ContentEncoder::Gzip(GzEncoder::new(
                 Writer::new(),
                 flate2::Compression::fast(),
             ))),
+            #[cfg(feature = "compress-brotli")]
             ContentEncoding::Br => {
                 Some(ContentEncoder::Br(BrotliEncoder::new(Writer::new(), 3)))
             }
+            #[cfg(feature = "compress-zstd")]
+            ContentEncoding::Zstd => {
+                let encoder = ZstdEncoder::new(Writer::new(), 3).ok()?;
+                Some(ContentEncoder::Zstd(encoder))
+            }
             _ => None,
         }
     }
@@ -232,31 +280,45 @@ impl ContentEncoder {
     #[inline]
     pub(crate) fn take(&mut self) -> Bytes {
         match *self {
+            #[cfg(feature = "compress-brotli")]
             ContentEncoder::Br(ref mut encoder) => encoder.get_mut().take(),
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Deflate(ref mut encoder) => encoder.get_mut().take(),
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Gzip(ref mut encoder) => encoder.get_mut().take(),
+            #[cfg(feature = "compress-zstd")]
+            ContentEncoder::Zstd(ref mut encoder) => encoder.get_mut().take(),
         }
     }
 
     fn finish(self) -> Result<Bytes, io::Error> {
         match self {
+            #[cfg(feature = "compress-brotli")]
             ContentEncoder::Br(encoder) => match encoder.finish() {
                 Ok(writer) => Ok(writer.buf.freeze()),
                 Err(err) => Err(err),
             },
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Gzip(encoder) => match encoder.finish() {
                 Ok(writer) => Ok(writer.buf.freeze()),
                 Err(err) => Err(err),
             },
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Deflate(encoder) => match encoder.finish() {
                 Ok(writer) => Ok(writer.buf.freeze()),
                 Err(err) => Err(err),
             },
+            #[cfg(feature = "compress-zstd")]
+            ContentEncoder::Zstd(encoder) => match encoder.finish() {
+                Ok(writer) => Ok(writer.buf.freeze()),
+                Err(err) => Err(err),
+            },
         }
     }
 
     fn write(&mut self, data: &[u8]) -> Result<(), io::Error> {
         match *self {
+            #[cfg(feature = "compress-brotli")]
             ContentEncoder::Br(ref mut encoder) => match encoder.write_all(data) {
                 Ok(_) => Ok(()),
                 Err(err) => {
@@ -264,6 +326,7 @@ impl ContentEncoder {
                     Err(err)
                 }
             },
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Gzip(ref mut encoder) => match encoder.write_all(data) {
                 Ok(_) => Ok(()),
                 Err(err) => {
@@ -271,6 +334,7 @@ impl ContentEncoder {
                     Err(err)
                 }
             },
+            #[cfg(feature = "compress-gzip")]
             ContentEncoder::Deflate(ref mut encoder) => match encoder.write_all(data) {
                 Ok(_) => Ok(()),
                 Err(err) => {
@@ -278,6 +342,47 @@ impl ContentEncoder {
                     Err(err)
                 }
             },
+            #[cfg(feature = "compress-zstd")]
+            ContentEncoder::Zstd(ref mut encoder) => match encoder.write_all(data) {
+                Ok(_) => Ok(()),
+                Err(err) => {
+                    trace!("Error decoding ztsd encoding: {}", err);
+                    Err(err)
+                }
+            },
         }
     }
 }
+
+#[derive(Debug, Display)]
+#[non_exhaustive]
+pub enum EncoderError<E> {
+    #[display(fmt = "body")]
+    Body(E),
+
+    #[display(fmt = "boxed")]
+    Boxed(Box<dyn StdError>),
+
+    #[display(fmt = "blocking")]
+    Blocking(BlockingError),
+
+    #[display(fmt = "io")]
+    Io(io::Error),
+}
+
+impl<E: StdError + 'static> StdError for EncoderError<E> {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        match self {
+            EncoderError::Body(err) => Some(err),
+            EncoderError::Boxed(err) => Some(&**err),
+            EncoderError::Blocking(err) => Some(err),
+            EncoderError::Io(err) => Some(err),
+        }
+    }
+}
+
+impl<E: StdError + 'static> From<EncoderError<E>> for crate::Error {
+    fn from(err: EncoderError<E>) -> Self {
+        crate::Error::new_encoder().with_cause(err)
+    }
+}
diff --git a/actix-http/src/error.rs b/actix-http/src/error.rs
index 39ffa29e7..d9e1a1ed2 100644
--- a/actix-http/src/error.rs
+++ b/actix-http/src/error.rs
@@ -1,193 +1,155 @@
 //! Error and Result module
 
-use std::{
-    cell::RefCell,
-    fmt,
-    io::{self, Write as _},
-    str::Utf8Error,
-    string::FromUtf8Error,
-};
+use std::{error::Error as StdError, fmt, io, str::Utf8Error, string::FromUtf8Error};
 
-use bytes::BytesMut;
 use derive_more::{Display, Error, From};
-use http::{header, uri::InvalidUri, StatusCode};
-use serde::de::value::Error as DeError;
+use http::{uri::InvalidUri, StatusCode};
 
-use crate::{body::Body, helpers::Writer, Response, ResponseBuilder};
+use crate::{
+    body::{AnyBody, Body},
+    ws, Response,
+};
 
 pub use http::Error as HttpError;
 
-/// A specialized [`std::result::Result`] for Actix Web operations.
-///
-/// This typedef is generally used to avoid writing out `actix_http::error::Error` directly and is
-/// otherwise a direct mapping to `Result`.
-pub type Result<T, E = Error> = std::result::Result<T, E>;
-
-/// General purpose actix web error.
-///
-/// An actix web error is used to carry errors from `std::error`
-/// through actix in a convenient way.  It can be created through
-/// converting errors with `into()`.
-///
-/// Whenever it is created from an external object a response error is created
-/// for it that can be used to create an HTTP response from it this means that
-/// if you have access to an actix `Error` you can always get a
-/// `ResponseError` reference from it.
 pub struct Error {
-    cause: Box<dyn ResponseError>,
+    inner: Box<ErrorInner>,
+}
+
+pub(crate) struct ErrorInner {
+    #[allow(dead_code)]
+    kind: Kind,
+    cause: Option<Box<dyn StdError>>,
 }
 
 impl Error {
-    /// Returns the reference to the underlying `ResponseError`.
-    pub fn as_response_error(&self) -> &dyn ResponseError {
-        self.cause.as_ref()
+    fn new(kind: Kind) -> Self {
+        Self {
+            inner: Box::new(ErrorInner { kind, cause: None }),
+        }
     }
 
-    /// Similar to `as_response_error` but downcasts.
-    pub fn as_error<T: ResponseError + 'static>(&self) -> Option<&T> {
-        <dyn ResponseError>::downcast_ref(self.cause.as_ref())
+    pub(crate) fn new_http() -> Self {
+        Self::new(Kind::Http)
+    }
+
+    pub(crate) fn new_parse() -> Self {
+        Self::new(Kind::Parse)
+    }
+
+    pub(crate) fn new_payload() -> Self {
+        Self::new(Kind::Payload)
+    }
+
+    pub(crate) fn new_body() -> Self {
+        Self::new(Kind::Body)
+    }
+
+    pub(crate) fn new_send_response() -> Self {
+        Self::new(Kind::SendResponse)
+    }
+
+    // TODO: remove allow
+    #[allow(dead_code)]
+    pub(crate) fn new_io() -> Self {
+        Self::new(Kind::Io)
+    }
+
+    pub(crate) fn new_encoder() -> Self {
+        Self::new(Kind::Encoder)
+    }
+
+    pub(crate) fn new_ws() -> Self {
+        Self::new(Kind::Ws)
+    }
+
+    pub(crate) fn with_cause(mut self, cause: impl Into<Box<dyn StdError>>) -> Self {
+        self.inner.cause = Some(cause.into());
+        self
     }
 }
 
-/// Errors that can generate responses.
-pub trait ResponseError: fmt::Debug + fmt::Display {
-    /// Returns appropriate status code for error.
-    ///
-    /// A 500 Internal Server Error is used by default. If [error_response](Self::error_response) is
-    /// also implemented and does not call `self.status_code()`, then this will not be used.
-    fn status_code(&self) -> StatusCode {
-        StatusCode::INTERNAL_SERVER_ERROR
-    }
+impl From<Error> for Response<AnyBody> {
+    fn from(err: Error) -> Self {
+        let status_code = match err.inner.kind {
+            Kind::Parse => StatusCode::BAD_REQUEST,
+            _ => StatusCode::INTERNAL_SERVER_ERROR,
+        };
 
-    /// Creates full response for error.
-    ///
-    /// By default, the generated response uses a 500 Internal Server Error status code, a
-    /// `Content-Type` of `text/plain`, and the body is set to `Self`'s `Display` impl.
-    fn error_response(&self) -> Response<Body> {
-        let mut resp = Response::new(self.status_code());
-        let mut buf = BytesMut::new();
-        let _ = write!(Writer(&mut buf), "{}", self);
-        resp.headers_mut().insert(
-            header::CONTENT_TYPE,
-            header::HeaderValue::from_static("text/plain; charset=utf-8"),
-        );
-        resp.set_body(Body::from(buf))
+        Response::new(status_code).set_body(Body::from(err.to_string()))
     }
-
-    downcast_get_type_id!();
 }
 
-downcast!(ResponseError);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Display)]
+pub enum Kind {
+    #[display(fmt = "error processing HTTP")]
+    Http,
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.cause, f)
-    }
+    #[display(fmt = "error parsing HTTP message")]
+    Parse,
+
+    #[display(fmt = "request payload read error")]
+    Payload,
+
+    #[display(fmt = "response body write error")]
+    Body,
+
+    #[display(fmt = "send response error")]
+    SendResponse,
+
+    #[display(fmt = "error in WebSocket process")]
+    Ws,
+
+    #[display(fmt = "connection error")]
+    Io,
+
+    #[display(fmt = "encoder error")]
+    Encoder,
 }
 
 impl fmt::Debug for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", &self.cause)
+        // TODO: more detail
+        f.write_str("actix_http::Error")
     }
 }
 
-impl std::error::Error for Error {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        None
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.inner.cause.as_ref() {
+            Some(err) => write!(f, "{}: {}", &self.inner.kind, err),
+            None => write!(f, "{}", &self.inner.kind),
+        }
     }
 }
 
-impl From<()> for Error {
-    fn from(_: ()) -> Self {
-        Error::from(UnitError)
+impl StdError for Error {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.inner.cause.as_ref().map(|err| err.as_ref())
     }
 }
 
 impl From<std::convert::Infallible> for Error {
-    fn from(_: std::convert::Infallible) -> Self {
-        // `std::convert::Infallible` indicates an error
-        // that will never happen
-        unreachable!()
+    fn from(err: std::convert::Infallible) -> Self {
+        match err {}
     }
 }
 
-/// Convert `Error` to a `Response` instance
-impl From<Error> for Response<Body> {
-    fn from(err: Error) -> Self {
-        Response::from_error(err)
+impl From<ws::ProtocolError> for Error {
+    fn from(err: ws::ProtocolError) -> Self {
+        Self::new_ws().with_cause(err)
     }
 }
 
-/// `Error` for any error that implements `ResponseError`
-impl<T: ResponseError + 'static> From<T> for Error {
-    fn from(err: T) -> Error {
-        Error {
-            cause: Box::new(err),
-        }
+impl From<HttpError> for Error {
+    fn from(err: HttpError) -> Self {
+        Self::new_http().with_cause(err)
     }
 }
 
-/// Convert Response to a Error
-impl From<Response<Body>> for Error {
-    fn from(res: Response<Body>) -> Error {
-        InternalError::from_response("", res).into()
-    }
-}
-
-/// Convert ResponseBuilder to a Error
-impl From<ResponseBuilder> for Error {
-    fn from(mut res: ResponseBuilder) -> Error {
-        InternalError::from_response("", res.finish()).into()
-    }
-}
-
-#[derive(Debug, Display, Error)]
-#[display(fmt = "Unknown Error")]
-struct UnitError;
-
-/// Returns [`StatusCode::INTERNAL_SERVER_ERROR`] for [`UnitError`].
-impl ResponseError for UnitError {}
-
-/// Returns [`StatusCode::INTERNAL_SERVER_ERROR`] for [`actix_tls::accept::openssl::SslError`].
-#[cfg(feature = "openssl")]
-impl ResponseError for actix_tls::accept::openssl::SslError {}
-
-/// Returns [`StatusCode::BAD_REQUEST`] for [`DeError`].
-impl ResponseError for DeError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
-    }
-}
-
-/// Returns [`StatusCode::BAD_REQUEST`] for [`Utf8Error`].
-impl ResponseError for Utf8Error {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
-    }
-}
-
-/// Returns [`StatusCode::INTERNAL_SERVER_ERROR`] for [`HttpError`].
-impl ResponseError for HttpError {}
-
-/// Inspects the underlying [`io::ErrorKind`] and returns an appropriate status code.
-///
-/// If the error is [`io::ErrorKind::NotFound`], [`StatusCode::NOT_FOUND`] is returned. If the
-/// error is [`io::ErrorKind::PermissionDenied`], [`StatusCode::FORBIDDEN`] is returned. Otherwise,
-/// [`StatusCode::INTERNAL_SERVER_ERROR`] is returned.
-impl ResponseError for io::Error {
-    fn status_code(&self) -> StatusCode {
-        match self.kind() {
-            io::ErrorKind::NotFound => StatusCode::NOT_FOUND,
-            io::ErrorKind::PermissionDenied => StatusCode::FORBIDDEN,
-            _ => StatusCode::INTERNAL_SERVER_ERROR,
-        }
-    }
-}
-
-/// Returns [`StatusCode::BAD_REQUEST`] for [`header::InvalidHeaderValue`].
-impl ResponseError for header::InvalidHeaderValue {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
+impl From<ws::HandshakeError> for Error {
+    fn from(err: ws::HandshakeError) -> Self {
+        Self::new_ws().with_cause(err)
     }
 }
 
@@ -237,13 +199,6 @@ pub enum ParseError {
     Utf8(Utf8Error),
 }
 
-/// Return `BadRequest` for `ParseError`
-impl ResponseError for ParseError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
-    }
-}
-
 impl From<io::Error> for ParseError {
     fn from(err: io::Error) -> ParseError {
         ParseError::Io(err)
@@ -282,14 +237,23 @@ impl From<httparse::Error> for ParseError {
     }
 }
 
+impl From<ParseError> for Error {
+    fn from(err: ParseError) -> Self {
+        Self::new_parse().with_cause(err)
+    }
+}
+
+impl From<ParseError> for Response<AnyBody> {
+    fn from(err: ParseError) -> Self {
+        Error::from(err).into()
+    }
+}
+
 /// A set of errors that can occur running blocking tasks in thread pool.
 #[derive(Debug, Display, Error)]
 #[display(fmt = "Blocking thread pool is gone")]
 pub struct BlockingError;
 
-/// `InternalServerError` for `BlockingError`
-impl ResponseError for BlockingError {}
-
 /// A set of errors that can occur during payload parsing.
 #[derive(Debug, Display)]
 #[non_exhaustive]
@@ -363,16 +327,9 @@ impl From<BlockingError> for PayloadError {
     }
 }
 
-/// `PayloadError` returns two possible results:
-///
-/// - `Overflow` returns `PayloadTooLarge`
-/// - Other errors returns `BadRequest`
-impl ResponseError for PayloadError {
-    fn status_code(&self) -> StatusCode {
-        match *self {
-            PayloadError::Overflow => StatusCode::PAYLOAD_TOO_LARGE,
-            _ => StatusCode::BAD_REQUEST,
-        }
+impl From<PayloadError> for Error {
+    fn from(err: PayloadError) -> Self {
+        Self::new_payload().with_cause(err)
     }
 }
 
@@ -381,13 +338,19 @@ impl ResponseError for PayloadError {
 #[non_exhaustive]
 pub enum DispatchError {
     /// Service error
-    Service(Error),
+    // FIXME: display and error type
+    #[display(fmt = "Service Error")]
+    Service(#[error(not(source))] Response<AnyBody>),
+
+    /// Body error
+    // FIXME: display and error type
+    #[display(fmt = "Body Error")]
+    Body(#[error(not(source))] Box<dyn StdError>),
 
     /// Upgrade service error
     Upgrade,
 
-    /// An `io::Error` that occurred while trying to read or write to a network
-    /// stream.
+    /// An `io::Error` that occurred while trying to read or write to a network stream.
     #[display(fmt = "IO error: {}", _0)]
     Io(io::Error),
 
@@ -453,180 +416,6 @@ mod content_type_test_impls {
     }
 }
 
-/// Return `BadRequest` for `ContentTypeError`
-impl ResponseError for ContentTypeError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
-    }
-}
-
-/// Helper type that can wrap any error and generate custom response.
-///
-/// In following example any `io::Error` will be converted into "BAD REQUEST"
-/// response as opposite to *INTERNAL SERVER ERROR* which is defined by
-/// default.
-///
-/// ```
-/// # use std::io;
-/// # use actix_http::*;
-///
-/// fn index(req: Request) -> Result<&'static str> {
-///     Err(error::ErrorBadRequest(io::Error::new(io::ErrorKind::Other, "error")))
-/// }
-/// ```
-pub struct InternalError<T> {
-    cause: T,
-    status: InternalErrorType,
-}
-
-enum InternalErrorType {
-    Status(StatusCode),
-    Response(RefCell<Option<Response<Body>>>),
-}
-
-impl<T> InternalError<T> {
-    /// Create `InternalError` instance
-    pub fn new(cause: T, status: StatusCode) -> Self {
-        InternalError {
-            cause,
-            status: InternalErrorType::Status(status),
-        }
-    }
-
-    /// Create `InternalError` with predefined `Response`.
-    pub fn from_response(cause: T, response: Response<Body>) -> Self {
-        InternalError {
-            cause,
-            status: InternalErrorType::Response(RefCell::new(Some(response))),
-        }
-    }
-}
-
-impl<T> fmt::Debug for InternalError<T>
-where
-    T: fmt::Debug + 'static,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&self.cause, f)
-    }
-}
-
-impl<T> fmt::Display for InternalError<T>
-where
-    T: fmt::Display + 'static,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.cause, f)
-    }
-}
-
-impl<T> ResponseError for InternalError<T>
-where
-    T: fmt::Debug + fmt::Display + 'static,
-{
-    fn status_code(&self) -> StatusCode {
-        match self.status {
-            InternalErrorType::Status(st) => st,
-            InternalErrorType::Response(ref resp) => {
-                if let Some(resp) = resp.borrow().as_ref() {
-                    resp.head().status
-                } else {
-                    StatusCode::INTERNAL_SERVER_ERROR
-                }
-            }
-        }
-    }
-
-    fn error_response(&self) -> Response<Body> {
-        match self.status {
-            InternalErrorType::Status(st) => {
-                let mut res = Response::new(st);
-                let mut buf = BytesMut::new();
-                let _ = write!(Writer(&mut buf), "{}", self);
-                res.headers_mut().insert(
-                    header::CONTENT_TYPE,
-                    header::HeaderValue::from_static("text/plain; charset=utf-8"),
-                );
-                res.set_body(Body::from(buf))
-            }
-            InternalErrorType::Response(ref resp) => {
-                if let Some(resp) = resp.borrow_mut().take() {
-                    resp
-                } else {
-                    Response::new(StatusCode::INTERNAL_SERVER_ERROR)
-                }
-            }
-        }
-    }
-}
-
-macro_rules! error_helper {
-    ($name:ident, $status:ident) => {
-        paste::paste! {
-            #[doc = "Helper function that wraps any error and generates a `" $status "` response."]
-            #[allow(non_snake_case)]
-            pub fn $name<T>(err: T) -> Error
-            where
-            T: fmt::Debug + fmt::Display + 'static,
-            {
-                InternalError::new(err, StatusCode::$status).into()
-            }
-        }
-    }
-}
-
-error_helper!(ErrorBadRequest, BAD_REQUEST);
-error_helper!(ErrorUnauthorized, UNAUTHORIZED);
-error_helper!(ErrorPaymentRequired, PAYMENT_REQUIRED);
-error_helper!(ErrorForbidden, FORBIDDEN);
-error_helper!(ErrorNotFound, NOT_FOUND);
-error_helper!(ErrorMethodNotAllowed, METHOD_NOT_ALLOWED);
-error_helper!(ErrorNotAcceptable, NOT_ACCEPTABLE);
-error_helper!(
-    ErrorProxyAuthenticationRequired,
-    PROXY_AUTHENTICATION_REQUIRED
-);
-error_helper!(ErrorRequestTimeout, REQUEST_TIMEOUT);
-error_helper!(ErrorConflict, CONFLICT);
-error_helper!(ErrorGone, GONE);
-error_helper!(ErrorLengthRequired, LENGTH_REQUIRED);
-error_helper!(ErrorPayloadTooLarge, PAYLOAD_TOO_LARGE);
-error_helper!(ErrorUriTooLong, URI_TOO_LONG);
-error_helper!(ErrorUnsupportedMediaType, UNSUPPORTED_MEDIA_TYPE);
-error_helper!(ErrorRangeNotSatisfiable, RANGE_NOT_SATISFIABLE);
-error_helper!(ErrorImATeapot, IM_A_TEAPOT);
-error_helper!(ErrorMisdirectedRequest, MISDIRECTED_REQUEST);
-error_helper!(ErrorUnprocessableEntity, UNPROCESSABLE_ENTITY);
-error_helper!(ErrorLocked, LOCKED);
-error_helper!(ErrorFailedDependency, FAILED_DEPENDENCY);
-error_helper!(ErrorUpgradeRequired, UPGRADE_REQUIRED);
-error_helper!(ErrorPreconditionFailed, PRECONDITION_FAILED);
-error_helper!(ErrorPreconditionRequired, PRECONDITION_REQUIRED);
-error_helper!(ErrorTooManyRequests, TOO_MANY_REQUESTS);
-error_helper!(
-    ErrorRequestHeaderFieldsTooLarge,
-    REQUEST_HEADER_FIELDS_TOO_LARGE
-);
-error_helper!(
-    ErrorUnavailableForLegalReasons,
-    UNAVAILABLE_FOR_LEGAL_REASONS
-);
-error_helper!(ErrorExpectationFailed, EXPECTATION_FAILED);
-error_helper!(ErrorInternalServerError, INTERNAL_SERVER_ERROR);
-error_helper!(ErrorNotImplemented, NOT_IMPLEMENTED);
-error_helper!(ErrorBadGateway, BAD_GATEWAY);
-error_helper!(ErrorServiceUnavailable, SERVICE_UNAVAILABLE);
-error_helper!(ErrorGatewayTimeout, GATEWAY_TIMEOUT);
-error_helper!(ErrorHttpVersionNotSupported, HTTP_VERSION_NOT_SUPPORTED);
-error_helper!(ErrorVariantAlsoNegotiates, VARIANT_ALSO_NEGOTIATES);
-error_helper!(ErrorInsufficientStorage, INSUFFICIENT_STORAGE);
-error_helper!(ErrorLoopDetected, LOOP_DETECTED);
-error_helper!(ErrorNotExtended, NOT_EXTENDED);
-error_helper!(
-    ErrorNetworkAuthenticationRequired,
-    NETWORK_AUTHENTICATION_REQUIRED
-);
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -635,42 +424,36 @@ mod tests {
 
     #[test]
     fn test_into_response() {
-        let resp: Response<Body> = ParseError::Incomplete.error_response();
+        let resp: Response<AnyBody> = ParseError::Incomplete.into();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
 
         let err: HttpError = StatusCode::from_u16(10000).err().unwrap().into();
-        let resp: Response<Body> = err.error_response();
+        let resp: Response<AnyBody> = Error::new_http().with_cause(err).into();
         assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
     #[test]
     fn test_as_response() {
         let orig = io::Error::new(io::ErrorKind::Other, "other");
-        let e: Error = ParseError::Io(orig).into();
-        assert_eq!(format!("{}", e.as_response_error()), "IO error: other");
-    }
-
-    #[test]
-    fn test_error_cause() {
-        let orig = io::Error::new(io::ErrorKind::Other, "other");
-        let desc = orig.to_string();
-        let e = Error::from(orig);
-        assert_eq!(format!("{}", e.as_response_error()), desc);
+        let err: Error = ParseError::Io(orig).into();
+        assert_eq!(
+            format!("{}", err),
+            "error parsing HTTP message: IO error: other"
+        );
     }
 
     #[test]
     fn test_error_display() {
         let orig = io::Error::new(io::ErrorKind::Other, "other");
-        let desc = orig.to_string();
-        let e = Error::from(orig);
-        assert_eq!(format!("{}", e), desc);
+        let err = Error::new_io().with_cause(orig);
+        assert_eq!("connection error: other", err.to_string());
     }
 
     #[test]
     fn test_error_http_response() {
         let orig = io::Error::new(io::ErrorKind::Other, "other");
-        let e = Error::from(orig);
-        let resp: Response<Body> = e.into();
+        let err = Error::new_io().with_cause(orig);
+        let resp: Response<AnyBody> = err.into();
         assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
@@ -722,141 +505,4 @@ mod tests {
         from!(httparse::Error::TooManyHeaders => ParseError::TooLarge);
         from!(httparse::Error::Version => ParseError::Version);
     }
-
-    #[test]
-    fn test_internal_error() {
-        let err = InternalError::from_response(ParseError::Method, Response::ok());
-        let resp: Response<Body> = err.error_response();
-        assert_eq!(resp.status(), StatusCode::OK);
-    }
-
-    #[test]
-    fn test_error_casting() {
-        let err = PayloadError::Overflow;
-        let resp_err: &dyn ResponseError = &err;
-        let err = resp_err.downcast_ref::<PayloadError>().unwrap();
-        assert_eq!(err.to_string(), "Payload reached size limit.");
-        let not_err = resp_err.downcast_ref::<ContentTypeError>();
-        assert!(not_err.is_none());
-    }
-
-    #[test]
-    fn test_error_helpers() {
-        let res: Response<Body> = ErrorBadRequest("err").into();
-        assert_eq!(res.status(), StatusCode::BAD_REQUEST);
-
-        let res: Response<Body> = ErrorUnauthorized("err").into();
-        assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
-
-        let res: Response<Body> = ErrorPaymentRequired("err").into();
-        assert_eq!(res.status(), StatusCode::PAYMENT_REQUIRED);
-
-        let res: Response<Body> = ErrorForbidden("err").into();
-        assert_eq!(res.status(), StatusCode::FORBIDDEN);
-
-        let res: Response<Body> = ErrorNotFound("err").into();
-        assert_eq!(res.status(), StatusCode::NOT_FOUND);
-
-        let res: Response<Body> = ErrorMethodNotAllowed("err").into();
-        assert_eq!(res.status(), StatusCode::METHOD_NOT_ALLOWED);
-
-        let res: Response<Body> = ErrorNotAcceptable("err").into();
-        assert_eq!(res.status(), StatusCode::NOT_ACCEPTABLE);
-
-        let res: Response<Body> = ErrorProxyAuthenticationRequired("err").into();
-        assert_eq!(res.status(), StatusCode::PROXY_AUTHENTICATION_REQUIRED);
-
-        let res: Response<Body> = ErrorRequestTimeout("err").into();
-        assert_eq!(res.status(), StatusCode::REQUEST_TIMEOUT);
-
-        let res: Response<Body> = ErrorConflict("err").into();
-        assert_eq!(res.status(), StatusCode::CONFLICT);
-
-        let res: Response<Body> = ErrorGone("err").into();
-        assert_eq!(res.status(), StatusCode::GONE);
-
-        let res: Response<Body> = ErrorLengthRequired("err").into();
-        assert_eq!(res.status(), StatusCode::LENGTH_REQUIRED);
-
-        let res: Response<Body> = ErrorPreconditionFailed("err").into();
-        assert_eq!(res.status(), StatusCode::PRECONDITION_FAILED);
-
-        let res: Response<Body> = ErrorPayloadTooLarge("err").into();
-        assert_eq!(res.status(), StatusCode::PAYLOAD_TOO_LARGE);
-
-        let res: Response<Body> = ErrorUriTooLong("err").into();
-        assert_eq!(res.status(), StatusCode::URI_TOO_LONG);
-
-        let res: Response<Body> = ErrorUnsupportedMediaType("err").into();
-        assert_eq!(res.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
-
-        let res: Response<Body> = ErrorRangeNotSatisfiable("err").into();
-        assert_eq!(res.status(), StatusCode::RANGE_NOT_SATISFIABLE);
-
-        let res: Response<Body> = ErrorExpectationFailed("err").into();
-        assert_eq!(res.status(), StatusCode::EXPECTATION_FAILED);
-
-        let res: Response<Body> = ErrorImATeapot("err").into();
-        assert_eq!(res.status(), StatusCode::IM_A_TEAPOT);
-
-        let res: Response<Body> = ErrorMisdirectedRequest("err").into();
-        assert_eq!(res.status(), StatusCode::MISDIRECTED_REQUEST);
-
-        let res: Response<Body> = ErrorUnprocessableEntity("err").into();
-        assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY);
-
-        let res: Response<Body> = ErrorLocked("err").into();
-        assert_eq!(res.status(), StatusCode::LOCKED);
-
-        let res: Response<Body> = ErrorFailedDependency("err").into();
-        assert_eq!(res.status(), StatusCode::FAILED_DEPENDENCY);
-
-        let res: Response<Body> = ErrorUpgradeRequired("err").into();
-        assert_eq!(res.status(), StatusCode::UPGRADE_REQUIRED);
-
-        let res: Response<Body> = ErrorPreconditionRequired("err").into();
-        assert_eq!(res.status(), StatusCode::PRECONDITION_REQUIRED);
-
-        let res: Response<Body> = ErrorTooManyRequests("err").into();
-        assert_eq!(res.status(), StatusCode::TOO_MANY_REQUESTS);
-
-        let res: Response<Body> = ErrorRequestHeaderFieldsTooLarge("err").into();
-        assert_eq!(res.status(), StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE);
-
-        let res: Response<Body> = ErrorUnavailableForLegalReasons("err").into();
-        assert_eq!(res.status(), StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS);
-
-        let res: Response<Body> = ErrorInternalServerError("err").into();
-        assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
-
-        let res: Response<Body> = ErrorNotImplemented("err").into();
-        assert_eq!(res.status(), StatusCode::NOT_IMPLEMENTED);
-
-        let res: Response<Body> = ErrorBadGateway("err").into();
-        assert_eq!(res.status(), StatusCode::BAD_GATEWAY);
-
-        let res: Response<Body> = ErrorServiceUnavailable("err").into();
-        assert_eq!(res.status(), StatusCode::SERVICE_UNAVAILABLE);
-
-        let res: Response<Body> = ErrorGatewayTimeout("err").into();
-        assert_eq!(res.status(), StatusCode::GATEWAY_TIMEOUT);
-
-        let res: Response<Body> = ErrorHttpVersionNotSupported("err").into();
-        assert_eq!(res.status(), StatusCode::HTTP_VERSION_NOT_SUPPORTED);
-
-        let res: Response<Body> = ErrorVariantAlsoNegotiates("err").into();
-        assert_eq!(res.status(), StatusCode::VARIANT_ALSO_NEGOTIATES);
-
-        let res: Response<Body> = ErrorInsufficientStorage("err").into();
-        assert_eq!(res.status(), StatusCode::INSUFFICIENT_STORAGE);
-
-        let res: Response<Body> = ErrorLoopDetected("err").into();
-        assert_eq!(res.status(), StatusCode::LOOP_DETECTED);
-
-        let res: Response<Body> = ErrorNotExtended("err").into();
-        assert_eq!(res.status(), StatusCode::NOT_EXTENDED);
-
-        let res: Response<Body> = ErrorNetworkAuthenticationRequired("err").into();
-        assert_eq!(res.status(), StatusCode::NETWORK_AUTHENTICATION_REQUIRED);
-    }
 }
diff --git a/actix-http/src/h1/dispatcher.rs b/actix-http/src/h1/dispatcher.rs
index 3b272f0fb..b4adde638 100644
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
@@ -1,5 +1,6 @@
 use std::{
     collections::VecDeque,
+    error::Error as StdError,
     fmt,
     future::Future,
     io, mem, net,
@@ -17,19 +18,19 @@ use futures_core::ready;
 use log::{error, trace};
 use pin_project::pin_project;
 
-use crate::body::{Body, BodySize, MessageBody, ResponseBody};
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::error::{ParseError, PayloadError};
-use crate::http::StatusCode;
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpFlow;
-use crate::OnConnectData;
+use crate::{
+    body::{AnyBody, BodySize, MessageBody},
+    config::ServiceConfig,
+    error::{DispatchError, ParseError, PayloadError},
+    service::HttpFlow,
+    OnConnectData, Request, Response, StatusCode,
+};
 
-use super::codec::Codec;
-use super::payload::{Payload, PayloadSender, PayloadStatus};
-use super::{Message, MessageType};
+use super::{
+    codec::Codec,
+    payload::{Payload, PayloadSender, PayloadStatus},
+    Message, MessageType,
+};
 
 const LW_BUFFER_SIZE: usize = 1024;
 const HW_BUFFER_SIZE: usize = 1024 * 8;
@@ -50,10 +51,14 @@ bitflags! {
 pub struct Dispatcher<T, S, B, X, U>
 where
     S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -68,10 +73,14 @@ where
 enum DispatcherState<T, S, B, X, U>
 where
     S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -83,10 +92,14 @@ where
 struct InnerDispatcher<T, S, B, X, U>
 where
     S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -122,19 +135,25 @@ enum State<S, B, X>
 where
     S: Service<Request>,
     X: Service<Request, Response = Request>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
 {
     None,
     ExpectCall(#[pin] X::Future),
     ServiceCall(#[pin] S::Future),
-    SendPayload(#[pin] ResponseBody<B>),
+    SendPayload(#[pin] B),
+    SendErrorPayload(#[pin] AnyBody),
 }
 
 impl<S, B, X> State<S, B, X>
 where
     S: Service<Request>,
+
     X: Service<Request, Response = Request>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
 {
     fn is_empty(&self) -> bool {
         matches!(self, State::None)
@@ -150,12 +169,17 @@ enum PollResponse {
 impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
+
     S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
     S::Response: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -206,12 +230,17 @@ where
 impl<T, S, B, X, U> InnerDispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
+
     S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
     S::Response: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -268,11 +297,11 @@ where
         io.poll_flush(cx)
     }
 
-    fn send_response(
+    fn send_response_inner(
         self: Pin<&mut Self>,
         message: Response<()>,
-        body: ResponseBody<B>,
-    ) -> Result<(), DispatchError> {
+        body: &impl MessageBody,
+    ) -> Result<BodySize, DispatchError> {
         let size = body.size();
         let mut this = self.project();
         this.codec
@@ -285,10 +314,35 @@ where
             })?;
 
         this.flags.set(Flags::KEEPALIVE, this.codec.keepalive());
-        match size {
-            BodySize::None | BodySize::Empty => this.state.set(State::None),
-            _ => this.state.set(State::SendPayload(body)),
+
+        Ok(size)
+    }
+
+    fn send_response(
+        mut self: Pin<&mut Self>,
+        message: Response<()>,
+        body: B,
+    ) -> Result<(), DispatchError> {
+        let size = self.as_mut().send_response_inner(message, &body)?;
+        let state = match size {
+            BodySize::None | BodySize::Empty => State::None,
+            _ => State::SendPayload(body),
         };
+        self.project().state.set(state);
+        Ok(())
+    }
+
+    fn send_error_response(
+        mut self: Pin<&mut Self>,
+        message: Response<()>,
+        body: AnyBody,
+    ) -> Result<(), DispatchError> {
+        let size = self.as_mut().send_response_inner(message, &body)?;
+        let state = match size {
+            BodySize::None | BodySize::Empty => State::None,
+            _ => State::SendErrorPayload(body),
+        };
+        self.project().state.set(state);
         Ok(())
     }
 
@@ -326,8 +380,7 @@ where
                         // send_response would update InnerDispatcher state to SendPayload or
                         // None(If response body is empty).
                         // continue loop to poll it.
-                        self.as_mut()
-                            .send_response(res, ResponseBody::Other(Body::Empty))?;
+                        self.as_mut().send_error_response(res, AnyBody::Empty)?;
                     }
 
                     // return with upgrade request and poll it exclusively.
@@ -347,9 +400,9 @@ where
 
                     // send service call error as response
                     Poll::Ready(Err(err)) => {
-                        let res = Response::from_error(err.into());
+                        let res: Response<AnyBody> = err.into();
                         let (res, body) = res.replace_body(());
-                        self.as_mut().send_response(res, body.into_body())?;
+                        self.as_mut().send_error_response(res, body)?;
                     }
 
                     // service call pending and could be waiting for more chunk messages.
@@ -386,7 +439,42 @@ where
                             }
 
                             Poll::Ready(Some(Err(err))) => {
-                                return Err(DispatchError::Service(err))
+                                return Err(DispatchError::Body(err.into()))
+                            }
+
+                            Poll::Pending => return Ok(PollResponse::DoNothing),
+                        }
+                    }
+                    // buffer is beyond max size.
+                    // return and try to write the whole buffer to io stream.
+                    return Ok(PollResponse::DrainWriteBuf);
+                }
+
+                StateProj::SendErrorPayload(mut stream) => {
+                    // TODO: de-dupe impl with SendPayload
+
+                    // keep populate writer buffer until buffer size limit hit,
+                    // get blocked or finished.
+                    while this.write_buf.len() < super::payload::MAX_BUFFER_SIZE {
+                        match stream.as_mut().poll_next(cx) {
+                            Poll::Ready(Some(Ok(item))) => {
+                                this.codec.encode(
+                                    Message::Chunk(Some(item)),
+                                    &mut this.write_buf,
+                                )?;
+                            }
+
+                            Poll::Ready(None) => {
+                                this.codec
+                                    .encode(Message::Chunk(None), &mut this.write_buf)?;
+                                // payload stream finished.
+                                // set state to None and handle next message
+                                this.state.set(State::None);
+                                continue 'res;
+                            }
+
+                            Poll::Ready(Some(Err(err))) => {
+                                return Err(DispatchError::Service(err.into()))
                             }
 
                             Poll::Pending => return Ok(PollResponse::DoNothing),
@@ -406,12 +494,14 @@ where
                         let fut = this.flow.service.call(req);
                         this.state.set(State::ServiceCall(fut));
                     }
+
                     // send expect error as response
                     Poll::Ready(Err(err)) => {
-                        let res = Response::from_error(err.into());
+                        let res: Response<AnyBody> = err.into();
                         let (res, body) = res.replace_body(());
-                        self.as_mut().send_response(res, body.into_body())?;
+                        self.as_mut().send_error_response(res, body)?;
                     }
+
                     // expect must be solved before progress can be made.
                     Poll::Pending => return Ok(PollResponse::DoNothing),
                 },
@@ -457,9 +547,9 @@ where
                         // to notify the dispatcher a new state is set and the outer loop
                         // should be continue.
                         Poll::Ready(Err(err)) => {
-                            let res = Response::from_error(err.into());
+                            let res: Response<AnyBody> = err.into();
                             let (res, body) = res.replace_body(());
-                            return self.send_response(res, body.into_body());
+                            return self.send_error_response(res, body);
                         }
                     }
                 }
@@ -477,9 +567,9 @@ where
                         Poll::Pending => Ok(()),
                         // see the comment on ExpectCall state branch's Ready(Err(err)).
                         Poll::Ready(Err(err)) => {
-                            let res = Response::from_error(err.into());
+                            let res: Response<AnyBody> = err.into();
                             let (res, body) = res.replace_body(());
-                            self.send_response(res, body.into_body())
+                            self.send_error_response(res, body)
                         }
                     };
                 }
@@ -599,8 +689,10 @@ where
                     }
                     // Requests overflow buffer size should be responded with 431
                     this.messages.push_back(DispatcherMessage::Error(
-                        Response::new(StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE)
-                            .drop_body(),
+                        Response::with_body(
+                            StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE,
+                            (),
+                        ),
                     ));
                     this.flags.insert(Flags::READ_DISCONNECT);
                     *this.error = Some(ParseError::TooLarge.into());
@@ -679,10 +771,9 @@ where
                             } else {
                                 // timeout on first request (slow request) return 408
                                 trace!("Slow request timeout");
-                                let _ = self.as_mut().send_response(
-                                    Response::new(StatusCode::REQUEST_TIMEOUT)
-                                        .drop_body(),
-                                    ResponseBody::Other(Body::Empty),
+                                let _ = self.as_mut().send_error_response(
+                                    Response::with_body(StatusCode::REQUEST_TIMEOUT, ()),
+                                    AnyBody::Empty,
                                 );
                                 this = self.project();
                                 this.flags.insert(Flags::STARTED | Flags::SHUTDOWN);
@@ -817,12 +908,17 @@ where
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
+
     S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
     S::Response: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -972,16 +1068,17 @@ mod tests {
         }
     }
 
-    fn ok_service() -> impl Service<Request, Response = Response<Body>, Error = Error> {
+    fn ok_service() -> impl Service<Request, Response = Response<AnyBody>, Error = Error>
+    {
         fn_service(|_req: Request| ready(Ok::<_, Error>(Response::ok())))
     }
 
     fn echo_path_service(
-    ) -> impl Service<Request, Response = Response<Body>, Error = Error> {
+    ) -> impl Service<Request, Response = Response<AnyBody>, Error = Error> {
         fn_service(|req: Request| {
             let path = req.path().as_bytes();
             ready(Ok::<_, Error>(
-                Response::ok().set_body(Body::from_slice(path)),
+                Response::ok().set_body(AnyBody::from_slice(path)),
             ))
         })
     }
diff --git a/actix-http/src/h1/encoder.rs b/actix-http/src/h1/encoder.rs
index 4e9903284..254981123 100644
--- a/actix-http/src/h1/encoder.rs
+++ b/actix-http/src/h1/encoder.rs
@@ -6,14 +6,15 @@ use std::{cmp, io};
 
 use bytes::{BufMut, BytesMut};
 
-use crate::body::BodySize;
-use crate::config::ServiceConfig;
-use crate::header::{map::Value, HeaderName};
-use crate::helpers;
-use crate::http::header::{CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
-use crate::http::{HeaderMap, StatusCode, Version};
-use crate::message::{ConnectionType, RequestHeadType};
-use crate::response::Response;
+use crate::{
+    body::BodySize,
+    config::ServiceConfig,
+    header::{map::Value, HeaderMap, HeaderName},
+    header::{CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING},
+    helpers,
+    message::{ConnectionType, RequestHeadType},
+    Response, StatusCode, Version,
+};
 
 const AVERAGE_HEADER_SIZE: usize = 30;
 
@@ -287,7 +288,7 @@ impl MessageType for RequestHeadType {
         let head = self.as_ref();
         dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE);
         write!(
-            helpers::Writer(dst),
+            helpers::MutWriter(dst),
             "{} {} {}",
             head.method,
             head.uri.path_and_query().map(|u| u.as_str()).unwrap_or("/"),
@@ -420,7 +421,7 @@ impl TransferEncoding {
                     *eof = true;
                     buf.extend_from_slice(b"0\r\n\r\n");
                 } else {
-                    writeln!(helpers::Writer(buf), "{:X}\r", msg.len())
+                    writeln!(helpers::MutWriter(buf), "{:X}\r", msg.len())
                         .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
 
                     buf.reserve(msg.len() + 2);
@@ -630,8 +631,7 @@ mod tests {
     async fn test_no_content_length() {
         let mut bytes = BytesMut::with_capacity(2048);
 
-        let mut res: Response<()> =
-            Response::new(StatusCode::SWITCHING_PROTOCOLS).into_body::<()>();
+        let mut res = Response::with_body(StatusCode::SWITCHING_PROTOCOLS, ());
         res.headers_mut().insert(DATE, HeaderValue::from_static(""));
         res.headers_mut()
             .insert(CONTENT_LENGTH, HeaderValue::from_static("0"));
diff --git a/actix-http/src/h1/service.rs b/actix-http/src/h1/service.rs
index 916643a18..dbad8cfac 100644
--- a/actix-http/src/h1/service.rs
+++ b/actix-http/src/h1/service.rs
@@ -1,7 +1,11 @@
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-use std::{fmt, net};
+use std::{
+    error::Error as StdError,
+    fmt,
+    marker::PhantomData,
+    net,
+    rc::Rc,
+    task::{Context, Poll},
+};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_rt::net::TcpStream;
@@ -11,17 +15,15 @@ use actix_service::{
 use actix_utils::future::ready;
 use futures_core::future::LocalBoxFuture;
 
-use crate::body::MessageBody;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpServiceHandler;
-use crate::{ConnectCallback, OnConnectData};
+use crate::{
+    body::{AnyBody, MessageBody},
+    config::ServiceConfig,
+    error::DispatchError,
+    service::HttpServiceHandler,
+    ConnectCallback, OnConnectData, Request, Response,
+};
 
-use super::codec::Codec;
-use super::dispatcher::Dispatcher;
-use super::{ExpectHandler, UpgradeHandler};
+use super::{codec::Codec, dispatcher::Dispatcher, ExpectHandler, UpgradeHandler};
 
 /// `ServiceFactory` implementation for HTTP1 transport
 pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler> {
@@ -36,7 +38,7 @@ pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler> {
 impl<T, S, B> H1Service<T, S, B>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
     B: MessageBody,
@@ -61,17 +63,21 @@ impl<S, B, X, U> H1Service<TcpStream, S, B, X, U>
 where
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Future: 'static,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
     X::InitError: fmt::Debug,
+
     U: ServiceFactory<(Request, Framed<TcpStream, Codec>), Config = (), Response = ()>,
     U::Future: 'static,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
     U::InitError: fmt::Debug,
 {
     /// Create simple tcp stream service
@@ -106,21 +112,25 @@ mod openssl {
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Future: 'static,
-        S::Error: Into<Error>,
+        S::Error: Into<Response<AnyBody>>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
+
         B: MessageBody,
+        B::Error: Into<Box<dyn StdError>>,
+
         X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Future: 'static,
-        X::Error: Into<Error>,
+        X::Error: Into<Response<AnyBody>>,
         X::InitError: fmt::Debug,
+
         U: ServiceFactory<
             (Request, Framed<TlsStream<TcpStream>, Codec>),
             Config = (),
             Response = (),
         >,
         U::Future: 'static,
-        U::Error: fmt::Display + Into<Error>,
+        U::Error: fmt::Display + Into<Response<AnyBody>>,
         U::InitError: fmt::Debug,
     {
         /// Create openssl based service
@@ -162,21 +172,25 @@ mod rustls {
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Future: 'static,
-        S::Error: Into<Error>,
+        S::Error: Into<Response<AnyBody>>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
+
         B: MessageBody,
+        B::Error: Into<Box<dyn StdError>>,
+
         X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Future: 'static,
-        X::Error: Into<Error>,
+        X::Error: Into<Response<AnyBody>>,
         X::InitError: fmt::Debug,
+
         U: ServiceFactory<
             (Request, Framed<TlsStream<TcpStream>, Codec>),
             Config = (),
             Response = (),
         >,
         U::Future: 'static,
-        U::Error: fmt::Display + Into<Error>,
+        U::Error: fmt::Display + Into<Response<AnyBody>>,
         U::InitError: fmt::Debug,
     {
         /// Create rustls based service
@@ -205,7 +219,7 @@ mod rustls {
 impl<T, S, B, X, U> H1Service<T, S, B, X, U>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
     S::Response: Into<Response<B>>,
     S::InitError: fmt::Debug,
     B: MessageBody,
@@ -213,7 +227,7 @@ where
     pub fn expect<X1>(self, expect: X1) -> H1Service<T, S, B, X1, U>
     where
         X1: ServiceFactory<Request, Response = Request>,
-        X1::Error: Into<Error>,
+        X1::Error: Into<Response<AnyBody>>,
         X1::InitError: fmt::Debug,
     {
         H1Service {
@@ -253,19 +267,24 @@ impl<T, S, B, X, U> ServiceFactory<(T, Option<net::SocketAddr>)>
     for H1Service<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin + 'static,
+
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
     S::Response: Into<Response<B>>,
     S::InitError: fmt::Debug,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Future: 'static,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
     X::InitError: fmt::Debug,
+
     U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
     U::Future: 'static,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
     U::InitError: fmt::Debug,
 {
     type Response = ();
@@ -319,14 +338,19 @@ impl<T, S, B, X, U> Service<(T, Option<net::SocketAddr>)>
     for HttpServiceHandler<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
+
     S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
     S::Response: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
 {
     type Response = ();
     type Error = DispatchError;
diff --git a/actix-http/src/h1/utils.rs b/actix-http/src/h1/utils.rs
index 9e9c57137..523e652fd 100644
--- a/actix-http/src/h1/utils.rs
+++ b/actix-http/src/h1/utils.rs
@@ -4,7 +4,7 @@ use std::task::{Context, Poll};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 
-use crate::body::{BodySize, MessageBody, ResponseBody};
+use crate::body::{BodySize, MessageBody};
 use crate::error::Error;
 use crate::h1::{Codec, Message};
 use crate::response::Response;
@@ -14,7 +14,7 @@ use crate::response::Response;
 pub struct SendResponse<T, B> {
     res: Option<Message<(Response<()>, BodySize)>>,
     #[pin]
-    body: Option<ResponseBody<B>>,
+    body: Option<B>,
     #[pin]
     framed: Option<Framed<T, Codec>>,
 }
@@ -22,6 +22,7 @@ pub struct SendResponse<T, B> {
 impl<T, B> SendResponse<T, B>
 where
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     pub fn new(framed: Framed<T, Codec>, response: Response<B>) -> Self {
         let (res, body) = response.into_parts();
@@ -38,6 +39,7 @@ impl<T, B> Future for SendResponse<T, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
     B: MessageBody + Unpin,
+    B::Error: Into<Error>,
 {
     type Output = Result<Framed<T, Codec>, Error>;
 
@@ -60,7 +62,18 @@ where
                         .unwrap()
                         .is_write_buf_full()
                 {
-                    match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx)? {
+                    let next =
+                        // TODO: MSRV 1.51: poll_map_err
+                        match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx) {
+                            Poll::Ready(Some(Ok(item))) => Poll::Ready(Some(item)),
+                            Poll::Ready(Some(Err(err))) => {
+                                return Poll::Ready(Err(err.into()))
+                            }
+                            Poll::Ready(None) => Poll::Ready(None),
+                            Poll::Pending => Poll::Pending,
+                        };
+
+                    match next {
                         Poll::Ready(item) => {
                             // body is done when item is None
                             body_done = item.is_none();
@@ -68,7 +81,9 @@ where
                                 let _ = this.body.take();
                             }
                             let framed = this.framed.as_mut().as_pin_mut().unwrap();
-                            framed.write(Message::Chunk(item))?;
+                            framed.write(Message::Chunk(item)).map_err(|err| {
+                                Error::new_send_response().with_cause(err)
+                            })?;
                         }
                         Poll::Pending => body_ready = false,
                     }
@@ -79,7 +94,10 @@ where
 
             // flush write buffer
             if !framed.is_write_buf_empty() {
-                match framed.flush(cx)? {
+                match framed
+                    .flush(cx)
+                    .map_err(|err| Error::new_send_response().with_cause(err))?
+                {
                     Poll::Ready(_) => {
                         if body_ready {
                             continue;
@@ -93,7 +111,9 @@ where
 
             // send response
             if let Some(res) = this.res.take() {
-                framed.write(res)?;
+                framed
+                    .write(res)
+                    .map_err(|err| Error::new_send_response().with_cause(err))?;
                 continue;
             }
 
diff --git a/actix-http/src/h2/dispatcher.rs b/actix-http/src/h2/dispatcher.rs
index 87dd66fe7..ea149b1e0 100644
--- a/actix-http/src/h2/dispatcher.rs
+++ b/actix-http/src/h2/dispatcher.rs
@@ -1,53 +1,46 @@
-use std::task::{Context, Poll};
-use std::{cmp, future::Future, marker::PhantomData, net, pin::Pin, rc::Rc};
+use std::{
+    cmp,
+    error::Error as StdError,
+    future::Future,
+    marker::PhantomData,
+    net,
+    pin::Pin,
+    rc::Rc,
+    task::{Context, Poll},
+};
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_service::Service;
+use actix_utils::future::poll_fn;
 use bytes::{Bytes, BytesMut};
 use futures_core::ready;
-use h2::{
-    server::{Connection, SendResponse},
-    SendStream,
-};
+use h2::server::{Connection, SendResponse};
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
 use log::{error, trace};
+use pin_project_lite::pin_project;
 
-use crate::body::{BodySize, MessageBody, ResponseBody};
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::message::ResponseHead;
-use crate::payload::Payload;
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpFlow;
-use crate::OnConnectData;
+use crate::{
+    body::{AnyBody, BodySize, MessageBody},
+    config::ServiceConfig,
+    service::HttpFlow,
+    OnConnectData, Payload, Request, Response, ResponseHead,
+};
 
 const CHUNK_SIZE: usize = 16_384;
 
-/// Dispatcher for HTTP/2 protocol.
-#[pin_project::pin_project]
-pub struct Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    B: MessageBody,
-{
-    flow: Rc<HttpFlow<S, X, U>>,
-    connection: Connection<T, Bytes>,
-    on_connect_data: OnConnectData,
-    config: ServiceConfig,
-    peer_addr: Option<net::SocketAddr>,
-    _phantom: PhantomData<B>,
+pin_project! {
+    /// Dispatcher for HTTP/2 protocol.
+    pub struct Dispatcher<T, S, B, X, U> {
+        flow: Rc<HttpFlow<S, X, U>>,
+        connection: Connection<T, Bytes>,
+        on_connect_data: OnConnectData,
+        config: ServiceConfig,
+        peer_addr: Option<net::SocketAddr>,
+        _phantom: PhantomData<B>,
+    }
 }
 
-impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-{
+impl<T, S, B, X, U> Dispatcher<T, S, B, X, U> {
     pub(crate) fn new(
         flow: Rc<HttpFlow<S, X, U>>,
         connection: Connection<T, Bytes>,
@@ -55,7 +48,7 @@ where
         config: ServiceConfig,
         peer_addr: Option<net::SocketAddr>,
     ) -> Self {
-        Dispatcher {
+        Self {
             flow,
             config,
             peer_addr,
@@ -69,269 +62,208 @@ where
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
+
     S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>>,
     S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
+    S::Response: Into<Response<B>>,
+
+    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
 {
-    type Output = Result<(), DispatchError>;
+    type Output = Result<(), crate::error::DispatchError>;
 
     #[inline]
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
 
-        loop {
-            match ready!(Pin::new(&mut this.connection).poll_accept(cx)) {
-                None => return Poll::Ready(Ok(())),
+        while let Some((req, tx)) =
+            ready!(Pin::new(&mut this.connection).poll_accept(cx)?)
+        {
+            let (parts, body) = req.into_parts();
+            let pl = crate::h2::Payload::new(body);
+            let pl = Payload::<crate::payload::PayloadStream>::H2(pl);
+            let mut req = Request::with_payload(pl);
 
-                Some(Err(err)) => return Poll::Ready(Err(err.into())),
+            let head = req.head_mut();
+            head.uri = parts.uri;
+            head.method = parts.method;
+            head.version = parts.version;
+            head.headers = parts.headers.into();
+            head.peer_addr = this.peer_addr;
 
-                Some(Ok((req, res))) => {
-                    let (parts, body) = req.into_parts();
-                    let pl = crate::h2::Payload::new(body);
-                    let pl = Payload::<crate::payload::PayloadStream>::H2(pl);
-                    let mut req = Request::with_payload(pl);
+            // merge on_connect_ext data into request extensions
+            this.on_connect_data.merge_into(&mut req);
 
-                    let head = req.head_mut();
-                    head.uri = parts.uri;
-                    head.method = parts.method;
-                    head.version = parts.version;
-                    head.headers = parts.headers.into();
-                    head.peer_addr = this.peer_addr;
+            let fut = this.flow.service.call(req);
+            let config = this.config.clone();
 
-                    // merge on_connect_ext data into request extensions
-                    this.on_connect_data.merge_into(&mut req);
+            // multiplex request handling with spawn task
+            actix_rt::spawn(async move {
+                // resolve service call and send response.
+                let res = match fut.await {
+                    Ok(res) => handle_response(res.into(), tx, config).await,
+                    Err(err) => {
+                        let res: Response<AnyBody> = err.into();
+                        handle_response(res, tx, config).await
+                    }
+                };
 
-                    let svc = ServiceResponse {
-                        state: ServiceResponseState::ServiceCall(
-                            this.flow.service.call(req),
-                            Some(res),
-                        ),
-                        config: this.config.clone(),
-                        buffer: None,
-                        _phantom: PhantomData,
-                    };
+                // log error.
+                if let Err(err) = res {
+                    match err {
+                        DispatchError::SendResponse(err) => {
+                            trace!("Error sending HTTP/2 response: {:?}", err)
+                        }
+                        DispatchError::SendData(err) => warn!("{:?}", err),
+                        DispatchError::ResponseBody(err) => {
+                            error!("Response payload stream error: {:?}", err)
+                        }
+                    }
+                }
+            });
+        }
 
-                    actix_rt::spawn(svc);
+        Poll::Ready(Ok(()))
+    }
+}
+
+enum DispatchError {
+    SendResponse(h2::Error),
+    SendData(h2::Error),
+    ResponseBody(Box<dyn StdError>),
+}
+
+async fn handle_response<B>(
+    res: Response<B>,
+    mut tx: SendResponse<Bytes>,
+    config: ServiceConfig,
+) -> Result<(), DispatchError>
+where
+    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+{
+    let (res, body) = res.replace_body(());
+
+    // prepare response.
+    let mut size = body.size();
+    let res = prepare_response(config, res.head(), &mut size);
+    let eof = size.is_eof();
+
+    // send response head and return on eof.
+    let mut stream = tx
+        .send_response(res, eof)
+        .map_err(DispatchError::SendResponse)?;
+
+    if eof {
+        return Ok(());
+    }
+
+    // poll response body and send chunks to client.
+    actix_rt::pin!(body);
+
+    while let Some(res) = poll_fn(|cx| body.as_mut().poll_next(cx)).await {
+        let mut chunk = res.map_err(|err| DispatchError::ResponseBody(err.into()))?;
+
+        'send: loop {
+            // reserve enough space and wait for stream ready.
+            stream.reserve_capacity(cmp::min(chunk.len(), CHUNK_SIZE));
+
+            match poll_fn(|cx| stream.poll_capacity(cx)).await {
+                // No capacity left. drop body and return.
+                None => return Ok(()),
+                Some(res) => {
+                    // Split chuck to writeable size and send to client.
+                    let cap = res.map_err(DispatchError::SendData)?;
+
+                    let len = chunk.len();
+                    let bytes = chunk.split_to(cmp::min(cap, len));
+
+                    stream
+                        .send_data(bytes, false)
+                        .map_err(DispatchError::SendData)?;
+
+                    // Current chuck completely sent. break send loop and poll next one.
+                    if chunk.is_empty() {
+                        break 'send;
+                    }
                 }
             }
         }
     }
+
+    // response body streaming finished. send end of stream and return.
+    stream
+        .send_data(Bytes::new(), true)
+        .map_err(DispatchError::SendData)?;
+
+    Ok(())
 }
 
-#[pin_project::pin_project]
-struct ServiceResponse<F, I, E, B> {
-    #[pin]
-    state: ServiceResponseState<F, B>,
+fn prepare_response(
     config: ServiceConfig,
-    buffer: Option<Bytes>,
-    _phantom: PhantomData<(I, E)>,
-}
+    head: &ResponseHead,
+    size: &mut BodySize,
+) -> http::Response<()> {
+    let mut has_date = false;
+    let mut skip_len = size != &BodySize::Stream;
 
-#[pin_project::pin_project(project = ServiceResponseStateProj)]
-enum ServiceResponseState<F, B> {
-    ServiceCall(#[pin] F, Option<SendResponse<Bytes>>),
-    SendPayload(SendStream<Bytes>, #[pin] ResponseBody<B>),
-}
+    let mut res = http::Response::new(());
+    *res.status_mut() = head.status;
+    *res.version_mut() = http::Version::HTTP_2;
 
-impl<F, I, E, B> ServiceResponse<F, I, E, B>
-where
-    F: Future<Output = Result<I, E>>,
-    E: Into<Error>,
-    I: Into<Response<B>>,
-    B: MessageBody,
-{
-    fn prepare_response(
-        &self,
-        head: &ResponseHead,
-        size: &mut BodySize,
-    ) -> http::Response<()> {
-        let mut has_date = false;
-        let mut skip_len = size != &BodySize::Stream;
+    // Content length
+    match head.status {
+        http::StatusCode::NO_CONTENT
+        | http::StatusCode::CONTINUE
+        | http::StatusCode::PROCESSING => *size = BodySize::None,
+        http::StatusCode::SWITCHING_PROTOCOLS => {
+            skip_len = true;
+            *size = BodySize::Stream;
+        }
+        _ => {}
+    }
 
-        let mut res = http::Response::new(());
-        *res.status_mut() = head.status;
-        *res.version_mut() = http::Version::HTTP_2;
+    let _ = match size {
+        BodySize::None | BodySize::Stream => None,
+        BodySize::Empty => res
+            .headers_mut()
+            .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
+        BodySize::Sized(len) => {
+            let mut buf = itoa::Buffer::new();
 
-        // Content length
-        match head.status {
-            http::StatusCode::NO_CONTENT
-            | http::StatusCode::CONTINUE
-            | http::StatusCode::PROCESSING => *size = BodySize::None,
-            http::StatusCode::SWITCHING_PROTOCOLS => {
-                skip_len = true;
-                *size = BodySize::Stream;
-            }
+            res.headers_mut().insert(
+                CONTENT_LENGTH,
+                HeaderValue::from_str(buf.format(*len)).unwrap(),
+            )
+        }
+    };
+
+    // copy headers
+    for (key, value) in head.headers.iter() {
+        match *key {
+            // TODO: consider skipping other headers according to:
+            //       https://tools.ietf.org/html/rfc7540#section-8.1.2.2
+            // omit HTTP/1.x only headers
+            CONNECTION | TRANSFER_ENCODING => continue,
+            CONTENT_LENGTH if skip_len => continue,
+            DATE => has_date = true,
             _ => {}
         }
 
-        let _ = match size {
-            BodySize::None | BodySize::Stream => None,
-            BodySize::Empty => res
-                .headers_mut()
-                .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
-            BodySize::Sized(len) => {
-                let mut buf = itoa::Buffer::new();
-
-                res.headers_mut().insert(
-                    CONTENT_LENGTH,
-                    HeaderValue::from_str(buf.format(*len)).unwrap(),
-                )
-            }
-        };
-
-        // copy headers
-        for (key, value) in head.headers.iter() {
-            match *key {
-                // TODO: consider skipping other headers according to:
-                //       https://tools.ietf.org/html/rfc7540#section-8.1.2.2
-                // omit HTTP/1.x only headers
-                CONNECTION | TRANSFER_ENCODING => continue,
-                CONTENT_LENGTH if skip_len => continue,
-                DATE => has_date = true,
-                _ => {}
-            }
-
-            res.headers_mut().append(key, value.clone());
-        }
-
-        // set date header
-        if !has_date {
-            let mut bytes = BytesMut::with_capacity(29);
-            self.config.set_date_header(&mut bytes);
-            res.headers_mut().insert(
-                DATE,
-                // SAFETY: serialized date-times are known ASCII strings
-                unsafe { HeaderValue::from_maybe_shared_unchecked(bytes.freeze()) },
-            );
-        }
-
-        res
+        res.headers_mut().append(key, value.clone());
     }
-}
 
-impl<F, I, E, B> Future for ServiceResponse<F, I, E, B>
-where
-    F: Future<Output = Result<I, E>>,
-    E: Into<Error>,
-    I: Into<Response<B>>,
-    B: MessageBody,
-{
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        match this.state.project() {
-            ServiceResponseStateProj::ServiceCall(call, send) => {
-                match ready!(call.poll(cx)) {
-                    Ok(res) => {
-                        let (res, body) = res.into().replace_body(());
-
-                        let mut send = send.take().unwrap();
-                        let mut size = body.size();
-                        let h2_res =
-                            self.as_mut().prepare_response(res.head(), &mut size);
-                        this = self.as_mut().project();
-
-                        let stream = match send.send_response(h2_res, size.is_eof()) {
-                            Err(e) => {
-                                trace!("Error sending HTTP/2 response: {:?}", e);
-                                return Poll::Ready(());
-                            }
-                            Ok(stream) => stream,
-                        };
-
-                        if size.is_eof() {
-                            Poll::Ready(())
-                        } else {
-                            this.state
-                                .set(ServiceResponseState::SendPayload(stream, body));
-                            self.poll(cx)
-                        }
-                    }
-
-                    Err(err) => {
-                        let res = Response::from_error(err.into());
-                        let (res, body) = res.replace_body(());
-
-                        let mut send = send.take().unwrap();
-                        let mut size = body.size();
-                        let h2_res =
-                            self.as_mut().prepare_response(res.head(), &mut size);
-                        this = self.as_mut().project();
-
-                        let stream = match send.send_response(h2_res, size.is_eof()) {
-                            Err(e) => {
-                                trace!("Error sending HTTP/2 response: {:?}", e);
-                                return Poll::Ready(());
-                            }
-                            Ok(stream) => stream,
-                        };
-
-                        if size.is_eof() {
-                            Poll::Ready(())
-                        } else {
-                            this.state.set(ServiceResponseState::SendPayload(
-                                stream,
-                                body.into_body(),
-                            ));
-                            self.poll(cx)
-                        }
-                    }
-                }
-            }
-
-            ServiceResponseStateProj::SendPayload(ref mut stream, ref mut body) => {
-                loop {
-                    match this.buffer {
-                        Some(ref mut buffer) => match ready!(stream.poll_capacity(cx)) {
-                            None => return Poll::Ready(()),
-
-                            Some(Ok(cap)) => {
-                                let len = buffer.len();
-                                let bytes = buffer.split_to(cmp::min(cap, len));
-
-                                if let Err(e) = stream.send_data(bytes, false) {
-                                    warn!("{:?}", e);
-                                    return Poll::Ready(());
-                                } else if !buffer.is_empty() {
-                                    let cap = cmp::min(buffer.len(), CHUNK_SIZE);
-                                    stream.reserve_capacity(cap);
-                                } else {
-                                    this.buffer.take();
-                                }
-                            }
-
-                            Some(Err(e)) => {
-                                warn!("{:?}", e);
-                                return Poll::Ready(());
-                            }
-                        },
-
-                        None => match ready!(body.as_mut().poll_next(cx)) {
-                            None => {
-                                if let Err(e) = stream.send_data(Bytes::new(), true) {
-                                    warn!("{:?}", e);
-                                }
-                                return Poll::Ready(());
-                            }
-
-                            Some(Ok(chunk)) => {
-                                stream
-                                    .reserve_capacity(cmp::min(chunk.len(), CHUNK_SIZE));
-                                *this.buffer = Some(chunk);
-                            }
-
-                            Some(Err(e)) => {
-                                error!("Response payload stream error: {:?}", e);
-                                return Poll::Ready(());
-                            }
-                        },
-                    }
-                }
-            }
-        }
+    // set date header
+    if !has_date {
+        let mut bytes = BytesMut::with_capacity(29);
+        config.set_date_header(&mut bytes);
+        res.headers_mut().insert(
+            DATE,
+            // SAFETY: serialized date-times are known ASCII strings
+            unsafe { HeaderValue::from_maybe_shared_unchecked(bytes.freeze()) },
+        );
     }
+
+    res
 }
diff --git a/actix-http/src/h2/service.rs b/actix-http/src/h2/service.rs
index 1a0b8c7f5..09e24045b 100644
--- a/actix-http/src/h2/service.rs
+++ b/actix-http/src/h2/service.rs
@@ -1,8 +1,12 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{net, rc::Rc};
+use std::{
+    error::Error as StdError,
+    future::Future,
+    marker::PhantomData,
+    net,
+    pin::Pin,
+    rc::Rc,
+    task::{Context, Poll},
+};
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::net::TcpStream;
@@ -13,16 +17,16 @@ use actix_service::{
 use actix_utils::future::ready;
 use bytes::Bytes;
 use futures_core::{future::LocalBoxFuture, ready};
-use h2::server::{handshake, Handshake};
+use h2::server::{handshake as h2_handshake, Handshake as H2Handshake};
 use log::error;
 
-use crate::body::MessageBody;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpFlow;
-use crate::{ConnectCallback, OnConnectData};
+use crate::{
+    body::{AnyBody, MessageBody},
+    config::ServiceConfig,
+    error::DispatchError,
+    service::HttpFlow,
+    ConnectCallback, OnConnectData, Request, Response,
+};
 
 use super::dispatcher::Dispatcher;
 
@@ -37,10 +41,12 @@ pub struct H2Service<T, S, B> {
 impl<T, S, B> H2Service<T, S, B>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
+
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
     /// Create new `H2Service` instance with config.
     pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
@@ -66,10 +72,12 @@ impl<S, B> H2Service<TcpStream, S, B>
 where
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
+
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
     /// Create plain TCP based service
     pub fn tcp(
@@ -103,10 +111,12 @@ mod openssl {
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Future: 'static,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
         S::Response: Into<Response<B>> + 'static,
         <S::Service as Service<Request>>::Future: 'static,
+
         B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,
     {
         /// Create OpenSSL based service
         pub fn openssl(
@@ -147,10 +157,12 @@ mod rustls {
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Future: 'static,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
         S::Response: Into<Response<B>> + 'static,
         <S::Service as Service<Request>>::Future: 'static,
+
         B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,
     {
         /// Create Rustls based service
         pub fn rustls(
@@ -163,7 +175,8 @@ mod rustls {
             Error = TlsError<io::Error, DispatchError>,
             InitError = S::InitError,
         > {
-            let protos = vec!["h2".to_string().into()];
+            let mut protos = vec![b"h2".to_vec()];
+            protos.extend_from_slice(&config.alpn_protocols);
             config.set_protocols(&protos);
 
             Acceptor::new(config)
@@ -185,12 +198,15 @@ mod rustls {
 impl<T, S, B> ServiceFactory<(T, Option<net::SocketAddr>)> for H2Service<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin + 'static,
+
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
+
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
     type Response = ();
     type Error = DispatchError;
@@ -225,7 +241,7 @@ where
 impl<T, S, B> H2ServiceHandler<T, S, B>
 where
     S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
@@ -248,10 +264,11 @@ impl<T, S, B> Service<(T, Option<net::SocketAddr>)> for H2ServiceHandler<T, S, B
 where
     T: AsyncRead + AsyncWrite + Unpin,
     S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
     type Response = ();
     type Error = DispatchError;
@@ -275,7 +292,7 @@ where
                 Some(self.cfg.clone()),
                 addr,
                 on_connect_data,
-                handshake(io),
+                h2_handshake(io),
             ),
         }
     }
@@ -292,7 +309,7 @@ where
         Option<ServiceConfig>,
         Option<net::SocketAddr>,
         OnConnectData,
-        Handshake<T, Bytes>,
+        H2Handshake<T, Bytes>,
     ),
 }
 
@@ -300,7 +317,7 @@ pub struct H2ServiceHandlerResponse<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
     S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
@@ -312,10 +329,11 @@ impl<T, S, B> Future for H2ServiceHandlerResponse<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
     S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
 {
     type Output = Result<(), DispatchError>;
 
diff --git a/actix-http/src/header/as_name.rs b/actix-http/src/header/as_name.rs
index af81ff7f2..5ce321566 100644
--- a/actix-http/src/header/as_name.rs
+++ b/actix-http/src/header/as_name.rs
@@ -8,40 +8,42 @@ use http::header::{HeaderName, InvalidHeaderName};
 
 pub trait AsHeaderName: Sealed {}
 
+pub struct Seal;
+
 pub trait Sealed {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName>;
+    fn try_as_name(&self, seal: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName>;
 }
 
 impl Sealed for HeaderName {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
+    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         Ok(Cow::Borrowed(self))
     }
 }
 impl AsHeaderName for HeaderName {}
 
 impl Sealed for &HeaderName {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
+    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         Ok(Cow::Borrowed(*self))
     }
 }
 impl AsHeaderName for &HeaderName {}
 
 impl Sealed for &str {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
+    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         HeaderName::from_str(self).map(Cow::Owned)
     }
 }
 impl AsHeaderName for &str {}
 
 impl Sealed for String {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
+    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         HeaderName::from_str(self).map(Cow::Owned)
     }
 }
 impl AsHeaderName for String {}
 
 impl Sealed for &String {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
+    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
         HeaderName::from_str(self).map(Cow::Owned)
     }
 }
diff --git a/actix-http/src/header/map.rs b/actix-http/src/header/map.rs
index 106e44edb..be33ec02a 100644
--- a/actix-http/src/header/map.rs
+++ b/actix-http/src/header/map.rs
@@ -213,7 +213,7 @@ impl HeaderMap {
     }
 
     fn get_value(&self, key: impl AsHeaderName) -> Option<&Value> {
-        match key.try_as_name().ok()? {
+        match key.try_as_name(super::as_name::Seal).ok()? {
             Cow::Borrowed(name) => self.inner.get(name),
             Cow::Owned(name) => self.inner.get(&name),
         }
@@ -279,7 +279,7 @@ impl HeaderMap {
     /// assert!(map.get("INVALID HEADER NAME").is_none());
     /// ```
     pub fn get_mut(&mut self, key: impl AsHeaderName) -> Option<&mut HeaderValue> {
-        match key.try_as_name().ok()? {
+        match key.try_as_name(super::as_name::Seal).ok()? {
             Cow::Borrowed(name) => self.inner.get_mut(name).map(|v| v.first_mut()),
             Cow::Owned(name) => self.inner.get_mut(&name).map(|v| v.first_mut()),
         }
@@ -327,7 +327,7 @@ impl HeaderMap {
     /// assert!(map.contains_key(header::ACCEPT));
     /// ```
     pub fn contains_key(&self, key: impl AsHeaderName) -> bool {
-        match key.try_as_name() {
+        match key.try_as_name(super::as_name::Seal) {
             Ok(Cow::Borrowed(name)) => self.inner.contains_key(name),
             Ok(Cow::Owned(name)) => self.inner.contains_key(&name),
             Err(_) => false,
@@ -410,7 +410,7 @@ impl HeaderMap {
     ///
     /// assert!(map.is_empty());
     pub fn remove(&mut self, key: impl AsHeaderName) -> Removed {
-        let value = match key.try_as_name() {
+        let value = match key.try_as_name(super::as_name::Seal) {
             Ok(Cow::Borrowed(name)) => self.inner.remove(name),
             Ok(Cow::Owned(name)) => self.inner.remove(&name),
             Err(_) => None,
diff --git a/actix-http/src/header/shared/charset.rs b/actix-http/src/header/shared/charset.rs
index 36bdbf7e2..b482f6bce 100644
--- a/actix-http/src/header/shared/charset.rs
+++ b/actix-http/src/header/shared/charset.rs
@@ -104,7 +104,7 @@ impl Display for Charset {
 impl FromStr for Charset {
     type Err = crate::Error;
 
-    fn from_str(s: &str) -> crate::Result<Charset> {
+    fn from_str(s: &str) -> Result<Charset, crate::Error> {
         Ok(match s.to_ascii_uppercase().as_ref() {
             "US-ASCII" => Us_Ascii,
             "ISO-8859-1" => Iso_8859_1,
diff --git a/actix-http/src/header/shared/content_encoding.rs b/actix-http/src/header/shared/content_encoding.rs
index b93d66101..b9c1d2795 100644
--- a/actix-http/src/header/shared/content_encoding.rs
+++ b/actix-http/src/header/shared/content_encoding.rs
@@ -23,6 +23,9 @@ pub enum ContentEncoding {
     /// Gzip algorithm.
     Gzip,
 
+    // Zstd algorithm.
+    Zstd,
+
     /// Indicates the identity function (i.e. no compression, nor modification).
     Identity,
 }
@@ -41,6 +44,7 @@ impl ContentEncoding {
             ContentEncoding::Br => "br",
             ContentEncoding::Gzip => "gzip",
             ContentEncoding::Deflate => "deflate",
+            ContentEncoding::Zstd => "zstd",
             ContentEncoding::Identity | ContentEncoding::Auto => "identity",
         }
     }
@@ -53,6 +57,7 @@ impl ContentEncoding {
             ContentEncoding::Gzip => 1.0,
             ContentEncoding::Deflate => 0.9,
             ContentEncoding::Identity | ContentEncoding::Auto => 0.1,
+            ContentEncoding::Zstd => 0.0,
         }
     }
 }
@@ -81,6 +86,8 @@ impl From<&str> for ContentEncoding {
             ContentEncoding::Gzip
         } else if val.eq_ignore_ascii_case("deflate") {
             ContentEncoding::Deflate
+        } else if val.eq_ignore_ascii_case("zstd") {
+            ContentEncoding::Zstd
         } else {
             ContentEncoding::default()
         }
diff --git a/actix-http/src/helpers.rs b/actix-http/src/helpers.rs
index b00ca307e..cba94d9b8 100644
--- a/actix-http/src/helpers.rs
+++ b/actix-http/src/helpers.rs
@@ -27,7 +27,9 @@ pub(crate) fn write_status_line<B: BufMut>(version: Version, n: u16, buf: &mut B
     buf.put_u8(b' ');
 }
 
-/// NOTE: bytes object has to contain enough space
+/// Write out content length header.
+///
+/// Buffer must to contain enough space or be implicitly extendable.
 pub fn write_content_length<B: BufMut>(n: u64, buf: &mut B) {
     if n == 0 {
         buf.put_slice(b"\r\ncontent-length: 0\r\n");
@@ -41,10 +43,15 @@ pub fn write_content_length<B: BufMut>(n: u64, buf: &mut B) {
     buf.put_slice(b"\r\n");
 }
 
-// TODO: bench why this is needed
-pub(crate) struct Writer<'a, B>(pub &'a mut B);
+/// An `io::Write`r that only requires mutable reference and assumes that there is space available
+/// in the buffer for every write operation or that it can be extended implicitly (like
+/// `bytes::BytesMut`, for example).
+///
+/// This is slightly faster (~10%) than `bytes::buf::Writer` in such cases because it does not
+/// perform a remaining length check before writing.
+pub(crate) struct MutWriter<'a, B>(pub(crate) &'a mut B);
 
-impl<'a, B> io::Write for Writer<'a, B>
+impl<'a, B> io::Write for MutWriter<'a, B>
 where
     B: BufMut,
 {
diff --git a/actix-http/src/lib.rs b/actix-http/src/lib.rs
index 82d0415c2..924d5441f 100644
--- a/actix-http/src/lib.rs
+++ b/actix-http/src/lib.rs
@@ -1,12 +1,14 @@
 //! HTTP primitives for the Actix ecosystem.
 //!
 //! ## Crate Features
-//! | Feature          | Functionality                                         |
-//! | ---------------- | ----------------------------------------------------- |
-//! | `openssl`        | TLS support via [OpenSSL].                            |
-//! | `rustls`         | TLS support via [rustls].                             |
-//! | `compress`       | Payload compression support. (Deflate, Gzip & Brotli) |
-//! | `trust-dns`      | Use [trust-dns] as the client DNS resolver.           |
+//! | Feature             | Functionality                               |
+//! | ------------------- | ------------------------------------------- |
+//! | `openssl`           | TLS support via [OpenSSL].                  |
+//! | `rustls`            | TLS support via [rustls].                   |
+//! | `compress-brotli`   | Payload compression support: Brotli.        |
+//! | `compress-gzip`     | Payload compression support: Deflate, Gzip. |
+//! | `compress-zstd`     | Payload compression support: Zstd.          |
+//! | `trust-dns`         | Use [trust-dns] as the client DNS resolver. |
 //!
 //! [OpenSSL]: https://crates.io/crates/openssl
 //! [rustls]: https://crates.io/crates/rustls
@@ -32,7 +34,8 @@ pub mod body;
 mod builder;
 pub mod client;
 mod config;
-#[cfg(feature = "compress")]
+
+#[cfg(feature = "__compress")]
 pub mod encoding;
 mod extensions;
 pub mod header;
@@ -54,7 +57,7 @@ pub mod ws;
 
 pub use self::builder::HttpServiceBuilder;
 pub use self::config::{KeepAlive, ServiceConfig};
-pub use self::error::{Error, ResponseError, Result};
+pub use self::error::Error;
 pub use self::extensions::Extensions;
 pub use self::header::ContentEncoding;
 pub use self::http_message::HttpMessage;
diff --git a/actix-http/src/macros.rs b/actix-http/src/macros.rs
index 7cf0e288b..be8e63d6e 100644
--- a/actix-http/src/macros.rs
+++ b/actix-http/src/macros.rs
@@ -15,8 +15,15 @@ macro_rules! downcast_get_type_id {
         /// making it impossible for safe code to construct outside of
         /// this module. This ensures that safe code cannot violate
         /// type-safety by implementing this method.
+        ///
+        /// We also take `PrivateHelper` as a parameter, to ensure that
+        /// safe code cannot obtain a `PrivateHelper` instance by
+        /// delegating to an existing implementation of `__private_get_type_id__`
         #[doc(hidden)]
-        fn __private_get_type_id__(&self) -> (std::any::TypeId, PrivateHelper)
+        fn __private_get_type_id__(
+            &self,
+            _: PrivateHelper,
+        ) -> (std::any::TypeId, PrivateHelper)
         where
             Self: 'static,
         {
@@ -39,7 +46,9 @@ macro_rules! downcast {
         impl dyn $name + 'static {
             /// Downcasts generic body to a specific type.
             pub fn downcast_ref<T: $name + 'static>(&self) -> Option<&T> {
-                if self.__private_get_type_id__().0 == std::any::TypeId::of::<T>() {
+                if self.__private_get_type_id__(PrivateHelper(())).0
+                    == std::any::TypeId::of::<T>()
+                {
                     // SAFETY: external crates cannot override the default
                     // implementation of `__private_get_type_id__`, since
                     // it requires returning a private type. We can therefore
@@ -53,7 +62,9 @@ macro_rules! downcast {
 
             /// Downcasts a generic body to a mutable specific type.
             pub fn downcast_mut<T: $name + 'static>(&mut self) -> Option<&mut T> {
-                if self.__private_get_type_id__().0 == std::any::TypeId::of::<T>() {
+                if self.__private_get_type_id__(PrivateHelper(())).0
+                    == std::any::TypeId::of::<T>()
+                {
                     // SAFETY: external crates cannot override the default
                     // implementation of `__private_get_type_id__`, since
                     // it requires returning a private type. We can therefore
diff --git a/actix-http/src/message.rs b/actix-http/src/message.rs
index 8cb99d43a..0a3f3a915 100644
--- a/actix-http/src/message.rs
+++ b/actix-http/src/message.rs
@@ -293,14 +293,14 @@ impl ResponseHead {
         }
     }
 
-    #[inline]
     /// Check if keep-alive is enabled
+    #[inline]
     pub fn keep_alive(&self) -> bool {
         self.connection_type() == ConnectionType::KeepAlive
     }
 
-    #[inline]
     /// Check upgrade status of this message
+    #[inline]
     pub fn upgrade(&self) -> bool {
         self.connection_type() == ConnectionType::Upgrade
     }
@@ -389,12 +389,6 @@ impl BoxedResponseHead {
     pub fn new(status: StatusCode) -> Self {
         RESPONSE_POOL.with(|p| p.get_message(status))
     }
-
-    pub(crate) fn take(&mut self) -> Self {
-        BoxedResponseHead {
-            head: self.head.take(),
-        }
-    }
 }
 
 impl std::ops::Deref for BoxedResponseHead {
diff --git a/actix-http/src/response.rs b/actix-http/src/response.rs
index a3ab1175c..2aa38c153 100644
--- a/actix-http/src/response.rs
+++ b/actix-http/src/response.rs
@@ -2,17 +2,13 @@
 
 use std::{
     cell::{Ref, RefMut},
-    fmt,
-    future::Future,
-    pin::Pin,
-    str,
-    task::{Context, Poll},
+    fmt, str,
 };
 
 use bytes::{Bytes, BytesMut};
 
 use crate::{
-    body::{Body, MessageBody, ResponseBody},
+    body::{AnyBody, MessageBody},
     error::Error,
     extensions::Extensions,
     http::{HeaderMap, StatusCode},
@@ -23,22 +19,20 @@ use crate::{
 /// An HTTP response.
 pub struct Response<B> {
     pub(crate) head: BoxedResponseHead,
-    pub(crate) body: ResponseBody<B>,
-    pub(crate) error: Option<Error>,
+    pub(crate) body: B,
 }
 
-impl Response<Body> {
-    /// Constructs a response
+impl Response<AnyBody> {
+    /// Constructs a new response with default body.
     #[inline]
-    pub fn new(status: StatusCode) -> Response<Body> {
+    pub fn new(status: StatusCode) -> Self {
         Response {
             head: BoxedResponseHead::new(status),
-            body: ResponseBody::Body(Body::Empty),
-            error: None,
+            body: AnyBody::Empty,
         }
     }
 
-    /// Create HTTP response builder with specific status.
+    /// Constructs a new response builder.
     #[inline]
     pub fn build(status: StatusCode) -> ResponseBuilder {
         ResponseBuilder::new(status)
@@ -47,202 +41,164 @@ impl Response<Body> {
     // just a couple frequently used shortcuts
     // this list should not grow larger than a few
 
-    /// Creates a new response with status 200 OK.
+    /// Constructs a new response with status 200 OK.
     #[inline]
-    pub fn ok() -> Response<Body> {
+    pub fn ok() -> Self {
         Response::new(StatusCode::OK)
     }
 
-    /// Creates a new response with status 400 Bad Request.
+    /// Constructs a new response with status 400 Bad Request.
     #[inline]
-    pub fn bad_request() -> Response<Body> {
+    pub fn bad_request() -> Self {
         Response::new(StatusCode::BAD_REQUEST)
     }
 
-    /// Creates a new response with status 404 Not Found.
+    /// Constructs a new response with status 404 Not Found.
     #[inline]
-    pub fn not_found() -> Response<Body> {
+    pub fn not_found() -> Self {
         Response::new(StatusCode::NOT_FOUND)
     }
 
-    /// Creates a new response with status 500 Internal Server Error.
+    /// Constructs a new response with status 500 Internal Server Error.
     #[inline]
-    pub fn internal_server_error() -> Response<Body> {
+    pub fn internal_server_error() -> Self {
         Response::new(StatusCode::INTERNAL_SERVER_ERROR)
     }
 
     // end shortcuts
-
-    /// Constructs an error response
-    #[inline]
-    pub fn from_error(error: Error) -> Response<Body> {
-        let mut resp = error.as_response_error().error_response();
-        if resp.head.status == StatusCode::INTERNAL_SERVER_ERROR {
-            error!("Internal Server Error: {:?}", error);
-        }
-        resp.error = Some(error);
-        resp
-    }
-
-    /// Convert response to response with body
-    pub fn into_body<B>(self) -> Response<B> {
-        let b = match self.body {
-            ResponseBody::Body(b) => b,
-            ResponseBody::Other(b) => b,
-        };
-        Response {
-            head: self.head,
-            error: self.error,
-            body: ResponseBody::Other(b),
-        }
-    }
 }
 
 impl<B> Response<B> {
-    /// Constructs a response with body
+    /// Constructs a new response with given body.
     #[inline]
     pub fn with_body(status: StatusCode, body: B) -> Response<B> {
         Response {
             head: BoxedResponseHead::new(status),
-            body: ResponseBody::Body(body),
-            error: None,
+            body,
         }
     }
 
+    /// Returns a reference to the head of this response.
     #[inline]
-    /// Http message part of the response
     pub fn head(&self) -> &ResponseHead {
         &*self.head
     }
 
+    /// Returns a mutable reference to the head of this response.
     #[inline]
-    /// Mutable reference to a HTTP message part of the response
     pub fn head_mut(&mut self) -> &mut ResponseHead {
         &mut *self.head
     }
 
-    /// The source `error` for this response
-    #[inline]
-    pub fn error(&self) -> Option<&Error> {
-        self.error.as_ref()
-    }
-
-    /// Get the response status code
+    /// Returns the status code of this response.
     #[inline]
     pub fn status(&self) -> StatusCode {
         self.head.status
     }
 
-    /// Set the `StatusCode` for this response
+    /// Returns a mutable reference the status code of this response.
     #[inline]
     pub fn status_mut(&mut self) -> &mut StatusCode {
         &mut self.head.status
     }
 
-    /// Get the headers from the response
+    /// Returns a reference to response headers.
     #[inline]
     pub fn headers(&self) -> &HeaderMap {
         &self.head.headers
     }
 
-    /// Get a mutable reference to the headers
+    /// Returns a mutable reference to response headers.
     #[inline]
     pub fn headers_mut(&mut self) -> &mut HeaderMap {
         &mut self.head.headers
     }
 
-    /// Connection upgrade status
+    /// Returns true if connection upgrade is enabled.
     #[inline]
     pub fn upgrade(&self) -> bool {
         self.head.upgrade()
     }
 
-    /// Keep-alive status for this connection
+    /// Returns true if keep-alive is enabled.
     pub fn keep_alive(&self) -> bool {
         self.head.keep_alive()
     }
 
-    /// Responses extensions
+    /// Returns a reference to the extensions of this response.
     #[inline]
     pub fn extensions(&self) -> Ref<'_, Extensions> {
         self.head.extensions.borrow()
     }
 
-    /// Mutable reference to a the response's extensions
+    /// Returns a mutable reference to the extensions of this response.
     #[inline]
     pub fn extensions_mut(&mut self) -> RefMut<'_, Extensions> {
         self.head.extensions.borrow_mut()
     }
 
-    /// Get body of this response
+    /// Returns a reference to the body of this response.
     #[inline]
-    pub fn body(&self) -> &ResponseBody<B> {
+    pub fn body(&self) -> &B {
         &self.body
     }
 
-    /// Set a body
+    /// Sets new body.
     pub fn set_body<B2>(self, body: B2) -> Response<B2> {
         Response {
             head: self.head,
-            body: ResponseBody::Body(body),
-            error: None,
+            body,
         }
     }
 
-    /// Split response and body
-    pub fn into_parts(self) -> (Response<()>, ResponseBody<B>) {
-        (
-            Response {
-                head: self.head,
-                body: ResponseBody::Body(()),
-                error: self.error,
-            },
-            self.body,
-        )
-    }
-
-    /// Drop request's body
+    /// Drops body and returns new response.
     pub fn drop_body(self) -> Response<()> {
-        Response {
-            head: self.head,
-            body: ResponseBody::Body(()),
-            error: None,
-        }
+        self.set_body(())
     }
 
-    /// Set a body and return previous body value
-    pub(crate) fn replace_body<B2>(self, body: B2) -> (Response<B2>, ResponseBody<B>) {
+    /// Sets new body, returning new response and previous body value.
+    pub(crate) fn replace_body<B2>(self, body: B2) -> (Response<B2>, B) {
         (
             Response {
                 head: self.head,
-                body: ResponseBody::Body(body),
-                error: self.error,
+                body,
             },
             self.body,
         )
     }
 
-    /// Set a body and return previous body value
+    /// Returns split head and body.
+    ///
+    /// # Implementation Notes
+    /// Due to internal performance optimisations, the first element of the returned tuple is a
+    /// `Response` as well but only contains the head of the response this was called on.
+    pub fn into_parts(self) -> (Response<()>, B) {
+        self.replace_body(())
+    }
+
+    /// Returns new response with mapped body.
     pub fn map_body<F, B2>(mut self, f: F) -> Response<B2>
     where
-        F: FnOnce(&mut ResponseHead, ResponseBody<B>) -> ResponseBody<B2>,
+        F: FnOnce(&mut ResponseHead, B) -> B2,
     {
         let body = f(&mut self.head, self.body);
 
         Response {
-            body,
             head: self.head,
-            error: self.error,
+            body,
         }
     }
 
-    /// Extract response body
-    pub fn take_body(&mut self) -> ResponseBody<B> {
-        self.body.take_body()
+    /// Returns body, consuming this response.
+    pub fn into_body(self) -> B {
+        self.body
     }
 }
 
-impl<B: MessageBody> fmt::Debug for Response<B> {
+impl<B> fmt::Debug for Response<B>
+where
+    B: MessageBody,
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let res = writeln!(
             f,
@@ -260,20 +216,16 @@ impl<B: MessageBody> fmt::Debug for Response<B> {
     }
 }
 
-impl<B: Unpin> Future for Response<B> {
-    type Output = Result<Response<B>, Error>;
-
-    fn poll(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
-        Poll::Ready(Ok(Response {
-            head: self.head.take(),
-            body: self.body.take_body(),
-            error: self.error.take(),
-        }))
+impl<B: Default> Default for Response<B> {
+    #[inline]
+    fn default() -> Response<B> {
+        Response::with_body(StatusCode::default(), B::default())
     }
 }
 
-/// Helper converters
-impl<I: Into<Response<Body>>, E: Into<Error>> From<Result<I, E>> for Response<Body> {
+impl<I: Into<Response<AnyBody>>, E: Into<Error>> From<Result<I, E>>
+    for Response<AnyBody>
+{
     fn from(res: Result<I, E>) -> Self {
         match res {
             Ok(val) => val.into(),
@@ -282,13 +234,19 @@ impl<I: Into<Response<Body>>, E: Into<Error>> From<Result<I, E>> for Response<Bo
     }
 }
 
-impl From<ResponseBuilder> for Response<Body> {
+impl From<ResponseBuilder> for Response<AnyBody> {
     fn from(mut builder: ResponseBuilder) -> Self {
         builder.finish()
     }
 }
 
-impl From<&'static str> for Response<Body> {
+impl From<std::convert::Infallible> for Response<AnyBody> {
+    fn from(val: std::convert::Infallible) -> Self {
+        match val {}
+    }
+}
+
+impl From<&'static str> for Response<AnyBody> {
     fn from(val: &'static str) -> Self {
         Response::build(StatusCode::OK)
             .content_type(mime::TEXT_PLAIN_UTF_8)
@@ -296,7 +254,7 @@ impl From<&'static str> for Response<Body> {
     }
 }
 
-impl From<&'static [u8]> for Response<Body> {
+impl From<&'static [u8]> for Response<AnyBody> {
     fn from(val: &'static [u8]) -> Self {
         Response::build(StatusCode::OK)
             .content_type(mime::APPLICATION_OCTET_STREAM)
@@ -304,7 +262,7 @@ impl From<&'static [u8]> for Response<Body> {
     }
 }
 
-impl From<String> for Response<Body> {
+impl From<String> for Response<AnyBody> {
     fn from(val: String) -> Self {
         Response::build(StatusCode::OK)
             .content_type(mime::TEXT_PLAIN_UTF_8)
@@ -312,7 +270,7 @@ impl From<String> for Response<Body> {
     }
 }
 
-impl<'a> From<&'a String> for Response<Body> {
+impl<'a> From<&'a String> for Response<AnyBody> {
     fn from(val: &'a String) -> Self {
         Response::build(StatusCode::OK)
             .content_type(mime::TEXT_PLAIN_UTF_8)
@@ -320,7 +278,7 @@ impl<'a> From<&'a String> for Response<Body> {
     }
 }
 
-impl From<Bytes> for Response<Body> {
+impl From<Bytes> for Response<AnyBody> {
     fn from(val: Bytes) -> Self {
         Response::build(StatusCode::OK)
             .content_type(mime::APPLICATION_OCTET_STREAM)
@@ -328,7 +286,7 @@ impl From<Bytes> for Response<Body> {
     }
 }
 
-impl From<BytesMut> for Response<Body> {
+impl From<BytesMut> for Response<AnyBody> {
     fn from(val: BytesMut) -> Self {
         Response::build(StatusCode::OK)
             .content_type(mime::APPLICATION_OCTET_STREAM)
@@ -339,7 +297,6 @@ impl From<BytesMut> for Response<Body> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::body::Body;
     use crate::http::header::{HeaderValue, CONTENT_TYPE, COOKIE};
 
     #[test]
@@ -354,7 +311,7 @@ mod tests {
 
     #[test]
     fn test_into_response() {
-        let resp: Response<Body> = "test".into();
+        let resp: Response<AnyBody> = "test".into();
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(
             resp.headers().get(CONTENT_TYPE).unwrap(),
@@ -363,7 +320,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().get_ref(), b"test");
 
-        let resp: Response<Body> = b"test".as_ref().into();
+        let resp: Response<AnyBody> = b"test".as_ref().into();
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(
             resp.headers().get(CONTENT_TYPE).unwrap(),
@@ -372,7 +329,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().get_ref(), b"test");
 
-        let resp: Response<Body> = "test".to_owned().into();
+        let resp: Response<AnyBody> = "test".to_owned().into();
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(
             resp.headers().get(CONTENT_TYPE).unwrap(),
@@ -381,7 +338,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().get_ref(), b"test");
 
-        let resp: Response<Body> = (&"test".to_owned()).into();
+        let resp: Response<AnyBody> = (&"test".to_owned()).into();
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(
             resp.headers().get(CONTENT_TYPE).unwrap(),
@@ -391,7 +348,7 @@ mod tests {
         assert_eq!(resp.body().get_ref(), b"test");
 
         let b = Bytes::from_static(b"test");
-        let resp: Response<Body> = b.into();
+        let resp: Response<AnyBody> = b.into();
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(
             resp.headers().get(CONTENT_TYPE).unwrap(),
@@ -401,7 +358,7 @@ mod tests {
         assert_eq!(resp.body().get_ref(), b"test");
 
         let b = Bytes::from_static(b"test");
-        let resp: Response<Body> = b.into();
+        let resp: Response<AnyBody> = b.into();
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(
             resp.headers().get(CONTENT_TYPE).unwrap(),
@@ -411,7 +368,7 @@ mod tests {
         assert_eq!(resp.body().get_ref(), b"test");
 
         let b = BytesMut::from("test");
-        let resp: Response<Body> = b.into();
+        let resp: Response<AnyBody> = b.into();
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(
             resp.headers().get(CONTENT_TYPE).unwrap(),
diff --git a/actix-http/src/response_builder.rs b/actix-http/src/response_builder.rs
index 0105f70cf..e46d9a28c 100644
--- a/actix-http/src/response_builder.rs
+++ b/actix-http/src/response_builder.rs
@@ -2,6 +2,7 @@
 
 use std::{
     cell::{Ref, RefMut},
+    error::Error as StdError,
     fmt,
     future::Future,
     pin::Pin,
@@ -13,7 +14,7 @@ use bytes::Bytes;
 use futures_core::Stream;
 
 use crate::{
-    body::{Body, BodyStream, ResponseBody},
+    body::{AnyBody, BodyStream},
     error::{Error, HttpError},
     header::{self, IntoHeaderPair, IntoHeaderValue},
     message::{BoxedResponseHead, ConnectionType, ResponseHead},
@@ -38,10 +39,11 @@ use crate::{
 ///     .body("1234");
 ///
 /// assert_eq!(res.status(), StatusCode::OK);
-/// assert_eq!(body::to_bytes(res.take_body()).await.unwrap(), &b"1234"[..]);
 ///
 /// assert!(res.headers().contains_key("server"));
 /// assert_eq!(res.headers().get_all("set-cookie").count(), 2);
+///
+/// assert_eq!(body::to_bytes(res.into_body()).await.unwrap(), &b"1234"[..]);
 /// # })
 /// ```
 pub struct ResponseBuilder {
@@ -234,45 +236,41 @@ impl ResponseBuilder {
     ///
     /// This `ResponseBuilder` will be left in a useless state.
     #[inline]
-    pub fn body<B: Into<Body>>(&mut self, body: B) -> Response<Body> {
+    pub fn body<B: Into<AnyBody>>(&mut self, body: B) -> Response<AnyBody> {
         self.message_body(body.into())
+            .unwrap_or_else(Response::from)
     }
 
     /// Generate response with a body.
     ///
     /// This `ResponseBuilder` will be left in a useless state.
-    pub fn message_body<B>(&mut self, body: B) -> Response<B> {
-        if let Some(e) = self.err.take() {
-            return Response::from(Error::from(e)).into_body();
+    pub fn message_body<B>(&mut self, body: B) -> Result<Response<B>, Error> {
+        if let Some(err) = self.err.take() {
+            return Err(Error::new_http().with_cause(err));
         }
 
-        let response = self.head.take().expect("cannot reuse response builder");
-
-        Response {
-            head: response,
-            body: ResponseBody::Body(body),
-            error: None,
-        }
+        let head = self.head.take().expect("cannot reuse response builder");
+        Ok(Response { head, body })
     }
 
     /// Generate response with a streaming body.
     ///
     /// This `ResponseBuilder` will be left in a useless state.
     #[inline]
-    pub fn streaming<S, E>(&mut self, stream: S) -> Response<Body>
+    pub fn streaming<S, E>(&mut self, stream: S) -> Response<AnyBody>
     where
-        S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-        E: Into<Error> + 'static,
+        S: Stream<Item = Result<Bytes, E>> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
     {
-        self.body(Body::from_message(BodyStream::new(stream)))
+        self.body(AnyBody::from_message(BodyStream::new(stream)))
     }
 
     /// Generate response with an empty body.
     ///
     /// This `ResponseBuilder` will be left in a useless state.
     #[inline]
-    pub fn finish(&mut self) -> Response<Body> {
-        self.body(Body::Empty)
+    pub fn finish(&mut self) -> Response<AnyBody> {
+        self.body(AnyBody::Empty)
     }
 
     /// Create an owned `ResponseBuilder`, leaving the original in a useless state.
@@ -330,7 +328,7 @@ impl<'a> From<&'a ResponseHead> for ResponseBuilder {
 }
 
 impl Future for ResponseBuilder {
-    type Output = Result<Response<Body>, Error>;
+    type Output = Result<Response<AnyBody>, Error>;
 
     fn poll(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
         Poll::Ready(Ok(self.finish()))
diff --git a/actix-http/src/service.rs b/actix-http/src/service.rs
index ff4b49f1d..afe47bf2d 100644
--- a/actix-http/src/service.rs
+++ b/actix-http/src/service.rs
@@ -1,4 +1,5 @@
 use std::{
+    error::Error as StdError,
     fmt,
     future::Future,
     marker::PhantomData,
@@ -8,6 +9,7 @@ use std::{
     task::{Context, Poll},
 };
 
+use ::h2::server::{handshake as h2_handshake, Handshake as H2Handshake};
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_rt::net::TcpStream;
 use actix_service::{
@@ -15,16 +17,15 @@ use actix_service::{
 };
 use bytes::Bytes;
 use futures_core::{future::LocalBoxFuture, ready};
-use h2::server::{handshake, Handshake};
 use pin_project::pin_project;
 
-use crate::body::MessageBody;
-use crate::builder::HttpServiceBuilder;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::{DispatchError, Error};
-use crate::request::Request;
-use crate::response::Response;
-use crate::{h1, h2::Dispatcher, ConnectCallback, OnConnectData, Protocol};
+use crate::{
+    body::{AnyBody, MessageBody},
+    builder::HttpServiceBuilder,
+    config::{KeepAlive, ServiceConfig},
+    error::DispatchError,
+    h1, h2, ConnectCallback, OnConnectData, Protocol, Request, Response,
+};
 
 /// A `ServiceFactory` for HTTP/1.1 or HTTP/2 protocol.
 pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler> {
@@ -39,7 +40,7 @@ pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler> {
 impl<T, S, B> HttpService<T, S, B>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
@@ -54,11 +55,12 @@ where
 impl<T, S, B> HttpService<T, S, B>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
     /// Create new `HttpService` instance.
     pub fn new<F: IntoServiceFactory<S, Request>>(service: F) -> Self {
@@ -93,7 +95,7 @@ where
 impl<T, S, B, X, U> HttpService<T, S, B, X, U>
 where
     S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
@@ -107,7 +109,7 @@ where
     pub fn expect<X1>(self, expect: X1) -> HttpService<T, S, B, X1, U>
     where
         X1: ServiceFactory<Request, Config = (), Response = Request>,
-        X1::Error: Into<Error>,
+        X1::Error: Into<Response<AnyBody>>,
         X1::InitError: fmt::Debug,
     {
         HttpService {
@@ -151,16 +153,17 @@ impl<S, B, X, U> HttpService<TcpStream, S, B, X, U>
 where
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
 
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 
     X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Future: 'static,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
     X::InitError: fmt::Debug,
 
     U: ServiceFactory<
@@ -169,7 +172,7 @@ where
         Response = (),
     >,
     U::Future: 'static,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
     U::InitError: fmt::Debug,
 {
     /// Create simple tcp stream service
@@ -202,16 +205,17 @@ mod openssl {
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Future: 'static,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
         <S::Service as Service<Request>>::Future: 'static,
 
         B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,
 
         X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Future: 'static,
-        X::Error: Into<Error>,
+        X::Error: Into<Response<AnyBody>>,
         X::InitError: fmt::Debug,
 
         U: ServiceFactory<
@@ -220,7 +224,7 @@ mod openssl {
             Response = (),
         >,
         U::Future: 'static,
-        U::Error: fmt::Display + Into<Error>,
+        U::Error: fmt::Display + Into<Response<AnyBody>>,
         U::InitError: fmt::Debug,
     {
         /// Create openssl based service
@@ -269,16 +273,17 @@ mod rustls {
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Future: 'static,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
         <S::Service as Service<Request>>::Future: 'static,
 
         B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,
 
         X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Future: 'static,
-        X::Error: Into<Error>,
+        X::Error: Into<Response<AnyBody>>,
         X::InitError: fmt::Debug,
 
         U: ServiceFactory<
@@ -287,7 +292,7 @@ mod rustls {
             Response = (),
         >,
         U::Future: 'static,
-        U::Error: fmt::Display + Into<Error>,
+        U::Error: fmt::Display + Into<Response<AnyBody>>,
         U::InitError: fmt::Debug,
     {
         /// Create rustls based service
@@ -301,7 +306,8 @@ mod rustls {
             Error = TlsError<io::Error, DispatchError>,
             InitError = (),
         > {
-            let protos = vec!["h2".to_string().into(), "http/1.1".to_string().into()];
+            let mut protos = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
+            protos.extend_from_slice(&config.alpn_protocols);
             config.set_protocols(&protos);
 
             Acceptor::new(config)
@@ -333,21 +339,22 @@ where
 
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
 
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 
     X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Future: 'static,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
     X::InitError: fmt::Debug,
 
     U: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
     U::Future: 'static,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
     U::InitError: fmt::Debug,
 {
     type Response = ();
@@ -410,11 +417,11 @@ where
 impl<T, S, B, X, U> HttpServiceHandler<T, S, B, X, U>
 where
     S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
     X: Service<Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
     U: Service<(Request, Framed<T, h1::Codec>)>,
-    U::Error: Into<Error>,
+    U::Error: Into<Response<AnyBody>>,
 {
     pub(super) fn new(
         cfg: ServiceConfig,
@@ -431,7 +438,10 @@ where
         }
     }
 
-    pub(super) fn _poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
+    pub(super) fn _poll_ready(
+        &self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Response<AnyBody>>> {
         ready!(self.flow.expect.poll_ready(cx).map_err(Into::into))?;
 
         ready!(self.flow.service.poll_ready(cx).map_err(Into::into))?;
@@ -465,15 +475,20 @@ impl<T, S, B, X, U> Service<(T, Protocol, Option<net::SocketAddr>)>
     for HttpServiceHandler<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
+
     S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
+
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
 {
     type Response = ();
     type Error = DispatchError;
@@ -496,7 +511,7 @@ where
         match proto {
             Protocol::Http2 => HttpServiceHandlerResponse {
                 state: State::H2Handshake(Some((
-                    handshake(io),
+                    h2_handshake(io),
                     self.cfg.clone(),
                     self.flow.clone(),
                     on_connect_data,
@@ -522,21 +537,26 @@ where
 #[pin_project(project = StateProj)]
 enum State<T, S, B, X, U>
 where
+    T: AsyncRead + AsyncWrite + Unpin,
+
     S: Service<Request>,
     S::Future: 'static,
-    S::Error: Into<Error>,
-    T: AsyncRead + AsyncWrite + Unpin,
+    S::Error: Into<Response<AnyBody>>,
+
     B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     H1(#[pin] h1::Dispatcher<T, S, B, X, U>),
-    H2(#[pin] Dispatcher<T, S, B, X, U>),
+    H2(#[pin] h2::Dispatcher<T, S, B, X, U>),
     H2Handshake(
         Option<(
-            Handshake<T, Bytes>,
+            H2Handshake<T, Bytes>,
             ServiceConfig,
             Rc<HttpFlow<S, X, U>>,
             OnConnectData,
@@ -549,13 +569,18 @@ where
 pub struct HttpServiceHandlerResponse<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
+
     S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
+
+    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -566,13 +591,18 @@ where
 impl<T, S, B, X, U> Future for HttpServiceHandlerResponse<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
+
     S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
-    B: MessageBody,
+
+    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
+
     X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
     U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -587,13 +617,15 @@ where
                     Ok(conn) => {
                         let (_, cfg, srv, on_connect_data, peer_addr) =
                             data.take().unwrap();
-                        self.as_mut().project().state.set(State::H2(Dispatcher::new(
-                            srv,
-                            conn,
-                            on_connect_data,
-                            cfg,
-                            peer_addr,
-                        )));
+                        self.as_mut().project().state.set(State::H2(
+                            h2::Dispatcher::new(
+                                srv,
+                                conn,
+                                on_connect_data,
+                                cfg,
+                                peer_addr,
+                            ),
+                        ));
                         self.poll(cx)
                     }
                     Err(err) => {
diff --git a/actix-http/src/ws/dispatcher.rs b/actix-http/src/ws/dispatcher.rs
index 576851139..f49cbe5d4 100644
--- a/actix-http/src/ws/dispatcher.rs
+++ b/actix-http/src/ws/dispatcher.rs
@@ -72,7 +72,7 @@ mod inner {
 
     use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 
-    use crate::ResponseError;
+    use crate::{body::AnyBody, Response};
 
     /// Framed transport errors
     pub enum DispatcherError<E, U, I>
@@ -136,13 +136,16 @@ mod inner {
         }
     }
 
-    impl<E, U, I> ResponseError for DispatcherError<E, U, I>
+    impl<E, U, I> From<DispatcherError<E, U, I>> for Response<AnyBody>
     where
         E: fmt::Debug + fmt::Display,
         U: Encoder<I> + Decoder,
         <U as Encoder<I>>::Error: fmt::Debug,
         <U as Decoder>::Error: fmt::Debug,
     {
+        fn from(err: DispatcherError<E, U, I>) -> Self {
+            Response::internal_server_error().set_body(AnyBody::from(err.to_string()))
+        }
     }
 
     /// Message type wrapper for signalling end of message stream.
diff --git a/actix-http/src/ws/mod.rs b/actix-http/src/ws/mod.rs
index 22df2b4ff..7df924cf5 100644
--- a/actix-http/src/ws/mod.rs
+++ b/actix-http/src/ws/mod.rs
@@ -9,8 +9,8 @@ use derive_more::{Display, Error, From};
 use http::{header, Method, StatusCode};
 
 use crate::{
-    body::Body, error::ResponseError, header::HeaderValue, message::RequestHead,
-    response::Response, ResponseBuilder,
+    body::AnyBody, header::HeaderValue, message::RequestHead, response::Response,
+    ResponseBuilder,
 };
 
 mod codec;
@@ -25,7 +25,7 @@ pub use self::frame::Parser;
 pub use self::proto::{hash_key, CloseCode, CloseReason, OpCode};
 
 /// WebSocket protocol errors.
-#[derive(Debug, Display, From, Error)]
+#[derive(Debug, Display, Error, From)]
 pub enum ProtocolError {
     /// Received an unmasked frame from client.
     #[display(fmt = "Received an unmasked frame from client.")]
@@ -68,10 +68,8 @@ pub enum ProtocolError {
     Io(io::Error),
 }
 
-impl ResponseError for ProtocolError {}
-
 /// WebSocket handshake errors
-#[derive(PartialEq, Debug, Display)]
+#[derive(Debug, PartialEq, Display, Error)]
 pub enum HandshakeError {
     /// Only get method is allowed.
     #[display(fmt = "Method not allowed.")]
@@ -98,44 +96,55 @@ pub enum HandshakeError {
     BadWebsocketKey,
 }
 
-impl ResponseError for HandshakeError {
-    fn error_response(&self) -> Response<Body> {
-        match self {
+impl From<&HandshakeError> for Response<AnyBody> {
+    fn from(err: &HandshakeError) -> Self {
+        match err {
             HandshakeError::GetMethodRequired => {
-                Response::build(StatusCode::METHOD_NOT_ALLOWED)
-                    .insert_header((header::ALLOW, "GET"))
-                    .finish()
+                let mut res = Response::new(StatusCode::METHOD_NOT_ALLOWED);
+                res.headers_mut()
+                    .insert(header::ALLOW, HeaderValue::from_static("GET"));
+                res
             }
 
             HandshakeError::NoWebsocketUpgrade => {
-                Response::build(StatusCode::BAD_REQUEST)
-                    .reason("No WebSocket Upgrade header found")
-                    .finish()
+                let mut res = Response::bad_request();
+                res.head_mut().reason = Some("No WebSocket Upgrade header found");
+                res
             }
 
             HandshakeError::NoConnectionUpgrade => {
-                Response::build(StatusCode::BAD_REQUEST)
-                    .reason("No Connection upgrade")
-                    .finish()
+                let mut res = Response::bad_request();
+                res.head_mut().reason = Some("No Connection upgrade");
+                res
             }
 
-            HandshakeError::NoVersionHeader => Response::build(StatusCode::BAD_REQUEST)
-                .reason("WebSocket version header is required")
-                .finish(),
+            HandshakeError::NoVersionHeader => {
+                let mut res = Response::bad_request();
+                res.head_mut().reason = Some("WebSocket version header is required");
+                res
+            }
 
             HandshakeError::UnsupportedVersion => {
-                Response::build(StatusCode::BAD_REQUEST)
-                    .reason("Unsupported WebSocket version")
-                    .finish()
+                let mut res = Response::bad_request();
+                res.head_mut().reason = Some("Unsupported WebSocket version");
+                res
             }
 
-            HandshakeError::BadWebsocketKey => Response::build(StatusCode::BAD_REQUEST)
-                .reason("Handshake error")
-                .finish(),
+            HandshakeError::BadWebsocketKey => {
+                let mut res = Response::bad_request();
+                res.head_mut().reason = Some("Handshake error");
+                res
+            }
         }
     }
 }
 
+impl From<HandshakeError> for Response<AnyBody> {
+    fn from(err: HandshakeError) -> Self {
+        (&err).into()
+    }
+}
+
 /// Verify WebSocket handshake request and create handshake response.
 pub fn handshake(req: &RequestHead) -> Result<ResponseBuilder, HandshakeError> {
     verify_handshake(req)?;
@@ -213,7 +222,7 @@ pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test::TestRequest;
+    use crate::{body::AnyBody, test::TestRequest};
     use http::{header, Method};
 
     #[test]
@@ -327,18 +336,18 @@ mod tests {
     }
 
     #[test]
-    fn test_wserror_http_response() {
-        let resp = HandshakeError::GetMethodRequired.error_response();
+    fn test_ws_error_http_response() {
+        let resp: Response<AnyBody> = HandshakeError::GetMethodRequired.into();
         assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
-        let resp = HandshakeError::NoWebsocketUpgrade.error_response();
+        let resp: Response<AnyBody> = HandshakeError::NoWebsocketUpgrade.into();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp = HandshakeError::NoConnectionUpgrade.error_response();
+        let resp: Response<AnyBody> = HandshakeError::NoConnectionUpgrade.into();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp = HandshakeError::NoVersionHeader.error_response();
+        let resp: Response<AnyBody> = HandshakeError::NoVersionHeader.into();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp = HandshakeError::UnsupportedVersion.error_response();
+        let resp: Response<AnyBody> = HandshakeError::UnsupportedVersion.into();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp = HandshakeError::BadWebsocketKey.error_response();
+        let resp: Response<AnyBody> = HandshakeError::BadWebsocketKey.into();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
     }
 }
diff --git a/actix-http/tests/test_client.rs b/actix-http/tests/test_client.rs
index 0a06d90e5..414266d81 100644
--- a/actix-http/tests/test_client.rs
+++ b/actix-http/tests/test_client.rs
@@ -1,10 +1,13 @@
+use std::convert::Infallible;
+
 use actix_http::{
-    error, http, http::StatusCode, HttpMessage, HttpService, Request, Response,
+    body::AnyBody, http, http::StatusCode, HttpMessage, HttpService, Request, Response,
 };
 use actix_http_test::test_server;
 use actix_service::ServiceFactoryExt;
 use actix_utils::future;
 use bytes::Bytes;
+use derive_more::{Display, Error};
 use futures_util::StreamExt as _;
 
 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
@@ -33,7 +36,7 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 async fn test_h1_v2() {
     let srv = test_server(move || {
         HttpService::build()
-            .finish(|_| future::ok::<_, ()>(Response::ok().set_body(STR)))
+            .finish(|_| future::ok::<_, Infallible>(Response::ok().set_body(STR)))
             .tcp()
     })
     .await;
@@ -61,7 +64,7 @@ async fn test_h1_v2() {
 async fn test_connection_close() {
     let srv = test_server(move || {
         HttpService::build()
-            .finish(|_| future::ok::<_, ()>(Response::ok().set_body(STR)))
+            .finish(|_| future::ok::<_, Infallible>(Response::ok().set_body(STR)))
             .tcp()
             .map(|_| ())
     })
@@ -75,11 +78,11 @@ async fn test_connection_close() {
 async fn test_with_query_parameter() {
     let srv = test_server(move || {
         HttpService::build()
-            .finish(|req: Request| {
+            .finish(|req: Request| async move {
                 if req.uri().query().unwrap().contains("qp=") {
-                    future::ok::<_, ()>(Response::ok())
+                    Ok::<_, Infallible>(Response::ok())
                 } else {
-                    future::ok::<_, ()>(Response::bad_request())
+                    Ok(Response::bad_request())
                 }
             })
             .tcp()
@@ -92,6 +95,16 @@ async fn test_with_query_parameter() {
     assert!(response.status().is_success());
 }
 
+#[derive(Debug, Display, Error)]
+#[display(fmt = "expect failed")]
+struct ExpectFailed;
+
+impl From<ExpectFailed> for Response<AnyBody> {
+    fn from(_: ExpectFailed) -> Self {
+        Response::new(StatusCode::EXPECTATION_FAILED)
+    }
+}
+
 #[actix_rt::test]
 async fn test_h1_expect() {
     let srv = test_server(move || {
@@ -100,7 +113,7 @@ async fn test_h1_expect() {
                 if req.headers().contains_key("AUTH") {
                     Ok(req)
                 } else {
-                    Err(error::ErrorExpectationFailed("expect failed"))
+                    Err(ExpectFailed)
                 }
             })
             .h1(|req: Request| async move {
@@ -112,7 +125,7 @@ async fn test_h1_expect() {
                 let str = std::str::from_utf8(&buf).unwrap();
                 assert_eq!(str, "expect body");
 
-                Ok::<_, ()>(Response::ok())
+                Ok::<_, Infallible>(Response::ok())
             })
             .tcp()
     })
@@ -134,7 +147,7 @@ async fn test_h1_expect() {
     let response = request.send_body("expect body").await.unwrap();
     assert_eq!(response.status(), StatusCode::EXPECTATION_FAILED);
 
-    // test exepct would continue
+    // test expect would continue
     let request = srv
         .request(http::Method::GET, srv.url("/"))
         .insert_header(("Expect", "100-continue"))
diff --git a/actix-http/tests/test_openssl.rs b/actix-http/tests/test_openssl.rs
index 7cbd58518..a58d0cc70 100644
--- a/actix-http/tests/test_openssl.rs
+++ b/actix-http/tests/test_openssl.rs
@@ -2,11 +2,11 @@
 
 extern crate tls_openssl as openssl;
 
-use std::io;
+use std::{convert::Infallible, io};
 
 use actix_http::{
-    body::{Body, SizedStream},
-    error::{ErrorBadRequest, PayloadError},
+    body::{AnyBody, Body, SizedStream},
+    error::PayloadError,
     http::{
         header::{self, HeaderName, HeaderValue},
         Method, StatusCode, Version,
@@ -17,6 +17,7 @@ use actix_http_test::test_server;
 use actix_service::{fn_service, ServiceFactoryExt};
 use actix_utils::future::{err, ok, ready};
 use bytes::{Bytes, BytesMut};
+use derive_more::{Display, Error};
 use futures_core::Stream;
 use futures_util::stream::{once, StreamExt as _};
 use openssl::{
@@ -135,7 +136,7 @@ async fn test_h2_content_length() {
                     StatusCode::OK,
                     StatusCode::NOT_FOUND,
                 ];
-                ok::<_, ()>(Response::new(statuses[idx]))
+                ok::<_, Infallible>(Response::new(statuses[idx]))
             })
             .openssl(tls_config())
             .map_err(|_| ())
@@ -205,7 +206,7 @@ async fn test_h2_headers() {
                         TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
                 ));
             }
-            ok::<_, ()>(builder.body(data.clone()))
+            ok::<_, Infallible>(builder.body(data.clone()))
         })
             .openssl(tls_config())
                     .map_err(|_| ())
@@ -245,7 +246,7 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 async fn test_h2_body2() {
     let mut srv = test_server(move || {
         HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .openssl(tls_config())
             .map_err(|_| ())
     })
@@ -263,7 +264,7 @@ async fn test_h2_body2() {
 async fn test_h2_head_empty() {
     let mut srv = test_server(move || {
         HttpService::build()
-            .finish(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .finish(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .openssl(tls_config())
             .map_err(|_| ())
     })
@@ -287,7 +288,7 @@ async fn test_h2_head_empty() {
 async fn test_h2_head_binary() {
     let mut srv = test_server(move || {
         HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .openssl(tls_config())
             .map_err(|_| ())
     })
@@ -310,7 +311,7 @@ async fn test_h2_head_binary() {
 async fn test_h2_head_binary2() {
     let srv = test_server(move || {
         HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .openssl(tls_config())
             .map_err(|_| ())
     })
@@ -329,9 +330,12 @@ async fn test_h2_head_binary2() {
 async fn test_h2_body_length() {
     let mut srv = test_server(move || {
         HttpService::build()
-            .h2(|_| {
-                let body = once(ok(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
+            .h2(|_| async {
+                let body = once(async {
+                    Ok::<_, Infallible>(Bytes::from_static(STR.as_ref()))
+                });
+
+                Ok::<_, Infallible>(
                     Response::ok().set_body(SizedStream::new(STR.len() as u64, body)),
                 )
             })
@@ -354,7 +358,7 @@ async fn test_h2_body_chunked_explicit() {
         HttpService::build()
             .h2(|_| {
                 let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
+                ok::<_, Infallible>(
                     Response::build(StatusCode::OK)
                         .insert_header((header::TRANSFER_ENCODING, "chunked"))
                         .streaming(body),
@@ -382,7 +386,7 @@ async fn test_h2_response_http_error_handling() {
         HttpService::build()
             .h2(fn_service(|_| {
                 let broken_header = Bytes::from_static(b"\0\0\0");
-                ok::<_, ()>(
+                ok::<_, Infallible>(
                     Response::build(StatusCode::OK)
                         .insert_header((header::CONTENT_TYPE, broken_header))
                         .body(STR),
@@ -398,14 +402,27 @@ async fn test_h2_response_http_error_handling() {
 
     // read response
     let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
+    assert_eq!(
+        bytes,
+        Bytes::from_static(b"error processing HTTP: failed to parse header value")
+    );
+}
+
+#[derive(Debug, Display, Error)]
+#[display(fmt = "error")]
+struct BadRequest;
+
+impl From<BadRequest> for Response<AnyBody> {
+    fn from(err: BadRequest) -> Self {
+        Response::build(StatusCode::BAD_REQUEST).body(err.to_string())
+    }
 }
 
 #[actix_rt::test]
 async fn test_h2_service_error() {
     let mut srv = test_server(move || {
         HttpService::build()
-            .h2(|_| err::<Response<Body>, Error>(ErrorBadRequest("error")))
+            .h2(|_| err::<Response<Body>, _>(BadRequest))
             .openssl(tls_config())
             .map_err(|_| ())
     })
@@ -428,7 +445,7 @@ async fn test_h2_on_connect() {
             })
             .h2(|req: Request| {
                 assert!(req.extensions().contains::<isize>());
-                ok::<_, ()>(Response::ok())
+                ok::<_, Infallible>(Response::ok())
             })
             .openssl(tls_config())
             .map_err(|_| ())
diff --git a/actix-http/tests/test_rustls.rs b/actix-http/tests/test_rustls.rs
index a122ab847..cb7c77ad6 100644
--- a/actix-http/tests/test_rustls.rs
+++ b/actix-http/tests/test_rustls.rs
@@ -2,9 +2,16 @@
 
 extern crate tls_rustls as rustls;
 
+use std::{
+    convert::Infallible,
+    io::{self, BufReader, Write},
+    net::{SocketAddr, TcpStream as StdTcpStream},
+    sync::Arc,
+};
+
 use actix_http::{
-    body::{Body, SizedStream},
-    error::{self, PayloadError},
+    body::{AnyBody, Body, SizedStream},
+    error::PayloadError,
     http::{
         header::{self, HeaderName, HeaderValue},
         Method, StatusCode, Version,
@@ -14,16 +21,15 @@ use actix_http::{
 use actix_http_test::test_server;
 use actix_service::{fn_factory_with_config, fn_service};
 use actix_utils::future::{err, ok};
-
 use bytes::{Bytes, BytesMut};
+use derive_more::{Display, Error};
 use futures_core::Stream;
 use futures_util::stream::{once, StreamExt as _};
 use rustls::{
     internal::pemfile::{certs, pkcs8_private_keys},
-    NoClientAuth, ServerConfig as RustlsServerConfig,
+    NoClientAuth, ServerConfig as RustlsServerConfig, Session,
 };
-
-use std::io::{self, BufReader};
+use webpki::DNSNameRef;
 
 async fn load_body<S>(mut stream: S) -> Result<BytesMut, PayloadError>
 where
@@ -52,6 +58,25 @@ fn tls_config() -> RustlsServerConfig {
     config
 }
 
+pub fn get_negotiated_alpn_protocol(
+    addr: SocketAddr,
+    client_alpn_protocol: &[u8],
+) -> Option<Vec<u8>> {
+    let mut config = rustls::ClientConfig::new();
+    config.alpn_protocols.push(client_alpn_protocol.to_vec());
+    let mut sess = rustls::ClientSession::new(
+        &Arc::new(config),
+        DNSNameRef::try_from_ascii_str("localhost").unwrap(),
+    );
+    let mut sock = StdTcpStream::connect(addr).unwrap();
+    let mut stream = rustls::Stream::new(&mut sess, &mut sock);
+    // The handshake will fails because the client will not be able to verify the server
+    // certificate, but it doesn't matter here as we are just interested in the negotiated ALPN
+    // protocol
+    let _ = stream.flush();
+    sess.get_alpn_protocol().map(|proto| proto.to_vec())
+}
+
 #[actix_rt::test]
 async fn test_h1() -> io::Result<()> {
     let srv = test_server(move || {
@@ -149,7 +174,7 @@ async fn test_h2_content_length() {
                     StatusCode::OK,
                     StatusCode::NOT_FOUND,
                 ];
-                ok::<_, ()>(Response::new(statuses[indx]))
+                ok::<_, Infallible>(Response::new(statuses[indx]))
             })
             .rustls(tls_config())
     })
@@ -218,7 +243,7 @@ async fn test_h2_headers() {
                         TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
                 ));
             }
-            ok::<_, ()>(config.body(data.clone()))
+            ok::<_, Infallible>(config.body(data.clone()))
         })
             .rustls(tls_config())
     }).await;
@@ -257,7 +282,7 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 async fn test_h2_body2() {
     let mut srv = test_server(move || {
         HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .rustls(tls_config())
     })
     .await;
@@ -274,7 +299,7 @@ async fn test_h2_body2() {
 async fn test_h2_head_empty() {
     let mut srv = test_server(move || {
         HttpService::build()
-            .finish(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .finish(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .rustls(tls_config())
     })
     .await;
@@ -300,7 +325,7 @@ async fn test_h2_head_empty() {
 async fn test_h2_head_binary() {
     let mut srv = test_server(move || {
         HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .rustls(tls_config())
     })
     .await;
@@ -325,7 +350,7 @@ async fn test_h2_head_binary() {
 async fn test_h2_head_binary2() {
     let srv = test_server(move || {
         HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .rustls(tls_config())
     })
     .await;
@@ -347,8 +372,8 @@ async fn test_h2_body_length() {
     let mut srv = test_server(move || {
         HttpService::build()
             .h2(|_| {
-                let body = once(ok(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
+                let body = once(ok::<_, Infallible>(Bytes::from_static(STR.as_ref())));
+                ok::<_, Infallible>(
                     Response::ok().set_body(SizedStream::new(STR.len() as u64, body)),
                 )
             })
@@ -370,7 +395,7 @@ async fn test_h2_body_chunked_explicit() {
         HttpService::build()
             .h2(|_| {
                 let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
+                ok::<_, Infallible>(
                     Response::build(StatusCode::OK)
                         .insert_header((header::TRANSFER_ENCODING, "chunked"))
                         .streaming(body),
@@ -396,9 +421,9 @@ async fn test_h2_response_http_error_handling() {
     let mut srv = test_server(move || {
         HttpService::build()
             .h2(fn_factory_with_config(|_: ()| {
-                ok::<_, ()>(fn_service(|_| {
+                ok::<_, Infallible>(fn_service(|_| {
                     let broken_header = Bytes::from_static(b"\0\0\0");
-                    ok::<_, ()>(
+                    ok::<_, Infallible>(
                         Response::build(StatusCode::OK)
                             .insert_header((http::header::CONTENT_TYPE, broken_header))
                             .body(STR),
@@ -414,14 +439,27 @@ async fn test_h2_response_http_error_handling() {
 
     // read response
     let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
+    assert_eq!(
+        bytes,
+        Bytes::from_static(b"error processing HTTP: failed to parse header value")
+    );
+}
+
+#[derive(Debug, Display, Error)]
+#[display(fmt = "error")]
+struct BadRequest;
+
+impl From<BadRequest> for Response<AnyBody> {
+    fn from(_: BadRequest) -> Self {
+        Response::bad_request().set_body(AnyBody::from("error"))
+    }
 }
 
 #[actix_rt::test]
 async fn test_h2_service_error() {
     let mut srv = test_server(move || {
         HttpService::build()
-            .h2(|_| err::<Response<Body>, Error>(error::ErrorBadRequest("error")))
+            .h2(|_| err::<Response<Body>, _>(BadRequest))
             .rustls(tls_config())
     })
     .await;
@@ -438,7 +476,7 @@ async fn test_h2_service_error() {
 async fn test_h1_service_error() {
     let mut srv = test_server(move || {
         HttpService::build()
-            .h1(|_| err::<Response<Body>, Error>(error::ErrorBadRequest("error")))
+            .h1(|_| err::<Response<Body>, _>(BadRequest))
             .rustls(tls_config())
     })
     .await;
@@ -450,3 +488,85 @@ async fn test_h1_service_error() {
     let bytes = srv.load_body(response).await.unwrap();
     assert_eq!(bytes, Bytes::from_static(b"error"));
 }
+
+const H2_ALPN_PROTOCOL: &[u8] = b"h2";
+const HTTP1_1_ALPN_PROTOCOL: &[u8] = b"http/1.1";
+const CUSTOM_ALPN_PROTOCOL: &[u8] = b"custom";
+
+#[actix_rt::test]
+async fn test_alpn_h1() -> io::Result<()> {
+    let srv = test_server(move || {
+        let mut config = tls_config();
+        config.alpn_protocols.push(CUSTOM_ALPN_PROTOCOL.to_vec());
+        HttpService::build()
+            .h1(|_| ok::<_, Error>(Response::ok()))
+            .rustls(config)
+    })
+    .await;
+
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), CUSTOM_ALPN_PROTOCOL),
+        Some(CUSTOM_ALPN_PROTOCOL.to_vec())
+    );
+
+    let response = srv.sget("/").send().await.unwrap();
+    assert!(response.status().is_success());
+
+    Ok(())
+}
+
+#[actix_rt::test]
+async fn test_alpn_h2() -> io::Result<()> {
+    let srv = test_server(move || {
+        let mut config = tls_config();
+        config.alpn_protocols.push(CUSTOM_ALPN_PROTOCOL.to_vec());
+        HttpService::build()
+            .h2(|_| ok::<_, Error>(Response::ok()))
+            .rustls(config)
+    })
+    .await;
+
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), H2_ALPN_PROTOCOL),
+        Some(H2_ALPN_PROTOCOL.to_vec())
+    );
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), CUSTOM_ALPN_PROTOCOL),
+        Some(CUSTOM_ALPN_PROTOCOL.to_vec())
+    );
+
+    let response = srv.sget("/").send().await.unwrap();
+    assert!(response.status().is_success());
+
+    Ok(())
+}
+
+#[actix_rt::test]
+async fn test_alpn_h2_1() -> io::Result<()> {
+    let srv = test_server(move || {
+        let mut config = tls_config();
+        config.alpn_protocols.push(CUSTOM_ALPN_PROTOCOL.to_vec());
+        HttpService::build()
+            .finish(|_| ok::<_, Error>(Response::ok()))
+            .rustls(config)
+    })
+    .await;
+
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), H2_ALPN_PROTOCOL),
+        Some(H2_ALPN_PROTOCOL.to_vec())
+    );
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), HTTP1_1_ALPN_PROTOCOL),
+        Some(HTTP1_1_ALPN_PROTOCOL.to_vec())
+    );
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), CUSTOM_ALPN_PROTOCOL),
+        Some(CUSTOM_ALPN_PROTOCOL.to_vec())
+    );
+
+    let response = srv.sget("/").send().await.unwrap();
+    assert!(response.status().is_success());
+
+    Ok(())
+}
diff --git a/actix-http/tests/test_server.rs b/actix-http/tests/test_server.rs
index 9b8b039c3..1e6d0b637 100644
--- a/actix-http/tests/test_server.rs
+++ b/actix-http/tests/test_server.rs
@@ -1,23 +1,26 @@
-use std::io::{Read, Write};
-use std::time::Duration;
-use std::{net, thread};
+use std::{
+    convert::Infallible,
+    io::{Read, Write},
+    net, thread,
+    time::Duration,
+};
 
+use actix_http::{
+    body::{AnyBody, Body, SizedStream},
+    header, http, Error, HttpMessage, HttpService, KeepAlive, Request, Response,
+    StatusCode,
+};
 use actix_http_test::test_server;
 use actix_rt::time::sleep;
 use actix_service::fn_service;
 use actix_utils::future::{err, ok, ready};
 use bytes::Bytes;
-use futures_util::stream::{once, StreamExt as _};
-use futures_util::FutureExt as _;
-use regex::Regex;
-
-use actix_http::HttpMessage;
-use actix_http::{
-    body::{Body, SizedStream},
-    error,
-    http::{self, header, StatusCode},
-    Error, HttpService, KeepAlive, Request, Response,
+use derive_more::{Display, Error};
+use futures_util::{
+    stream::{once, StreamExt as _},
+    FutureExt as _,
 };
+use regex::Regex;
 
 #[actix_rt::test]
 async fn test_h1() {
@@ -28,7 +31,7 @@ async fn test_h1() {
             .client_disconnect(1000)
             .h1(|req: Request| {
                 assert!(req.peer_addr().is_some());
-                ok::<_, ()>(Response::ok())
+                ok::<_, Infallible>(Response::ok())
             })
             .tcp()
     })
@@ -48,7 +51,7 @@ async fn test_h1_2() {
             .finish(|req: Request| {
                 assert!(req.peer_addr().is_some());
                 assert_eq!(req.version(), http::Version::HTTP_11);
-                ok::<_, ()>(Response::ok())
+                ok::<_, Infallible>(Response::ok())
             })
             .tcp()
     })
@@ -58,6 +61,16 @@ async fn test_h1_2() {
     assert!(response.status().is_success());
 }
 
+#[derive(Debug, Display, Error)]
+#[display(fmt = "expect failed")]
+struct ExpectFailed;
+
+impl From<ExpectFailed> for Response<AnyBody> {
+    fn from(_: ExpectFailed) -> Self {
+        Response::new(StatusCode::EXPECTATION_FAILED)
+    }
+}
+
 #[actix_rt::test]
 async fn test_expect_continue() {
     let srv = test_server(|| {
@@ -66,10 +79,10 @@ async fn test_expect_continue() {
                 if req.head().uri.query() == Some("yes=") {
                     ok(req)
                 } else {
-                    err(error::ErrorPreconditionFailed("error"))
+                    err(ExpectFailed)
                 }
             }))
-            .finish(|_| ok::<_, ()>(Response::ok()))
+            .finish(|_| ok::<_, Infallible>(Response::ok()))
             .tcp()
     })
     .await;
@@ -78,7 +91,7 @@ async fn test_expect_continue() {
     let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
     let mut data = String::new();
     let _ = stream.read_to_string(&mut data);
-    assert!(data.starts_with("HTTP/1.1 412 Precondition Failed\r\ncontent-length"));
+    assert!(data.starts_with("HTTP/1.1 417 Expectation Failed\r\ncontent-length"));
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test?yes= HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
@@ -96,11 +109,11 @@ async fn test_expect_continue_h1() {
                     if req.head().uri.query() == Some("yes=") {
                         ok(req)
                     } else {
-                        err(error::ErrorPreconditionFailed("error"))
+                        err(ExpectFailed)
                     }
                 })
             }))
-            .h1(fn_service(|_| ok::<_, ()>(Response::ok())))
+            .h1(fn_service(|_| ok::<_, Infallible>(Response::ok())))
             .tcp()
     })
     .await;
@@ -109,7 +122,7 @@ async fn test_expect_continue_h1() {
     let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
     let mut data = String::new();
     let _ = stream.read_to_string(&mut data);
-    assert!(data.starts_with("HTTP/1.1 412 Precondition Failed\r\ncontent-length"));
+    assert!(data.starts_with("HTTP/1.1 417 Expectation Failed\r\ncontent-length"));
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test?yes= HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
@@ -181,7 +194,7 @@ async fn test_slow_request() {
     let srv = test_server(|| {
         HttpService::build()
             .client_timeout(100)
-            .finish(|_| ok::<_, ()>(Response::ok()))
+            .finish(|_| ok::<_, Infallible>(Response::ok()))
             .tcp()
     })
     .await;
@@ -197,7 +210,7 @@ async fn test_slow_request() {
 async fn test_http1_malformed_request() {
     let srv = test_server(|| {
         HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::ok()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
             .tcp()
     })
     .await;
@@ -213,7 +226,7 @@ async fn test_http1_malformed_request() {
 async fn test_http1_keepalive() {
     let srv = test_server(|| {
         HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::ok()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
             .tcp()
     })
     .await;
@@ -235,7 +248,7 @@ async fn test_http1_keepalive_timeout() {
     let srv = test_server(|| {
         HttpService::build()
             .keep_alive(1)
-            .h1(|_| ok::<_, ()>(Response::ok()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
             .tcp()
     })
     .await;
@@ -256,7 +269,7 @@ async fn test_http1_keepalive_timeout() {
 async fn test_http1_keepalive_close() {
     let srv = test_server(|| {
         HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::ok()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
             .tcp()
     })
     .await;
@@ -277,7 +290,7 @@ async fn test_http1_keepalive_close() {
 async fn test_http10_keepalive_default_close() {
     let srv = test_server(|| {
         HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::ok()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
             .tcp()
     })
     .await;
@@ -297,7 +310,7 @@ async fn test_http10_keepalive_default_close() {
 async fn test_http10_keepalive() {
     let srv = test_server(|| {
         HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::ok()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
             .tcp()
     })
     .await;
@@ -325,7 +338,7 @@ async fn test_http1_keepalive_disabled() {
     let srv = test_server(|| {
         HttpService::build()
             .keep_alive(KeepAlive::Disabled)
-            .h1(|_| ok::<_, ()>(Response::ok()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
             .tcp()
     })
     .await;
@@ -360,7 +373,7 @@ async fn test_content_length() {
                     StatusCode::OK,
                     StatusCode::NOT_FOUND,
                 ];
-                ok::<_, ()>(Response::new(statuses[indx]))
+                ok::<_, Infallible>(Response::new(statuses[indx]))
             })
             .tcp()
     })
@@ -415,7 +428,7 @@ async fn test_h1_headers() {
                         TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
                 ));
             }
-            ok::<_, ()>(builder.body(data.clone()))
+            ok::<_, Infallible>(builder.body(data.clone()))
         }).tcp()
     }).await;
 
@@ -453,7 +466,7 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 async fn test_h1_body() {
     let mut srv = test_server(|| {
         HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .h1(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .tcp()
     })
     .await;
@@ -470,7 +483,7 @@ async fn test_h1_body() {
 async fn test_h1_head_empty() {
     let mut srv = test_server(|| {
         HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .h1(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .tcp()
     })
     .await;
@@ -495,7 +508,7 @@ async fn test_h1_head_empty() {
 async fn test_h1_head_binary() {
     let mut srv = test_server(|| {
         HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .h1(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .tcp()
     })
     .await;
@@ -520,7 +533,7 @@ async fn test_h1_head_binary() {
 async fn test_h1_head_binary2() {
     let srv = test_server(|| {
         HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::ok().set_body(STR)))
+            .h1(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
             .tcp()
     })
     .await;
@@ -542,8 +555,8 @@ async fn test_h1_body_length() {
     let mut srv = test_server(|| {
         HttpService::build()
             .h1(|_| {
-                let body = once(ok(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
+                let body = once(ok::<_, Infallible>(Bytes::from_static(STR.as_ref())));
+                ok::<_, Infallible>(
                     Response::ok().set_body(SizedStream::new(STR.len() as u64, body)),
                 )
             })
@@ -565,7 +578,7 @@ async fn test_h1_body_chunked_explicit() {
         HttpService::build()
             .h1(|_| {
                 let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
+                ok::<_, Infallible>(
                     Response::build(StatusCode::OK)
                         .insert_header((header::TRANSFER_ENCODING, "chunked"))
                         .streaming(body),
@@ -600,7 +613,7 @@ async fn test_h1_body_chunked_implicit() {
         HttpService::build()
             .h1(|_| {
                 let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(Response::build(StatusCode::OK).streaming(body))
+                ok::<_, Infallible>(Response::build(StatusCode::OK).streaming(body))
             })
             .tcp()
     })
@@ -629,7 +642,7 @@ async fn test_h1_response_http_error_handling() {
         HttpService::build()
             .h1(fn_service(|_| {
                 let broken_header = Bytes::from_static(b"\0\0\0");
-                ok::<_, ()>(
+                ok::<_, Infallible>(
                     Response::build(StatusCode::OK)
                         .insert_header((http::header::CONTENT_TYPE, broken_header))
                         .body(STR),
@@ -644,14 +657,27 @@ async fn test_h1_response_http_error_handling() {
 
     // read response
     let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
+    assert_eq!(
+        bytes,
+        Bytes::from_static(b"error processing HTTP: failed to parse header value")
+    );
+}
+
+#[derive(Debug, Display, Error)]
+#[display(fmt = "error")]
+struct BadRequest;
+
+impl From<BadRequest> for Response<AnyBody> {
+    fn from(_: BadRequest) -> Self {
+        Response::bad_request().set_body(AnyBody::from("error"))
+    }
 }
 
 #[actix_rt::test]
 async fn test_h1_service_error() {
     let mut srv = test_server(|| {
         HttpService::build()
-            .h1(|_| err::<Response<Body>, _>(error::ErrorBadRequest("error")))
+            .h1(|_| err::<Response<Body>, _>(BadRequest))
             .tcp()
     })
     .await;
@@ -673,7 +699,7 @@ async fn test_h1_on_connect() {
             })
             .h1(|req: Request| {
                 assert!(req.extensions().contains::<isize>());
-                ok::<_, ()>(Response::ok())
+                ok::<_, Infallible>(Response::ok())
             })
             .tcp()
     })
diff --git a/actix-http/tests/test_ws.rs b/actix-http/tests/test_ws.rs
index 72870bab5..6d0de2316 100644
--- a/actix-http/tests/test_ws.rs
+++ b/actix-http/tests/test_ws.rs
@@ -1,193 +1,196 @@
-use std::cell::Cell;
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::sync::{Arc, Mutex};
-use std::task::{Context, Poll};
+use std::{
+    cell::Cell,
+    convert::Infallible,
+    task::{Context, Poll},
+};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_http::{body, h1, ws, Error, HttpService, Request, Response};
+use actix_http::{
+    body::{AnyBody, BodySize},
+    h1,
+    ws::{self, CloseCode, Frame, Item, Message},
+    Error, HttpService, Request, Response,
+};
 use actix_http_test::test_server;
 use actix_service::{fn_factory, Service};
-use actix_utils::future;
 use bytes::Bytes;
+use derive_more::{Display, Error, From};
+use futures_core::future::LocalBoxFuture;
 use futures_util::{SinkExt as _, StreamExt as _};
 
-use crate::ws::Dispatcher;
+#[derive(Clone)]
+struct WsService(Cell<bool>);
 
-struct WsService<T>(Arc<Mutex<(PhantomData<T>, Cell<bool>)>>);
-
-impl<T> WsService<T> {
+impl WsService {
     fn new() -> Self {
-        WsService(Arc::new(Mutex::new((PhantomData, Cell::new(false)))))
+        WsService(Cell::new(false))
     }
 
     fn set_polled(&self) {
-        *self.0.lock().unwrap().1.get_mut() = true;
+        self.0.set(true);
     }
 
     fn was_polled(&self) -> bool {
-        self.0.lock().unwrap().1.get()
+        self.0.get()
     }
 }
 
-impl<T> Clone for WsService<T> {
-    fn clone(&self) -> Self {
-        WsService(self.0.clone())
+#[derive(Debug, Display, Error, From)]
+enum WsServiceError {
+    #[display(fmt = "http error")]
+    Http(actix_http::Error),
+
+    #[display(fmt = "ws handshake error")]
+    Ws(actix_http::ws::HandshakeError),
+
+    #[display(fmt = "io error")]
+    Io(std::io::Error),
+
+    #[display(fmt = "dispatcher error")]
+    Dispatcher,
+}
+
+impl From<WsServiceError> for Response<AnyBody> {
+    fn from(err: WsServiceError) -> Self {
+        match err {
+            WsServiceError::Http(err) => err.into(),
+            WsServiceError::Ws(err) => err.into(),
+            WsServiceError::Io(_err) => unreachable!(),
+            WsServiceError::Dispatcher => Response::internal_server_error()
+                .set_body(AnyBody::from(format!("{}", err))),
+        }
     }
 }
 
-impl<T> Service<(Request, Framed<T, h1::Codec>)> for WsService<T>
+impl<T> Service<(Request, Framed<T, h1::Codec>)> for WsService
 where
     T: AsyncRead + AsyncWrite + Unpin + 'static,
 {
     type Response = ();
-    type Error = Error;
-    type Future = Pin<Box<dyn Future<Output = Result<(), Error>>>>;
+    type Error = WsServiceError;
+    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
 
-    fn poll_ready(&self, _ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.set_polled();
         Poll::Ready(Ok(()))
     }
 
     fn call(&self, (req, mut framed): (Request, Framed<T, h1::Codec>)) -> Self::Future {
-        let fut = async move {
-            let res = ws::handshake(req.head()).unwrap().message_body(());
+        assert!(self.was_polled());
 
-            framed
-                .send((res, body::BodySize::None).into())
+        Box::pin(async move {
+            let res = ws::handshake(req.head())?.message_body(())?;
+
+            framed.send((res, BodySize::None).into()).await?;
+
+            let framed = framed.replace_codec(ws::Codec::new());
+
+            ws::Dispatcher::with(framed, service)
                 .await
-                .unwrap();
+                .map_err(|_| WsServiceError::Dispatcher)?;
 
-            Dispatcher::with(framed.replace_codec(ws::Codec::new()), service)
-                .await
-                .map_err(|_| panic!())
-        };
-
-        Box::pin(fut)
+            Ok(())
+        })
     }
 }
 
-async fn service(msg: ws::Frame) -> Result<ws::Message, Error> {
+async fn service(msg: Frame) -> Result<Message, Error> {
     let msg = match msg {
-        ws::Frame::Ping(msg) => ws::Message::Pong(msg),
-        ws::Frame::Text(text) => {
-            ws::Message::Text(String::from_utf8_lossy(&text).into_owned().into())
+        Frame::Ping(msg) => Message::Pong(msg),
+        Frame::Text(text) => {
+            Message::Text(String::from_utf8_lossy(&text).into_owned().into())
         }
-        ws::Frame::Binary(bin) => ws::Message::Binary(bin),
-        ws::Frame::Continuation(item) => ws::Message::Continuation(item),
-        ws::Frame::Close(reason) => ws::Message::Close(reason),
-        _ => panic!(),
+        Frame::Binary(bin) => Message::Binary(bin),
+        Frame::Continuation(item) => Message::Continuation(item),
+        Frame::Close(reason) => Message::Close(reason),
+        _ => return Err(ws::ProtocolError::BadOpCode.into()),
     };
+
     Ok(msg)
 }
 
 #[actix_rt::test]
 async fn test_simple() {
-    let ws_service = WsService::new();
-    let mut srv = test_server({
-        let ws_service = ws_service.clone();
-        move || {
-            let ws_service = ws_service.clone();
-            HttpService::build()
-                .upgrade(fn_factory(move || future::ok::<_, ()>(ws_service.clone())))
-                .finish(|_| future::ok::<_, ()>(Response::not_found()))
-                .tcp()
-        }
+    let mut srv = test_server(|| {
+        HttpService::build()
+            .upgrade(fn_factory(|| async {
+                Ok::<_, Infallible>(WsService::new())
+            }))
+            .finish(|_| async { Ok::<_, Infallible>(Response::not_found()) })
+            .tcp()
     })
     .await;
 
     // client service
     let mut framed = srv.ws().await.unwrap();
-    framed.send(ws::Message::Text("text".into())).await.unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Text(Bytes::from_static(b"text"))
-    );
+    framed.send(Message::Text("text".into())).await.unwrap();
+
+    let item = framed.next().await.unwrap().unwrap();
+    assert_eq!(item, Frame::Text(Bytes::from_static(b"text")));
+
+    framed.send(Message::Binary("text".into())).await.unwrap();
+
+    let item = framed.next().await.unwrap().unwrap();
+    assert_eq!(item, Frame::Binary(Bytes::from_static(&b"text"[..])));
+
+    framed.send(Message::Ping("text".into())).await.unwrap();
+    let item = framed.next().await.unwrap().unwrap();
+    assert_eq!(item, Frame::Pong("text".to_string().into()));
 
     framed
-        .send(ws::Message::Binary("text".into()))
+        .send(Message::Continuation(Item::FirstText("text".into())))
         .await
         .unwrap();
-    let (item, mut framed) = framed.into_future().await;
+    let item = framed.next().await.unwrap().unwrap();
     assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Binary(Bytes::from_static(&b"text"[..]))
-    );
-
-    framed.send(ws::Message::Ping("text".into())).await.unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Pong("text".to_string().into())
-    );
-
-    framed
-        .send(ws::Message::Continuation(ws::Item::FirstText(
-            "text".into(),
-        )))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Continuation(ws::Item::FirstText(Bytes::from_static(b"text")))
+        item,
+        Frame::Continuation(Item::FirstText(Bytes::from_static(b"text")))
     );
 
     assert!(framed
-        .send(ws::Message::Continuation(ws::Item::FirstText(
-            "text".into()
-        )))
+        .send(Message::Continuation(Item::FirstText("text".into())))
         .await
         .is_err());
     assert!(framed
-        .send(ws::Message::Continuation(ws::Item::FirstBinary(
-            "text".into()
-        )))
+        .send(Message::Continuation(Item::FirstBinary("text".into())))
         .await
         .is_err());
 
     framed
-        .send(ws::Message::Continuation(ws::Item::Continue("text".into())))
+        .send(Message::Continuation(Item::Continue("text".into())))
         .await
         .unwrap();
-    let (item, mut framed) = framed.into_future().await;
+    let item = framed.next().await.unwrap().unwrap();
     assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Continuation(ws::Item::Continue(Bytes::from_static(b"text")))
+        item,
+        Frame::Continuation(Item::Continue(Bytes::from_static(b"text")))
     );
 
     framed
-        .send(ws::Message::Continuation(ws::Item::Last("text".into())))
+        .send(Message::Continuation(Item::Last("text".into())))
         .await
         .unwrap();
-    let (item, mut framed) = framed.into_future().await;
+    let item = framed.next().await.unwrap().unwrap();
     assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Continuation(ws::Item::Last(Bytes::from_static(b"text")))
+        item,
+        Frame::Continuation(Item::Last(Bytes::from_static(b"text")))
     );
 
     assert!(framed
-        .send(ws::Message::Continuation(ws::Item::Continue("text".into())))
+        .send(Message::Continuation(Item::Continue("text".into())))
         .await
         .is_err());
 
     assert!(framed
-        .send(ws::Message::Continuation(ws::Item::Last("text".into())))
+        .send(Message::Continuation(Item::Last("text".into())))
         .await
         .is_err());
 
     framed
-        .send(ws::Message::Close(Some(ws::CloseCode::Normal.into())))
+        .send(Message::Close(Some(CloseCode::Normal.into())))
         .await
         .unwrap();
 
-    let (item, _framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Close(Some(ws::CloseCode::Normal.into()))
-    );
-
-    assert!(ws_service.was_polled());
+    let item = framed.next().await.unwrap().unwrap();
+    assert_eq!(item, Frame::Close(Some(CloseCode::Normal.into())));
 }
diff --git a/actix-multipart/CHANGES.md b/actix-multipart/CHANGES.md
index cd50305cb..0b6affa3c 100644
--- a/actix-multipart/CHANGES.md
+++ b/actix-multipart/CHANGES.md
@@ -3,6 +3,10 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 0.4.0-beta.5 - 2021-06-17
+* No notable changes.
+
+
 ## 0.4.0-beta.4 - 2021-04-02
 * No notable changes.
 
diff --git a/actix-multipart/Cargo.toml b/actix-multipart/Cargo.toml
index fd9a8d529..41b0fbae7 100644
--- a/actix-multipart/Cargo.toml
+++ b/actix-multipart/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-multipart"
-version = "0.4.0-beta.4"
+version = "0.4.0-beta.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Multipart form support for Actix Web"
 readme = "README.md"
@@ -16,7 +16,7 @@ name = "actix_multipart"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = { version = "4.0.0-beta.6", default-features = false }
+actix-web = { version = "4.0.0-beta.7", default-features = false }
 actix-utils = "3.0.0"
 
 bytes = "1"
@@ -31,6 +31,6 @@ twoway = "0.2"
 
 [dev-dependencies]
 actix-rt = "2.2"
-actix-http = "3.0.0-beta.6"
+actix-http = "3.0.0-beta.7"
 tokio = { version = "1", features = ["sync"] }
 tokio-stream = "0.1"
diff --git a/actix-multipart/README.md b/actix-multipart/README.md
index 8a4279a62..f6d008fc3 100644
--- a/actix-multipart/README.md
+++ b/actix-multipart/README.md
@@ -3,11 +3,11 @@
 > Multipart form support for Actix Web.
 
 [![crates.io](https://img.shields.io/crates/v/actix-multipart?label=latest)](https://crates.io/crates/actix-multipart)
-[![Documentation](https://docs.rs/actix-multipart/badge.svg?version=0.4.0-beta.4)](https://docs.rs/actix-multipart/0.4.0-beta.4)
+[![Documentation](https://docs.rs/actix-multipart/badge.svg?version=0.4.0-beta.5)](https://docs.rs/actix-multipart/0.4.0-beta.5)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-multipart.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-multipart/0.4.0-beta.4/status.svg)](https://deps.rs/crate/actix-multipart/0.4.0-beta.4)
+[![dependency status](https://deps.rs/crate/actix-multipart/0.4.0-beta.5/status.svg)](https://deps.rs/crate/actix-multipart/0.4.0-beta.5)
 [![Download](https://img.shields.io/crates/d/actix-multipart.svg)](https://crates.io/crates/actix-multipart)
 
 ## Documentation & Resources
diff --git a/actix-test/Cargo.toml b/actix-test/Cargo.toml
index 4c7e89f31..607038377 100644
--- a/actix-test/Cargo.toml
+++ b/actix-test/Cargo.toml
@@ -19,14 +19,14 @@ rustls = ["tls-rustls", "actix-http/rustls"]
 openssl = ["tls-openssl", "actix-http/openssl"]
 
 [dependencies]
-actix-codec = "0.4.0-beta.1"
-actix-http = "3.0.0-beta.6"
+actix-codec = "0.4.0"
+actix-http = "3.0.0-beta.7"
 actix-http-test = { version = "3.0.0-beta.4", features = [] }
 actix-service = "2.0.0"
 actix-utils = "3.0.0"
-actix-web = { version = "4.0.0-beta.6", default-features = false, features = ["cookies"] }
+actix-web = { version = "4.0.0-beta.7", default-features = false, features = ["cookies"] }
 actix-rt = "2.1"
-awc = { version = "3.0.0-beta.5", default-features = false, features = ["cookies"] }
+awc = { version = "3.0.0-beta.6", default-features = false, features = ["cookies"] }
 
 futures-core = { version = "0.3.7", default-features = false, features = ["std"] }
 futures-util = { version = "0.3.7", default-features = false, features = [] }
diff --git a/actix-test/src/lib.rs b/actix-test/src/lib.rs
index 8fab33289..c863af44a 100644
--- a/actix-test/src/lib.rs
+++ b/actix-test/src/lib.rs
@@ -31,7 +31,7 @@ extern crate tls_openssl as openssl;
 #[cfg(feature = "rustls")]
 extern crate tls_rustls as rustls;
 
-use std::{fmt, net, sync::mpsc, thread, time};
+use std::{error::Error as StdError, fmt, net, sync::mpsc, thread, time};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 pub use actix_http::test::TestBuffer;
@@ -39,7 +39,7 @@ use actix_http::{
     http::{HeaderMap, Method},
     ws, HttpService, Request, Response,
 };
-use actix_service::{map_config, IntoServiceFactory, ServiceFactory};
+use actix_service::{map_config, IntoServiceFactory, ServiceFactory, ServiceFactoryExt as _};
 use actix_web::{
     dev::{AppConfig, MessageBody, Server, Service},
     rt, web, Error,
@@ -86,6 +86,7 @@ where
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
     start_with(TestServerConfig::default(), factory)
 }
@@ -125,6 +126,7 @@ where
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
     let (tx, rx) = mpsc::channel();
 
@@ -151,25 +153,40 @@ where
                 HttpVer::Http1 => builder.listen("test", tcp, move || {
                     let app_cfg =
                         AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                     HttpService::build()
                         .client_timeout(timeout)
-                        .h1(map_config(factory(), move |_| app_cfg.clone()))
+                        .h1(map_config(fac, move |_| app_cfg.clone()))
                         .tcp()
                 }),
                 HttpVer::Http2 => builder.listen("test", tcp, move || {
                     let app_cfg =
                         AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                     HttpService::build()
                         .client_timeout(timeout)
-                        .h2(map_config(factory(), move |_| app_cfg.clone()))
+                        .h2(map_config(fac, move |_| app_cfg.clone()))
                         .tcp()
                 }),
                 HttpVer::Both => builder.listen("test", tcp, move || {
                     let app_cfg =
                         AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                     HttpService::build()
                         .client_timeout(timeout)
-                        .finish(map_config(factory(), move |_| app_cfg.clone()))
+                        .finish(map_config(fac, move |_| app_cfg.clone()))
                         .tcp()
                 }),
             },
@@ -178,25 +195,40 @@ where
                 HttpVer::Http1 => builder.listen("test", tcp, move || {
                     let app_cfg =
                         AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                     HttpService::build()
                         .client_timeout(timeout)
-                        .h1(map_config(factory(), move |_| app_cfg.clone()))
+                        .h1(map_config(fac, move |_| app_cfg.clone()))
                         .openssl(acceptor.clone())
                 }),
                 HttpVer::Http2 => builder.listen("test", tcp, move || {
                     let app_cfg =
                         AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                     HttpService::build()
                         .client_timeout(timeout)
-                        .h2(map_config(factory(), move |_| app_cfg.clone()))
+                        .h2(map_config(fac, move |_| app_cfg.clone()))
                         .openssl(acceptor.clone())
                 }),
                 HttpVer::Both => builder.listen("test", tcp, move || {
                     let app_cfg =
                         AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                     HttpService::build()
                         .client_timeout(timeout)
-                        .finish(map_config(factory(), move |_| app_cfg.clone()))
+                        .finish(map_config(fac, move |_| app_cfg.clone()))
                         .openssl(acceptor.clone())
                 }),
             },
@@ -205,25 +237,40 @@ where
                 HttpVer::Http1 => builder.listen("test", tcp, move || {
                     let app_cfg =
                         AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                     HttpService::build()
                         .client_timeout(timeout)
-                        .h1(map_config(factory(), move |_| app_cfg.clone()))
+                        .h1(map_config(fac, move |_| app_cfg.clone()))
                         .rustls(config.clone())
                 }),
                 HttpVer::Http2 => builder.listen("test", tcp, move || {
                     let app_cfg =
                         AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                     HttpService::build()
                         .client_timeout(timeout)
-                        .h2(map_config(factory(), move |_| app_cfg.clone()))
+                        .h2(map_config(fac, move |_| app_cfg.clone()))
                         .rustls(config.clone())
                 }),
                 HttpVer::Both => builder.listen("test", tcp, move || {
                     let app_cfg =
                         AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                     HttpService::build()
                         .client_timeout(timeout)
-                        .finish(map_config(factory(), move |_| app_cfg.clone()))
+                        .finish(map_config(fac, move |_| app_cfg.clone()))
                         .rustls(config.clone())
                 }),
             },
diff --git a/actix-web-actors/CHANGES.md b/actix-web-actors/CHANGES.md
index cd76b201e..a7ee7a9e1 100644
--- a/actix-web-actors/CHANGES.md
+++ b/actix-web-actors/CHANGES.md
@@ -3,6 +3,10 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 4.0.0-beta.5 - 2021-06-17
+* No notable changes.
+
+
 ## 4.0.0-beta.4 - 2021-04-02
 * No notable changes.
 
diff --git a/actix-web-actors/Cargo.toml b/actix-web-actors/Cargo.toml
index ade2795cb..159b10d58 100644
--- a/actix-web-actors/Cargo.toml
+++ b/actix-web-actors/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-web-actors"
-version = "4.0.0-beta.4"
+version = "4.0.0-beta.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix actors support for Actix Web"
 readme = "README.md"
@@ -17,9 +17,9 @@ path = "src/lib.rs"
 
 [dependencies]
 actix = { version = "0.11.0-beta.3", default-features = false }
-actix-codec = "0.4.0-beta.1"
-actix-http = "3.0.0-beta.6"
-actix-web = { version = "4.0.0-beta.6", default-features = false }
+actix-codec = "0.4.0"
+actix-http = "3.0.0-beta.7"
+actix-web = { version = "4.0.0-beta.7", default-features = false }
 
 bytes = "1"
 bytestring = "1"
@@ -31,6 +31,6 @@ tokio = { version = "1", features = ["sync"] }
 actix-rt = "2.2"
 actix-test = "0.1.0-beta.2"
 
-awc = { version = "3.0.0-beta.5", default-features = false }
+awc = { version = "3.0.0-beta.6", default-features = false }
 env_logger = "0.8"
 futures-util = { version = "0.3.7", default-features = false }
diff --git a/actix-web-actors/README.md b/actix-web-actors/README.md
index 2dc779f10..0d926f5ee 100644
--- a/actix-web-actors/README.md
+++ b/actix-web-actors/README.md
@@ -3,11 +3,11 @@
 > Actix actors support for Actix Web.
 
 [![crates.io](https://img.shields.io/crates/v/actix-web-actors?label=latest)](https://crates.io/crates/actix-web-actors)
-[![Documentation](https://docs.rs/actix-web-actors/badge.svg?version=4.0.0-beta.4)](https://docs.rs/actix-web-actors/4.0.0-beta.4)
+[![Documentation](https://docs.rs/actix-web-actors/badge.svg?version=4.0.0-beta.5)](https://docs.rs/actix-web-actors/4.0.0-beta.5)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![License](https://img.shields.io/crates/l/actix-web-actors.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-web-actors/4.0.0-beta.4/status.svg)](https://deps.rs/crate/actix-web-actors/4.0.0-beta.4)
+[![dependency status](https://deps.rs/crate/actix-web-actors/4.0.0-beta.5/status.svg)](https://deps.rs/crate/actix-web-actors/4.0.0-beta.5)
 [![Download](https://img.shields.io/crates/d/actix-web-actors.svg)](https://crates.io/crates/actix-web-actors)
 [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
diff --git a/actix-web-actors/src/ws.rs b/actix-web-actors/src/ws.rs
index 8c575206d..f0a53d4e0 100644
--- a/actix-web-actors/src/ws.rs
+++ b/actix-web-actors/src/ws.rs
@@ -22,10 +22,11 @@ use actix_http::{
     http::HeaderValue,
     ws::{hash_key, Codec},
 };
-use actix_web::error::{Error, PayloadError};
-use actix_web::http::{header, Method, StatusCode};
-use actix_web::HttpResponseBuilder;
-use actix_web::{HttpRequest, HttpResponse};
+use actix_web::{
+    error::{Error, PayloadError},
+    http::{header, Method, StatusCode},
+    HttpRequest, HttpResponse, HttpResponseBuilder,
+};
 use bytes::{Bytes, BytesMut};
 use bytestring::ByteString;
 use futures_core::Stream;
diff --git a/actix-web-codegen/CHANGES.md b/actix-web-codegen/CHANGES.md
index f2c9b44b5..a8a901f72 100644
--- a/actix-web-codegen/CHANGES.md
+++ b/actix-web-codegen/CHANGES.md
@@ -3,6 +3,10 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 0.5.0-beta.3 - 2021-06-17
+* No notable changes.
+
+
 ## 0.5.0-beta.2 - 2021-03-09
 * Preserve doc comments when using route macros. [#2022]
 * Add `name` attribute to `route` macro. [#1934]
diff --git a/actix-web-codegen/Cargo.toml b/actix-web-codegen/Cargo.toml
index db4f8430c..29565f74a 100644
--- a/actix-web-codegen/Cargo.toml
+++ b/actix-web-codegen/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-web-codegen"
-version = "0.5.0-beta.2"
+version = "0.5.0-beta.3"
 description = "Routing and runtime macros for Actix Web"
 readme = "README.md"
 homepage = "https://actix.rs"
@@ -22,7 +22,7 @@ proc-macro2 = "1"
 actix-rt = "2.2"
 actix-test = "0.1.0-beta.2"
 actix-utils = "3.0.0"
-actix-web = "4.0.0-beta.6"
+actix-web = "4.0.0-beta.7"
 
 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
 trybuild = "1"
diff --git a/actix-web-codegen/README.md b/actix-web-codegen/README.md
index 9552d4b56..ef3aa72df 100644
--- a/actix-web-codegen/README.md
+++ b/actix-web-codegen/README.md
@@ -3,11 +3,11 @@
 > Routing and runtime macros for Actix Web.
 
 [![crates.io](https://img.shields.io/crates/v/actix-web-codegen?label=latest)](https://crates.io/crates/actix-web-codegen)
-[![Documentation](https://docs.rs/actix-web-codegen/badge.svg?version=0.5.0-beta.2)](https://docs.rs/actix-web-codegen/0.5.0-beta.2)
+[![Documentation](https://docs.rs/actix-web-codegen/badge.svg?version=0.5.0-beta.3)](https://docs.rs/actix-web-codegen/0.5.0-beta.3)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![License](https://img.shields.io/crates/l/actix-web-codegen.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.2/status.svg)](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.2)
+[![dependency status](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.3/status.svg)](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.3)
 [![Download](https://img.shields.io/crates/d/actix-web-codegen.svg)](https://crates.io/crates/actix-web-codegen)
 [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
diff --git a/actix-web-codegen/src/lib.rs b/actix-web-codegen/src/lib.rs
index 336345014..2237f422c 100644
--- a/actix-web-codegen/src/lib.rs
+++ b/actix-web-codegen/src/lib.rs
@@ -171,27 +171,10 @@ method_macro! {
 #[proc_macro_attribute]
 pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
     use quote::quote;
-
-    let mut input = syn::parse_macro_input!(item as syn::ItemFn);
-    let attrs = &input.attrs;
-    let vis = &input.vis;
-    let sig = &mut input.sig;
-    let body = &input.block;
-
-    if sig.asyncness.is_none() {
-        return syn::Error::new_spanned(sig.fn_token, "only async fn is supported")
-            .to_compile_error()
-            .into();
-    }
-
-    sig.asyncness = None;
-
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
     (quote! {
-        #(#attrs)*
-        #vis #sig {
-            actix_web::rt::System::new()
-                .block_on(async move { #body })
-        }
+        #[actix_web::rt::main(system = "::actix_web::rt::System")]
+        #input
     })
     .into()
 }
diff --git a/actix-web-codegen/tests/trybuild.rs b/actix-web-codegen/tests/trybuild.rs
index afbe7b728..12e848cf3 100644
--- a/actix-web-codegen/tests/trybuild.rs
+++ b/actix-web-codegen/tests/trybuild.rs
@@ -1,3 +1,4 @@
+#[rustversion::stable(1.46)] // MSRV
 #[test]
 fn compile_macros() {
     let t = trybuild::TestCases::new();
@@ -12,11 +13,3 @@ fn compile_macros() {
 
     t.pass("tests/trybuild/docstring-ok.rs");
 }
-
-// #[rustversion::not(nightly)]
-// fn skip_on_nightly(t: &trybuild::TestCases) {
-//
-// }
-
-// #[rustversion::nightly]
-// fn skip_on_nightly(_t: &trybuild::TestCases) {}
diff --git a/awc/CHANGES.md b/awc/CHANGES.md
index b2e0ff78d..2e56eb958 100644
--- a/awc/CHANGES.md
+++ b/awc/CHANGES.md
@@ -1,6 +1,14 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+### Changed
+* Change compression algorithm features flags. [#2250]
+
+[#2250]: https://github.com/actix/actix-web/pull/2250
+
+
+## 3.0.0-beta.6 - 2021-06-17
+* No significant changes since 3.0.0-beta.5.
 
 
 ## 3.0.0-beta.5 - 2021-04-17
diff --git a/awc/Cargo.toml b/awc/Cargo.toml
index 5591048bc..7d6ee52c4 100644
--- a/awc/Cargo.toml
+++ b/awc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "awc"
-version = "3.0.0-beta.5"
+version = "3.0.0-beta.6"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "fakeshadow <24548779@qq.com>",
@@ -24,10 +24,10 @@ path = "src/lib.rs"
 
 [package.metadata.docs.rs]
 # features that docs.rs will build with
-features = ["openssl", "rustls", "compress", "cookies"]
+features = ["openssl", "rustls", "compress-brotli", "compress-gzip", "compress-zstd", "cookies"]
 
 [features]
-default = ["compress", "cookies"]
+default = ["compress-brotli", "compress-gzip", "compress-zstd", "cookies"]
 
 # openssl
 openssl = ["tls-openssl", "actix-http/openssl"]
@@ -35,8 +35,12 @@ openssl = ["tls-openssl", "actix-http/openssl"]
 # rustls
 rustls = ["tls-rustls", "actix-http/rustls"]
 
-# content-encoding support
-compress = ["actix-http/compress"]
+# Brotli algorithm content-encoding support
+compress-brotli = ["actix-http/compress-brotli", "__compress"]
+# Gzip and deflate algorithms content-encoding support
+compress-gzip = ["actix-http/compress-gzip", "__compress"]
+# Zstd algorithm content-encoding support
+compress-zstd = ["actix-http/compress-zstd", "__compress"]
 
 # cookie parsing and cookie jar
 cookies = ["cookie"]
@@ -44,14 +48,19 @@ cookies = ["cookie"]
 # trust-dns as dns resolver
 trust-dns = ["actix-http/trust-dns"]
 
+# Internal (PRIVATE!) features used to aid testing and cheking feature status.
+# Don't rely on these whatsoever. They may disappear at anytime.
+__compress = []
+
 [dependencies]
-actix-codec = "0.4.0-beta.1"
+actix-codec = "0.4.0"
 actix-service = "2.0.0"
-actix-http = "3.0.0-beta.6"
+actix-http = "3.0.0-beta.7"
 actix-rt = { version = "2.1", default-features = false }
 
 base64 = "0.13"
 bytes = "1"
+cfg-if = "1"
 cookie = { version = "0.15", features = ["percent-encode"], optional = true }
 derive_more = "0.99.5"
 futures-core = { version = "0.3.7", default-features = false }
@@ -68,8 +77,8 @@ tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
 tls-rustls = { version = "0.19.0", package = "rustls", optional = true, features = ["dangerous_configuration"] }
 
 [dev-dependencies]
-actix-web = { version = "4.0.0-beta.6", features = ["openssl"] }
-actix-http = { version = "3.0.0-beta.6", features = ["openssl"] }
+actix-web = { version = "4.0.0-beta.7", features = ["openssl"] }
+actix-http = { version = "3.0.0-beta.7", features = ["openssl"] }
 actix-http-test = { version = "3.0.0-beta.4", features = ["openssl"] }
 actix-utils = "3.0.0"
 actix-server = "2.0.0-beta.3"
diff --git a/awc/README.md b/awc/README.md
index a836a2497..5076c59a4 100644
--- a/awc/README.md
+++ b/awc/README.md
@@ -3,9 +3,9 @@
 > Async HTTP and WebSocket client library.
 
 [![crates.io](https://img.shields.io/crates/v/awc?label=latest)](https://crates.io/crates/awc)
-[![Documentation](https://docs.rs/awc/badge.svg?version=3.0.0-beta.4)](https://docs.rs/awc/3.0.0-beta.4)
+[![Documentation](https://docs.rs/awc/badge.svg?version=3.0.0-beta.6)](https://docs.rs/awc/3.0.0-beta.6)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/awc)
-[![Dependency Status](https://deps.rs/crate/awc/3.0.0-beta.4/status.svg)](https://deps.rs/crate/awc/3.0.0-beta.4)
+[![Dependency Status](https://deps.rs/crate/awc/3.0.0-beta.6/status.svg)](https://deps.rs/crate/awc/3.0.0-beta.6)
 [![Join the chat at https://gitter.im/actix/actix-web](https://badges.gitter.im/actix/actix-web.svg)](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Documentation & Resources
diff --git a/awc/examples/client.rs b/awc/examples/client.rs
index b9574590d..653cb226f 100644
--- a/awc/examples/client.rs
+++ b/awc/examples/client.rs
@@ -1,18 +1,20 @@
-use actix_http::Error;
+use std::error::Error as StdError;
 
 #[actix_web::main]
-async fn main() -> Result<(), Error> {
-    std::env::set_var("RUST_LOG", "actix_http=trace");
+async fn main() -> Result<(), Box<dyn StdError>> {
+    std::env::set_var("RUST_LOG", "client=trace,awc=trace,actix_http=trace");
     env_logger::init();
 
     let client = awc::Client::new();
 
     // Create request builder, configure request and send
-    let mut response = client
+    let request = client
         .get("https://www.rust-lang.org/")
-        .append_header(("User-Agent", "Actix-web"))
-        .send()
-        .await?;
+        .append_header(("User-Agent", "Actix-web"));
+
+    println!("Request: {:?}", request);
+
+    let mut response = request.send().await?;
 
     // server http response
     println!("Response: {:?}", response);
diff --git a/awc/src/error.rs b/awc/src/error.rs
index b715f6213..c83c5ebbf 100644
--- a/awc/src/error.rs
+++ b/awc/src/error.rs
@@ -6,7 +6,6 @@ pub use actix_http::http::Error as HttpError;
 pub use actix_http::ws::HandshakeError as WsHandshakeError;
 pub use actix_http::ws::ProtocolError as WsProtocolError;
 
-use actix_http::ResponseError;
 use serde_json::error::Error as JsonError;
 
 use actix_http::http::{header::HeaderValue, StatusCode};
@@ -77,6 +76,3 @@ pub enum JsonPayloadError {
 }
 
 impl std::error::Error for JsonPayloadError {}
-
-/// Return `InternalServerError` for `JsonPayloadError`
-impl ResponseError for JsonPayloadError {}
diff --git a/awc/src/frozen.rs b/awc/src/frozen.rs
index 5fe8edb19..cb8c0f1bf 100644
--- a/awc/src/frozen.rs
+++ b/awc/src/frozen.rs
@@ -1,21 +1,21 @@
-use std::convert::TryFrom;
-use std::net;
-use std::rc::Rc;
-use std::time::Duration;
+use std::{convert::TryFrom, error::Error as StdError, net, rc::Rc, time::Duration};
 
 use bytes::Bytes;
 use futures_core::Stream;
 use serde::Serialize;
 
-use actix_http::body::Body;
-use actix_http::http::header::IntoHeaderValue;
-use actix_http::http::{Error as HttpError, HeaderMap, HeaderName, Method, Uri};
-use actix_http::{Error, RequestHead};
+use actix_http::{
+    body::Body,
+    http::{header::IntoHeaderValue, Error as HttpError, HeaderMap, HeaderName, Method, Uri},
+    RequestHead,
+};
 
-use crate::sender::{RequestSender, SendClientRequest};
-use crate::ClientConfig;
+use crate::{
+    sender::{RequestSender, SendClientRequest},
+    ClientConfig,
+};
 
-/// `FrozenClientRequest` struct represents clonable client request.
+/// `FrozenClientRequest` struct represents cloneable client request.
 /// It could be used to send same request multiple times.
 #[derive(Clone)]
 pub struct FrozenClientRequest {
@@ -82,7 +82,7 @@ impl FrozenClientRequest {
     pub fn send_stream<S, E>(&self, stream: S) -> SendClientRequest
     where
         S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-        E: Into<Error> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
     {
         RequestSender::Rc(self.head.clone(), None).send_stream(
             self.addr,
@@ -207,7 +207,7 @@ impl FrozenSendBuilder {
     pub fn send_stream<S, E>(self, stream: S) -> SendClientRequest
     where
         S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-        E: Into<Error> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
     {
         if let Some(e) = self.err {
             return e.into();
diff --git a/awc/src/lib.rs b/awc/src/lib.rs
index 562d6ee7f..c0290ddcf 100644
--- a/awc/src/lib.rs
+++ b/awc/src/lib.rs
@@ -1,7 +1,6 @@
 //! `awc` is a HTTP and WebSocket client library built on the Actix ecosystem.
 //!
-//! ## Making a GET request
-//!
+//! # Making a GET request
 //! ```no_run
 //! # #[actix_rt::main]
 //! # async fn main() -> Result<(), awc::error::SendRequestError> {
@@ -16,10 +15,8 @@
 //! # }
 //! ```
 //!
-//! ## Making POST requests
-//!
-//! ### Raw body contents
-//!
+//! # Making POST requests
+//! ## Raw body contents
 //! ```no_run
 //! # #[actix_rt::main]
 //! # async fn main() -> Result<(), awc::error::SendRequestError> {
@@ -31,8 +28,7 @@
 //! # }
 //! ```
 //!
-//! ### Forms
-//!
+//! ## Forms
 //! ```no_run
 //! # #[actix_rt::main]
 //! # async fn main() -> Result<(), awc::error::SendRequestError> {
@@ -46,8 +42,7 @@
 //! # }
 //! ```
 //!
-//! ### JSON
-//!
+//! ## JSON
 //! ```no_run
 //! # #[actix_rt::main]
 //! # async fn main() -> Result<(), awc::error::SendRequestError> {
@@ -64,8 +59,24 @@
 //! # }
 //! ```
 //!
-//! ## WebSocket support
+//! # Response Compression
+//! All [official][iana-encodings] and common content encoding codecs are supported, optionally.
 //!
+//! The `Accept-Encoding` header will automatically be populated with enabled codecs and added to
+//! outgoing requests, allowing servers to select their `Content-Encoding` accordingly.
+//!
+//! Feature flags enable these codecs according to the table below. By default, all `compress-*`
+//! features are enabled.
+//!
+//! | Feature           | Codecs        |
+//! | ----------------- | ------------- |
+//! | `compress-brotli` | brotli        |
+//! | `compress-gzip`   | gzip, deflate |
+//! | `compress-zstd`   | zstd          |
+//!
+//! [iana-encodings]: https://www.iana.org/assignments/http-parameters/http-parameters.xhtml#content-coding
+//!
+//! # WebSocket support
 //! ```no_run
 //! # #[actix_rt::main]
 //! # async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -128,8 +139,10 @@ pub use self::sender::SendClientRequest;
 
 /// An asynchronous HTTP and WebSocket client.
 ///
-/// ## Examples
+/// You should take care to create, at most, one `Client` per thread. Otherwise, expect higher CPU
+/// and memory usage.
 ///
+/// # Examples
 /// ```
 /// use awc::Client;
 ///
@@ -137,10 +150,10 @@ pub use self::sender::SendClientRequest;
 /// async fn main() {
 ///     let mut client = Client::default();
 ///
-///     let res = client.get("http://www.rust-lang.org") // <- Create request builder
-///         .insert_header(("User-Agent", "Actix-web"))
-///         .send()                             // <- Send HTTP request
-///         .await;                             // <- send request and wait for response
+///     let res = client.get("http://www.rust-lang.org")
+///         .insert_header(("User-Agent", "my-app/1.2"))
+///         .send()
+///         .await;
 ///
 ///      println!("Response: {:?}", res);
 /// }
diff --git a/awc/src/request.rs b/awc/src/request.rs
index 483524102..46dae7fa3 100644
--- a/awc/src/request.rs
+++ b/awc/src/request.rs
@@ -1,30 +1,26 @@
-use std::convert::TryFrom;
-use std::rc::Rc;
-use std::time::Duration;
-use std::{fmt, net};
+use std::{convert::TryFrom, error::Error as StdError, fmt, net, rc::Rc, time::Duration};
 
 use bytes::Bytes;
 use futures_core::Stream;
 use serde::Serialize;
 
-use actix_http::body::Body;
-use actix_http::http::header::{self, IntoHeaderPair};
-use actix_http::http::{
-    uri, ConnectionType, Error as HttpError, HeaderMap, HeaderValue, Method, Uri, Version,
+use actix_http::{
+    body::Body,
+    http::{
+        header::{self, IntoHeaderPair},
+        ConnectionType, Error as HttpError, HeaderMap, HeaderValue, Method, Uri, Version,
+    },
+    RequestHead,
 };
-use actix_http::{Error, RequestHead};
 
 #[cfg(feature = "cookies")]
 use crate::cookie::{Cookie, CookieJar};
-use crate::error::{FreezeRequestError, InvalidUrl};
-use crate::frozen::FrozenClientRequest;
-use crate::sender::{PrepForSendingError, RequestSender, SendClientRequest};
-use crate::ClientConfig;
-
-#[cfg(feature = "compress")]
-const HTTPS_ENCODING: &str = "br, gzip, deflate";
-#[cfg(not(feature = "compress"))]
-const HTTPS_ENCODING: &str = "br";
+use crate::{
+    error::{FreezeRequestError, InvalidUrl},
+    frozen::FrozenClientRequest,
+    sender::{PrepForSendingError, RequestSender, SendClientRequest},
+    ClientConfig,
+};
 
 /// An HTTP Client request builder
 ///
@@ -408,7 +404,7 @@ impl ClientRequest {
     pub fn send_stream<S, E>(self, stream: S) -> SendClientRequest
     where
         S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-        E: Into<Error> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
     {
         let slf = match self.prep_for_sending() {
             Ok(slf) => slf,
@@ -479,22 +475,37 @@ impl ClientRequest {
 
         let mut slf = self;
 
+        // Set Accept-Encoding HTTP header depending on enabled feature.
+        // If decompress is not ask, then we are not able to find which encoding is
+        // supported, so we cannot guess Accept-Encoding HTTP header.
         if slf.response_decompress {
-            let https = slf
-                .head
-                .uri
-                .scheme()
-                .map(|s| s == &uri::Scheme::HTTPS)
-                .unwrap_or(true);
+            // Set Accept-Encoding with compression algorithm awc is built with.
+            #[cfg(feature = "__compress")]
+            let accept_encoding = {
+                let mut encoding = vec![];
 
-            if https {
-                slf = slf.insert_header_if_none((header::ACCEPT_ENCODING, HTTPS_ENCODING));
-            } else {
-                #[cfg(feature = "compress")]
+                #[cfg(feature = "compress-brotli")]
+                encoding.push("br");
+
+                #[cfg(feature = "compress-gzip")]
                 {
-                    slf = slf.insert_header_if_none((header::ACCEPT_ENCODING, "gzip, deflate"));
+                    encoding.push("gzip");
+                    encoding.push("deflate");
                 }
+
+                #[cfg(feature = "compress-zstd")]
+                encoding.push("zstd");
+
+                assert!(!encoding.is_empty(), "encoding cannot be empty unless __compress feature has been explictily enabled.");
+                encoding.join(", ")
             };
+
+            // Otherwise tell the server, we do not support any compression algorithm.
+            // So we clearly indicate that we do want identity encoding.
+            #[cfg(not(feature = "__compress"))]
+            let accept_encoding = "identity";
+
+            slf = slf.insert_header_if_none((header::ACCEPT_ENCODING, accept_encoding));
         }
 
         Ok(slf)
diff --git a/awc/src/sender.rs b/awc/src/sender.rs
index 0e63be221..c0639606e 100644
--- a/awc/src/sender.rs
+++ b/awc/src/sender.rs
@@ -1,6 +1,7 @@
 use std::{
+    error::Error as StdError,
     future::Future,
-    io, net,
+    net,
     pin::Pin,
     rc::Rc,
     task::{Context, Poll},
@@ -21,25 +22,33 @@ use derive_more::From;
 use futures_core::Stream;
 use serde::Serialize;
 
-#[cfg(feature = "compress")]
+#[cfg(feature = "__compress")]
 use actix_http::{encoding::Decoder, http::header::ContentEncoding, Payload, PayloadStream};
 
-use crate::connect::{ConnectRequest, ConnectResponse};
-use crate::error::{FreezeRequestError, InvalidUrl, SendRequestError};
-use crate::response::ClientResponse;
-use crate::ClientConfig;
+use crate::{
+    error::{FreezeRequestError, InvalidUrl, SendRequestError},
+    ClientConfig, ClientResponse, ConnectRequest, ConnectResponse,
+};
 
 #[derive(Debug, From)]
 pub(crate) enum PrepForSendingError {
     Url(InvalidUrl),
     Http(HttpError),
+    Json(serde_json::Error),
+    Form(serde_urlencoded::ser::Error),
 }
 
 impl From<PrepForSendingError> for FreezeRequestError {
     fn from(err: PrepForSendingError) -> FreezeRequestError {
         match err {
-            PrepForSendingError::Url(e) => FreezeRequestError::Url(e),
-            PrepForSendingError::Http(e) => FreezeRequestError::Http(e),
+            PrepForSendingError::Url(err) => FreezeRequestError::Url(err),
+            PrepForSendingError::Http(err) => FreezeRequestError::Http(err),
+            PrepForSendingError::Json(err) => {
+                FreezeRequestError::Custom(Box::new(err), Box::new("json serialization error"))
+            }
+            PrepForSendingError::Form(err) => {
+                FreezeRequestError::Custom(Box::new(err), Box::new("form serialization error"))
+            }
         }
     }
 }
@@ -49,6 +58,12 @@ impl From<PrepForSendingError> for SendRequestError {
         match err {
             PrepForSendingError::Url(e) => SendRequestError::Url(e),
             PrepForSendingError::Http(e) => SendRequestError::Http(e),
+            PrepForSendingError::Json(err) => {
+                SendRequestError::Custom(Box::new(err), Box::new("json serialization error"))
+            }
+            PrepForSendingError::Form(err) => {
+                SendRequestError::Custom(Box::new(err), Box::new("form serialization error"))
+            }
         }
     }
 }
@@ -76,7 +91,7 @@ impl SendClientRequest {
     }
 }
 
-#[cfg(feature = "compress")]
+#[cfg(feature = "__compress")]
 impl Future for SendClientRequest {
     type Output = Result<ClientResponse<Decoder<Payload<PayloadStream>>>, SendRequestError>;
 
@@ -116,7 +131,7 @@ impl Future for SendClientRequest {
     }
 }
 
-#[cfg(not(feature = "compress"))]
+#[cfg(not(feature = "__compress"))]
 impl Future for SendClientRequest {
     type Output = Result<ClientResponse, SendRequestError>;
 
@@ -209,8 +224,7 @@ impl RequestSender {
     ) -> SendClientRequest {
         let body = match serde_json::to_string(value) {
             Ok(body) => body,
-            // TODO: own error type
-            Err(e) => return Error::from(io::Error::new(io::ErrorKind::Other, e)).into(),
+            Err(err) => return PrepForSendingError::Json(err).into(),
         };
 
         if let Err(e) = self.set_header_if_none(header::CONTENT_TYPE, "application/json") {
@@ -236,8 +250,7 @@ impl RequestSender {
     ) -> SendClientRequest {
         let body = match serde_urlencoded::to_string(value) {
             Ok(body) => body,
-            // TODO: own error type
-            Err(e) => return Error::from(io::Error::new(io::ErrorKind::Other, e)).into(),
+            Err(err) => return PrepForSendingError::Form(err).into(),
         };
 
         // set content-type
@@ -266,7 +279,7 @@ impl RequestSender {
     ) -> SendClientRequest
     where
         S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-        E: Into<Error> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
     {
         self.send_body(
             addr,
diff --git a/benches/server.rs b/benches/server.rs
index c6695817f..139e24abd 100644
--- a/benches/server.rs
+++ b/benches/server.rs
@@ -1,4 +1,4 @@
-use actix_web::{test, web, App, HttpResponse};
+use actix_web::{web, App, HttpResponse};
 use awc::Client;
 use criterion::{criterion_group, criterion_main, Criterion};
 use futures_util::future::join_all;
diff --git a/src/app_service.rs b/src/app_service.rs
index 32c779a32..ca6f36202 100644
--- a/src/app_service.rs
+++ b/src/app_service.rs
@@ -166,8 +166,7 @@ impl AppInitServiceState {
         Rc::new(AppInitServiceState {
             rmap,
             config,
-            // TODO: AppConfig can be used to pass user defined HttpRequestPool
-            // capacity.
+            // TODO: AppConfig can be used to pass user defined HttpRequestPool capacity.
             pool: HttpRequestPool::default(),
         })
     }
diff --git a/src/data.rs b/src/data.rs
index bd9b88301..f09a88891 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -1,16 +1,14 @@
-use std::any::type_name;
-use std::ops::Deref;
-use std::sync::Arc;
+use std::{any::type_name, ops::Deref, sync::Arc};
 
-use actix_http::error::{Error, ErrorInternalServerError};
 use actix_http::Extensions;
 use actix_utils::future::{err, ok, Ready};
 use futures_core::future::LocalBoxFuture;
 use serde::Serialize;
 
-use crate::dev::Payload;
-use crate::extract::FromRequest;
-use crate::request::HttpRequest;
+use crate::{
+    dev::Payload, error::ErrorInternalServerError, extract::FromRequest, request::HttpRequest,
+    Error,
+};
 
 /// Data factory.
 pub(crate) trait DataFactory {
diff --git a/src/error/error.rs b/src/error/error.rs
new file mode 100644
index 000000000..add290867
--- /dev/null
+++ b/src/error/error.rs
@@ -0,0 +1,76 @@
+use std::{error::Error as StdError, fmt};
+
+use actix_http::{body::AnyBody, Response};
+
+use crate::{HttpResponse, ResponseError};
+
+/// General purpose actix web error.
+///
+/// An actix web error is used to carry errors from `std::error`
+/// through actix in a convenient way.  It can be created through
+/// converting errors with `into()`.
+///
+/// Whenever it is created from an external object a response error is created
+/// for it that can be used to create an HTTP response from it this means that
+/// if you have access to an actix `Error` you can always get a
+/// `ResponseError` reference from it.
+pub struct Error {
+    cause: Box<dyn ResponseError>,
+}
+
+impl Error {
+    /// Returns the reference to the underlying `ResponseError`.
+    pub fn as_response_error(&self) -> &dyn ResponseError {
+        self.cause.as_ref()
+    }
+
+    /// Similar to `as_response_error` but downcasts.
+    pub fn as_error<T: ResponseError + 'static>(&self) -> Option<&T> {
+        <dyn ResponseError>::downcast_ref(self.cause.as_ref())
+    }
+
+    /// Shortcut for creating an `HttpResponse`.
+    pub fn error_response(&self) -> HttpResponse {
+        self.cause.error_response()
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.cause, f)
+    }
+}
+
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", &self.cause)
+    }
+}
+
+impl StdError for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        // TODO: populate if replacement for Box<dyn Error> is found
+        None
+    }
+}
+
+impl From<std::convert::Infallible> for Error {
+    fn from(val: std::convert::Infallible) -> Self {
+        match val {}
+    }
+}
+
+/// `Error` for any error that implements `ResponseError`
+impl<T: ResponseError + 'static> From<T> for Error {
+    fn from(err: T) -> Error {
+        Error {
+            cause: Box::new(err),
+        }
+    }
+}
+
+impl From<Error> for Response<AnyBody> {
+    fn from(err: Error) -> Response<AnyBody> {
+        err.error_response().into()
+    }
+}
diff --git a/src/error/internal.rs b/src/error/internal.rs
new file mode 100644
index 000000000..1d9ca904e
--- /dev/null
+++ b/src/error/internal.rs
@@ -0,0 +1,313 @@
+use std::{cell::RefCell, fmt, io::Write as _};
+
+use actix_http::{body::Body, header, StatusCode};
+use bytes::{BufMut as _, BytesMut};
+
+use crate::{Error, HttpRequest, HttpResponse, Responder, ResponseError};
+
+/// Wraps errors to alter the generated response status code.
+///
+/// In following example, the `io::Error` is wrapped into `ErrorBadRequest` which will generate a
+/// response with the 400 Bad Request status code instead of the usual status code generated by
+/// an `io::Error`.
+///
+/// # Examples
+/// ```
+/// # use std::io;
+/// # use actix_web::{error, HttpRequest};
+/// async fn handler_error() -> Result<String, actix_web::Error> {
+///     let err = io::Error::new(io::ErrorKind::Other, "error");
+///     Err(error::ErrorBadRequest(err))
+/// }
+/// ```
+pub struct InternalError<T> {
+    cause: T,
+    status: InternalErrorType,
+}
+
+enum InternalErrorType {
+    Status(StatusCode),
+    Response(RefCell<Option<HttpResponse>>),
+}
+
+impl<T> InternalError<T> {
+    /// Constructs an `InternalError` with given status code.
+    pub fn new(cause: T, status: StatusCode) -> Self {
+        InternalError {
+            cause,
+            status: InternalErrorType::Status(status),
+        }
+    }
+
+    /// Constructs an `InternalError` with pre-defined response.
+    pub fn from_response(cause: T, response: HttpResponse) -> Self {
+        InternalError {
+            cause,
+            status: InternalErrorType::Response(RefCell::new(Some(response))),
+        }
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for InternalError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.cause.fmt(f)
+    }
+}
+
+impl<T: fmt::Display> fmt::Display for InternalError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.cause.fmt(f)
+    }
+}
+
+impl<T> ResponseError for InternalError<T>
+where
+    T: fmt::Debug + fmt::Display,
+{
+    fn status_code(&self) -> StatusCode {
+        match self.status {
+            InternalErrorType::Status(st) => st,
+            InternalErrorType::Response(ref resp) => {
+                if let Some(resp) = resp.borrow().as_ref() {
+                    resp.head().status
+                } else {
+                    StatusCode::INTERNAL_SERVER_ERROR
+                }
+            }
+        }
+    }
+
+    fn error_response(&self) -> HttpResponse {
+        match self.status {
+            InternalErrorType::Status(status) => {
+                let mut res = HttpResponse::new(status);
+                let mut buf = BytesMut::new().writer();
+                let _ = write!(buf, "{}", self);
+
+                res.headers_mut().insert(
+                    header::CONTENT_TYPE,
+                    header::HeaderValue::from_static("text/plain; charset=utf-8"),
+                );
+                res.set_body(Body::from(buf.into_inner()))
+            }
+
+            InternalErrorType::Response(ref resp) => {
+                if let Some(resp) = resp.borrow_mut().take() {
+                    resp
+                } else {
+                    HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR)
+                }
+            }
+        }
+    }
+}
+
+impl<T> Responder for InternalError<T>
+where
+    T: fmt::Debug + fmt::Display + 'static,
+{
+    fn respond_to(self, _: &HttpRequest) -> HttpResponse {
+        HttpResponse::from_error(self)
+    }
+}
+
+macro_rules! error_helper {
+    ($name:ident, $status:ident) => {
+        paste::paste! {
+            #[doc = "Helper function that wraps any error and generates a `" $status "` response."]
+            #[allow(non_snake_case)]
+            pub fn $name<T>(err: T) -> Error
+            where
+                T: fmt::Debug + fmt::Display + 'static,
+            {
+                InternalError::new(err, StatusCode::$status).into()
+            }
+        }
+    }
+}
+
+error_helper!(ErrorBadRequest, BAD_REQUEST);
+error_helper!(ErrorUnauthorized, UNAUTHORIZED);
+error_helper!(ErrorPaymentRequired, PAYMENT_REQUIRED);
+error_helper!(ErrorForbidden, FORBIDDEN);
+error_helper!(ErrorNotFound, NOT_FOUND);
+error_helper!(ErrorMethodNotAllowed, METHOD_NOT_ALLOWED);
+error_helper!(ErrorNotAcceptable, NOT_ACCEPTABLE);
+error_helper!(
+    ErrorProxyAuthenticationRequired,
+    PROXY_AUTHENTICATION_REQUIRED
+);
+error_helper!(ErrorRequestTimeout, REQUEST_TIMEOUT);
+error_helper!(ErrorConflict, CONFLICT);
+error_helper!(ErrorGone, GONE);
+error_helper!(ErrorLengthRequired, LENGTH_REQUIRED);
+error_helper!(ErrorPayloadTooLarge, PAYLOAD_TOO_LARGE);
+error_helper!(ErrorUriTooLong, URI_TOO_LONG);
+error_helper!(ErrorUnsupportedMediaType, UNSUPPORTED_MEDIA_TYPE);
+error_helper!(ErrorRangeNotSatisfiable, RANGE_NOT_SATISFIABLE);
+error_helper!(ErrorImATeapot, IM_A_TEAPOT);
+error_helper!(ErrorMisdirectedRequest, MISDIRECTED_REQUEST);
+error_helper!(ErrorUnprocessableEntity, UNPROCESSABLE_ENTITY);
+error_helper!(ErrorLocked, LOCKED);
+error_helper!(ErrorFailedDependency, FAILED_DEPENDENCY);
+error_helper!(ErrorUpgradeRequired, UPGRADE_REQUIRED);
+error_helper!(ErrorPreconditionFailed, PRECONDITION_FAILED);
+error_helper!(ErrorPreconditionRequired, PRECONDITION_REQUIRED);
+error_helper!(ErrorTooManyRequests, TOO_MANY_REQUESTS);
+error_helper!(
+    ErrorRequestHeaderFieldsTooLarge,
+    REQUEST_HEADER_FIELDS_TOO_LARGE
+);
+error_helper!(
+    ErrorUnavailableForLegalReasons,
+    UNAVAILABLE_FOR_LEGAL_REASONS
+);
+error_helper!(ErrorExpectationFailed, EXPECTATION_FAILED);
+error_helper!(ErrorInternalServerError, INTERNAL_SERVER_ERROR);
+error_helper!(ErrorNotImplemented, NOT_IMPLEMENTED);
+error_helper!(ErrorBadGateway, BAD_GATEWAY);
+error_helper!(ErrorServiceUnavailable, SERVICE_UNAVAILABLE);
+error_helper!(ErrorGatewayTimeout, GATEWAY_TIMEOUT);
+error_helper!(ErrorHttpVersionNotSupported, HTTP_VERSION_NOT_SUPPORTED);
+error_helper!(ErrorVariantAlsoNegotiates, VARIANT_ALSO_NEGOTIATES);
+error_helper!(ErrorInsufficientStorage, INSUFFICIENT_STORAGE);
+error_helper!(ErrorLoopDetected, LOOP_DETECTED);
+error_helper!(ErrorNotExtended, NOT_EXTENDED);
+error_helper!(
+    ErrorNetworkAuthenticationRequired,
+    NETWORK_AUTHENTICATION_REQUIRED
+);
+
+#[cfg(test)]
+mod tests {
+    use actix_http::error::ParseError;
+
+    use super::*;
+
+    #[test]
+    fn test_internal_error() {
+        let err = InternalError::from_response(ParseError::Method, HttpResponse::Ok().finish());
+        let resp: HttpResponse = err.error_response();
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+
+    #[test]
+    fn test_error_helpers() {
+        let res: HttpResponse = ErrorBadRequest("err").into();
+        assert_eq!(res.status(), StatusCode::BAD_REQUEST);
+
+        let res: HttpResponse = ErrorUnauthorized("err").into();
+        assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
+
+        let res: HttpResponse = ErrorPaymentRequired("err").into();
+        assert_eq!(res.status(), StatusCode::PAYMENT_REQUIRED);
+
+        let res: HttpResponse = ErrorForbidden("err").into();
+        assert_eq!(res.status(), StatusCode::FORBIDDEN);
+
+        let res: HttpResponse = ErrorNotFound("err").into();
+        assert_eq!(res.status(), StatusCode::NOT_FOUND);
+
+        let res: HttpResponse = ErrorMethodNotAllowed("err").into();
+        assert_eq!(res.status(), StatusCode::METHOD_NOT_ALLOWED);
+
+        let res: HttpResponse = ErrorNotAcceptable("err").into();
+        assert_eq!(res.status(), StatusCode::NOT_ACCEPTABLE);
+
+        let res: HttpResponse = ErrorProxyAuthenticationRequired("err").into();
+        assert_eq!(res.status(), StatusCode::PROXY_AUTHENTICATION_REQUIRED);
+
+        let res: HttpResponse = ErrorRequestTimeout("err").into();
+        assert_eq!(res.status(), StatusCode::REQUEST_TIMEOUT);
+
+        let res: HttpResponse = ErrorConflict("err").into();
+        assert_eq!(res.status(), StatusCode::CONFLICT);
+
+        let res: HttpResponse = ErrorGone("err").into();
+        assert_eq!(res.status(), StatusCode::GONE);
+
+        let res: HttpResponse = ErrorLengthRequired("err").into();
+        assert_eq!(res.status(), StatusCode::LENGTH_REQUIRED);
+
+        let res: HttpResponse = ErrorPreconditionFailed("err").into();
+        assert_eq!(res.status(), StatusCode::PRECONDITION_FAILED);
+
+        let res: HttpResponse = ErrorPayloadTooLarge("err").into();
+        assert_eq!(res.status(), StatusCode::PAYLOAD_TOO_LARGE);
+
+        let res: HttpResponse = ErrorUriTooLong("err").into();
+        assert_eq!(res.status(), StatusCode::URI_TOO_LONG);
+
+        let res: HttpResponse = ErrorUnsupportedMediaType("err").into();
+        assert_eq!(res.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
+
+        let res: HttpResponse = ErrorRangeNotSatisfiable("err").into();
+        assert_eq!(res.status(), StatusCode::RANGE_NOT_SATISFIABLE);
+
+        let res: HttpResponse = ErrorExpectationFailed("err").into();
+        assert_eq!(res.status(), StatusCode::EXPECTATION_FAILED);
+
+        let res: HttpResponse = ErrorImATeapot("err").into();
+        assert_eq!(res.status(), StatusCode::IM_A_TEAPOT);
+
+        let res: HttpResponse = ErrorMisdirectedRequest("err").into();
+        assert_eq!(res.status(), StatusCode::MISDIRECTED_REQUEST);
+
+        let res: HttpResponse = ErrorUnprocessableEntity("err").into();
+        assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY);
+
+        let res: HttpResponse = ErrorLocked("err").into();
+        assert_eq!(res.status(), StatusCode::LOCKED);
+
+        let res: HttpResponse = ErrorFailedDependency("err").into();
+        assert_eq!(res.status(), StatusCode::FAILED_DEPENDENCY);
+
+        let res: HttpResponse = ErrorUpgradeRequired("err").into();
+        assert_eq!(res.status(), StatusCode::UPGRADE_REQUIRED);
+
+        let res: HttpResponse = ErrorPreconditionRequired("err").into();
+        assert_eq!(res.status(), StatusCode::PRECONDITION_REQUIRED);
+
+        let res: HttpResponse = ErrorTooManyRequests("err").into();
+        assert_eq!(res.status(), StatusCode::TOO_MANY_REQUESTS);
+
+        let res: HttpResponse = ErrorRequestHeaderFieldsTooLarge("err").into();
+        assert_eq!(res.status(), StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE);
+
+        let res: HttpResponse = ErrorUnavailableForLegalReasons("err").into();
+        assert_eq!(res.status(), StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS);
+
+        let res: HttpResponse = ErrorInternalServerError("err").into();
+        assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
+
+        let res: HttpResponse = ErrorNotImplemented("err").into();
+        assert_eq!(res.status(), StatusCode::NOT_IMPLEMENTED);
+
+        let res: HttpResponse = ErrorBadGateway("err").into();
+        assert_eq!(res.status(), StatusCode::BAD_GATEWAY);
+
+        let res: HttpResponse = ErrorServiceUnavailable("err").into();
+        assert_eq!(res.status(), StatusCode::SERVICE_UNAVAILABLE);
+
+        let res: HttpResponse = ErrorGatewayTimeout("err").into();
+        assert_eq!(res.status(), StatusCode::GATEWAY_TIMEOUT);
+
+        let res: HttpResponse = ErrorHttpVersionNotSupported("err").into();
+        assert_eq!(res.status(), StatusCode::HTTP_VERSION_NOT_SUPPORTED);
+
+        let res: HttpResponse = ErrorVariantAlsoNegotiates("err").into();
+        assert_eq!(res.status(), StatusCode::VARIANT_ALSO_NEGOTIATES);
+
+        let res: HttpResponse = ErrorInsufficientStorage("err").into();
+        assert_eq!(res.status(), StatusCode::INSUFFICIENT_STORAGE);
+
+        let res: HttpResponse = ErrorLoopDetected("err").into();
+        assert_eq!(res.status(), StatusCode::LOOP_DETECTED);
+
+        let res: HttpResponse = ErrorNotExtended("err").into();
+        assert_eq!(res.status(), StatusCode::NOT_EXTENDED);
+
+        let res: HttpResponse = ErrorNetworkAuthenticationRequired("err").into();
+        assert_eq!(res.status(), StatusCode::NETWORK_AUTHENTICATION_REQUIRED);
+    }
+}
diff --git a/src/error/macros.rs b/src/error/macros.rs
new file mode 100644
index 000000000..aeab74308
--- /dev/null
+++ b/src/error/macros.rs
@@ -0,0 +1,109 @@
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __downcast_get_type_id {
+    () => {
+        /// A helper method to get the type ID of the type
+        /// this trait is implemented on.
+        /// This method is unsafe to *implement*, since `downcast_ref` relies
+        /// on the returned `TypeId` to perform a cast.
+        ///
+        /// Unfortunately, Rust has no notion of a trait method that is
+        /// unsafe to implement (marking it as `unsafe` makes it unsafe
+        /// to *call*). As a workaround, we require this method
+        /// to return a private type along with the `TypeId`. This
+        /// private type (`PrivateHelper`) has a private constructor,
+        /// making it impossible for safe code to construct outside of
+        /// this module. This ensures that safe code cannot violate
+        /// type-safety by implementing this method.
+        ///
+        /// We also take `PrivateHelper` as a parameter, to ensure that
+        /// safe code cannot obtain a `PrivateHelper` instance by
+        /// delegating to an existing implementation of `__private_get_type_id__`
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        fn __private_get_type_id__(&self, _: PrivateHelper) -> (std::any::TypeId, PrivateHelper)
+        where
+            Self: 'static,
+        {
+            (std::any::TypeId::of::<Self>(), PrivateHelper(()))
+        }
+    };
+}
+
+//Generate implementation for dyn $name
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __downcast_dyn {
+    ($name:ident) => {
+        /// A struct with a private constructor, for use with
+        /// `__private_get_type_id__`. Its single field is private,
+        /// ensuring that it can only be constructed from this module
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        pub struct PrivateHelper(());
+
+        impl dyn $name + 'static {
+            /// Downcasts generic body to a specific type.
+            #[allow(dead_code)]
+            pub fn downcast_ref<T: $name + 'static>(&self) -> Option<&T> {
+                if self.__private_get_type_id__(PrivateHelper(())).0
+                    == std::any::TypeId::of::<T>()
+                {
+                    // SAFETY: external crates cannot override the default
+                    // implementation of `__private_get_type_id__`, since
+                    // it requires returning a private type. We can therefore
+                    // rely on the returned `TypeId`, which ensures that this
+                    // case is correct.
+                    unsafe { Some(&*(self as *const dyn $name as *const T)) }
+                } else {
+                    None
+                }
+            }
+
+            /// Downcasts a generic body to a mutable specific type.
+            #[allow(dead_code)]
+            pub fn downcast_mut<T: $name + 'static>(&mut self) -> Option<&mut T> {
+                if self.__private_get_type_id__(PrivateHelper(())).0
+                    == std::any::TypeId::of::<T>()
+                {
+                    // SAFETY: external crates cannot override the default
+                    // implementation of `__private_get_type_id__`, since
+                    // it requires returning a private type. We can therefore
+                    // rely on the returned `TypeId`, which ensures that this
+                    // case is correct.
+                    unsafe { Some(&mut *(self as *const dyn $name as *const T as *mut T)) }
+                } else {
+                    None
+                }
+            }
+        }
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::upper_case_acronyms)]
+
+    trait MB {
+        __downcast_get_type_id!();
+    }
+
+    __downcast_dyn!(MB);
+
+    impl MB for String {}
+    impl MB for () {}
+
+    #[actix_rt::test]
+    async fn test_any_casting() {
+        let mut body = String::from("hello cast");
+        let resp_body: &mut dyn MB = &mut body;
+        let body = resp_body.downcast_ref::<String>().unwrap();
+        assert_eq!(body, "hello cast");
+        let body = &mut resp_body.downcast_mut::<String>().unwrap();
+        body.push('!');
+        let body = resp_body.downcast_ref::<String>().unwrap();
+        assert_eq!(body, "hello cast!");
+        let not_body = resp_body.downcast_ref::<()>();
+        assert!(not_body.is_none());
+    }
+}
diff --git a/src/error.rs b/src/error/mod.rs
similarity index 81%
rename from src/error.rs
rename to src/error/mod.rs
index cc1a055b8..637d6ff16 100644
--- a/src/error.rs
+++ b/src/error/mod.rs
@@ -9,6 +9,21 @@ use url::ParseError as UrlParseError;
 
 use crate::http::StatusCode;
 
+#[allow(clippy::module_inception)]
+mod error;
+mod internal;
+mod macros;
+mod response_error;
+
+pub use self::error::Error;
+pub use self::internal::*;
+pub use self::response_error::ResponseError;
+
+/// A convenience [`Result`](std::result::Result) for Actix Web operations.
+///
+/// This type alias is generally used to avoid writing out `actix_http::Error` directly.
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
 /// Errors which can occur when attempting to generate resource uri.
 #[derive(Debug, PartialEq, Display, Error, From)]
 #[non_exhaustive]
@@ -26,7 +41,6 @@ pub enum UrlGenerationError {
     ParseError(UrlParseError),
 }
 
-/// `InternalServerError` for `UrlGeneratorError`
 impl ResponseError for UrlGenerationError {}
 
 /// A set of errors that can occur during parsing urlencoded payloads
@@ -70,7 +84,6 @@ pub enum UrlencodedError {
     Payload(PayloadError),
 }
 
-/// Return `BadRequest` for `UrlencodedError`
 impl ResponseError for UrlencodedError {
     fn status_code(&self) -> StatusCode {
         match self {
@@ -86,9 +99,17 @@ impl ResponseError for UrlencodedError {
 #[derive(Debug, Display, Error)]
 #[non_exhaustive]
 pub enum JsonPayloadError {
-    /// Payload size is bigger than allowed. (default: 32kB)
-    #[display(fmt = "Json payload size is bigger than allowed")]
-    Overflow,
+    /// Payload size is bigger than allowed & content length header set. (default: 2MB)
+    #[display(
+        fmt = "JSON payload ({} bytes) is larger than allowed (limit: {} bytes).",
+        length,
+        limit
+    )]
+    OverflowKnownLength { length: usize, limit: usize },
+
+    /// Payload size is bigger than allowed but no content length header set. (default: 2MB)
+    #[display(fmt = "JSON payload has exceeded limit ({} bytes).", limit)]
+    Overflow { limit: usize },
 
     /// Content type error
     #[display(fmt = "Content type error")]
@@ -116,7 +137,11 @@ impl From<PayloadError> for JsonPayloadError {
 impl ResponseError for JsonPayloadError {
     fn status_code(&self) -> StatusCode {
         match self {
-            Self::Overflow => StatusCode::PAYLOAD_TOO_LARGE,
+            Self::OverflowKnownLength {
+                length: _,
+                limit: _,
+            } => StatusCode::PAYLOAD_TOO_LARGE,
+            Self::Overflow { limit: _ } => StatusCode::PAYLOAD_TOO_LARGE,
             Self::Serialize(_) => StatusCode::INTERNAL_SERVER_ERROR,
             Self::Payload(err) => err.status_code(),
             _ => StatusCode::BAD_REQUEST,
@@ -149,7 +174,6 @@ pub enum QueryPayloadError {
     Deserialize(serde::de::value::Error),
 }
 
-/// Return `BadRequest` for `QueryPayloadError`
 impl ResponseError for QueryPayloadError {
     fn status_code(&self) -> StatusCode {
         StatusCode::BAD_REQUEST
@@ -177,7 +201,6 @@ pub enum ReadlinesError {
     ContentTypeError(ContentTypeError),
 }
 
-/// Return `BadRequest` for `ReadlinesError`
 impl ResponseError for ReadlinesError {
     fn status_code(&self) -> StatusCode {
         match *self {
@@ -203,7 +226,13 @@ mod tests {
 
     #[test]
     fn test_json_payload_error() {
-        let resp = JsonPayloadError::Overflow.error_response();
+        let resp = JsonPayloadError::OverflowKnownLength {
+            length: 0,
+            limit: 0,
+        }
+        .error_response();
+        assert_eq!(resp.status(), StatusCode::PAYLOAD_TOO_LARGE);
+        let resp = JsonPayloadError::Overflow { limit: 0 }.error_response();
         assert_eq!(resp.status(), StatusCode::PAYLOAD_TOO_LARGE);
         let resp = JsonPayloadError::ContentType.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
diff --git a/src/error/response_error.rs b/src/error/response_error.rs
new file mode 100644
index 000000000..c58fff8be
--- /dev/null
+++ b/src/error/response_error.rs
@@ -0,0 +1,144 @@
+//! `ResponseError` trait and foreign impls.
+
+use std::{
+    error::Error as StdError,
+    fmt,
+    io::{self, Write as _},
+};
+
+use actix_http::{body::AnyBody, header, Response, StatusCode};
+use bytes::BytesMut;
+
+use crate::{__downcast_dyn, __downcast_get_type_id};
+use crate::{helpers, HttpResponse};
+
+/// Errors that can generate responses.
+// TODO: add std::error::Error bound when replacement for Box<dyn Error> is found
+pub trait ResponseError: fmt::Debug + fmt::Display {
+    /// Returns appropriate status code for error.
+    ///
+    /// A 500 Internal Server Error is used by default. If [error_response](Self::error_response) is
+    /// also implemented and does not call `self.status_code()`, then this will not be used.
+    fn status_code(&self) -> StatusCode {
+        StatusCode::INTERNAL_SERVER_ERROR
+    }
+
+    /// Creates full response for error.
+    ///
+    /// By default, the generated response uses a 500 Internal Server Error status code, a
+    /// `Content-Type` of `text/plain`, and the body is set to `Self`'s `Display` impl.
+    fn error_response(&self) -> HttpResponse {
+        let mut res = HttpResponse::new(self.status_code());
+
+        let mut buf = BytesMut::new();
+        let _ = write!(helpers::MutWriter(&mut buf), "{}", self);
+
+        res.headers_mut().insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static("text/plain; charset=utf-8"),
+        );
+
+        res.set_body(AnyBody::from(buf))
+    }
+
+    __downcast_get_type_id!();
+}
+
+__downcast_dyn!(ResponseError);
+
+impl ResponseError for Box<dyn StdError + 'static> {}
+
+#[cfg(feature = "openssl")]
+impl ResponseError for actix_tls::accept::openssl::SslError {}
+
+impl ResponseError for serde::de::value::Error {
+    fn status_code(&self) -> StatusCode {
+        StatusCode::BAD_REQUEST
+    }
+}
+
+impl ResponseError for std::str::Utf8Error {
+    fn status_code(&self) -> StatusCode {
+        StatusCode::BAD_REQUEST
+    }
+}
+
+impl ResponseError for std::io::Error {
+    fn status_code(&self) -> StatusCode {
+        // TODO: decide if these errors should consider not found or permission errors
+        match self.kind() {
+            io::ErrorKind::NotFound => StatusCode::NOT_FOUND,
+            io::ErrorKind::PermissionDenied => StatusCode::FORBIDDEN,
+            _ => StatusCode::INTERNAL_SERVER_ERROR,
+        }
+    }
+}
+
+impl ResponseError for actix_http::error::HttpError {}
+
+impl ResponseError for actix_http::Error {
+    fn status_code(&self) -> StatusCode {
+        // TODO: map error kinds to status code better
+        StatusCode::INTERNAL_SERVER_ERROR
+    }
+
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(self.status_code()).set_body(self.to_string().into())
+    }
+}
+
+impl ResponseError for actix_http::header::InvalidHeaderValue {
+    fn status_code(&self) -> StatusCode {
+        StatusCode::BAD_REQUEST
+    }
+}
+
+impl ResponseError for actix_http::error::ParseError {
+    fn status_code(&self) -> StatusCode {
+        StatusCode::BAD_REQUEST
+    }
+}
+
+impl ResponseError for actix_http::error::BlockingError {}
+
+impl ResponseError for actix_http::error::PayloadError {
+    fn status_code(&self) -> StatusCode {
+        match *self {
+            actix_http::error::PayloadError::Overflow => StatusCode::PAYLOAD_TOO_LARGE,
+            _ => StatusCode::BAD_REQUEST,
+        }
+    }
+}
+
+impl ResponseError for actix_http::ws::ProtocolError {}
+
+impl ResponseError for actix_http::error::ContentTypeError {
+    fn status_code(&self) -> StatusCode {
+        StatusCode::BAD_REQUEST
+    }
+}
+
+impl ResponseError for actix_http::ws::HandshakeError {
+    fn error_response(&self) -> HttpResponse {
+        Response::from(self).into()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_error_casting() {
+        use actix_http::error::{ContentTypeError, PayloadError};
+
+        let err = PayloadError::Overflow;
+        let resp_err: &dyn ResponseError = &err;
+
+        let err = resp_err.downcast_ref::<PayloadError>().unwrap();
+        assert_eq!(err.to_string(), "Payload reached size limit.");
+
+        let not_err = resp_err.downcast_ref::<ContentTypeError>();
+        assert!(not_err.is_none());
+    }
+}
diff --git a/src/extract.rs b/src/extract.rs
index 80f2384a0..45cb330a3 100644
--- a/src/extract.rs
+++ b/src/extract.rs
@@ -47,8 +47,7 @@ pub trait FromRequest: Sized {
 ///
 /// If the FromRequest for T fails, return None rather than returning an error response
 ///
-/// ## Example
-///
+/// # Examples
 /// ```
 /// use actix_web::{web, dev, App, Error, HttpRequest, FromRequest};
 /// use actix_web::error::ErrorBadRequest;
@@ -139,8 +138,7 @@ where
 ///
 /// If the `FromRequest` for T fails, inject Err into handler rather than returning an error response
 ///
-/// ## Example
-///
+/// # Examples
 /// ```
 /// use actix_web::{web, dev, App, Result, Error, HttpRequest, FromRequest};
 /// use actix_web::error::ErrorBadRequest;
diff --git a/src/guard.rs b/src/guard.rs
index 3a1f5bb14..c71d64a29 100644
--- a/src/guard.rs
+++ b/src/guard.rs
@@ -26,6 +26,8 @@
 //! ```
 #![allow(non_snake_case)]
 use std::convert::TryFrom;
+use std::ops::Deref;
+use std::rc::Rc;
 
 use actix_http::http::{self, header, uri::Uri};
 use actix_http::RequestHead;
@@ -40,6 +42,12 @@ pub trait Guard {
     fn check(&self, request: &RequestHead) -> bool;
 }
 
+impl Guard for Rc<dyn Guard> {
+    fn check(&self, request: &RequestHead) -> bool {
+        self.deref().check(request)
+    }
+}
+
 /// Create guard object for supplied function.
 ///
 /// ```
diff --git a/src/handler.rs b/src/handler.rs
index 822dcafdd..bc91ce41b 100644
--- a/src/handler.rs
+++ b/src/handler.rs
@@ -3,18 +3,14 @@ use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use actix_http::Error;
 use actix_service::{Service, ServiceFactory};
 use actix_utils::future::{ready, Ready};
 use futures_core::ready;
 use pin_project::pin_project;
 
 use crate::{
-    extract::FromRequest,
-    request::HttpRequest,
-    responder::Responder,
-    response::HttpResponse,
     service::{ServiceRequest, ServiceResponse},
+    Error, FromRequest, HttpRequest, HttpResponse, Responder,
 };
 
 /// A request handler is an async function that accepts zero or more parameters that can be
diff --git a/src/helpers.rs b/src/helpers.rs
new file mode 100644
index 000000000..1d2679fce
--- /dev/null
+++ b/src/helpers.rs
@@ -0,0 +1,25 @@
+use std::io;
+
+use bytes::BufMut;
+
+/// An `io::Write`r that only requires mutable reference and assumes that there is space available
+/// in the buffer for every write operation or that it can be extended implicitly (like
+/// `bytes::BytesMut`, for example).
+///
+/// This is slightly faster (~10%) than `bytes::buf::Writer` in such cases because it does not
+/// perform a remaining length check before writing.
+pub(crate) struct MutWriter<'a, B>(pub(crate) &'a mut B);
+
+impl<'a, B> io::Write for MutWriter<'a, B>
+where
+    B: BufMut,
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.put_slice(buf);
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
diff --git a/src/http/header/accept_language.rs b/src/http/header/accept_language.rs
index 5fab4f79c..034946d4d 100644
--- a/src/http/header/accept_language.rs
+++ b/src/http/header/accept_language.rs
@@ -24,14 +24,11 @@ crate::__define_common_header! {
     /// # Examples
     ///
     /// ```
-    /// use language_tags::langtag;
     /// use actix_web::HttpResponse;
     /// use actix_web::http::header::{AcceptLanguage, LanguageTag, qitem};
     ///
     /// let mut builder = HttpResponse::Ok();
-    /// let mut langtag: LanguageTag = Default::default();
-    /// langtag.language = Some("en".to_owned());
-    /// langtag.region = Some("US".to_owned());
+    /// let langtag = LanguageTag::parse("en-US").unwrap();
     /// builder.insert_header(
     ///     AcceptLanguage(vec![
     ///         qitem(langtag),
@@ -40,16 +37,15 @@ crate::__define_common_header! {
     /// ```
     ///
     /// ```
-    /// use language_tags::langtag;
     /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{AcceptLanguage, QualityItem, q, qitem};
+    /// use actix_web::http::header::{AcceptLanguage, LanguageTag, QualityItem, q, qitem};
     ///
     /// let mut builder = HttpResponse::Ok();
     /// builder.insert_header(
     ///     AcceptLanguage(vec![
-    ///         qitem(langtag!(da)),
-    ///         QualityItem::new(langtag!(en;;;GB), q(800)),
-    ///         QualityItem::new(langtag!(en), q(700)),
+    ///         qitem(LanguageTag::parse("da").unwrap()),
+    ///         QualityItem::new(LanguageTag::parse("en-GB").unwrap(), q(800)),
+    ///         QualityItem::new(LanguageTag::parse("en").unwrap(), q(700)),
     ///     ])
     /// );
     /// ```
diff --git a/src/http/header/content_language.rs b/src/http/header/content_language.rs
index 41e6d9eff..c2469edd1 100644
--- a/src/http/header/content_language.rs
+++ b/src/http/header/content_language.rs
@@ -24,28 +24,26 @@ crate::__define_common_header! {
     /// # Examples
     ///
     /// ```
-    /// use language_tags::langtag;
     /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{ContentLanguage, qitem};
+    /// use actix_web::http::header::{ContentLanguage, LanguageTag, qitem};
     ///
     /// let mut builder = HttpResponse::Ok();
     /// builder.insert_header(
     ///     ContentLanguage(vec![
-    ///         qitem(langtag!(en)),
+    ///         qitem(LanguageTag::parse("en").unwrap()),
     ///     ])
     /// );
     /// ```
     ///
     /// ```
-    /// use language_tags::langtag;
     /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{ContentLanguage, qitem};
+    /// use actix_web::http::header::{ContentLanguage, LanguageTag, qitem};
     ///
     /// let mut builder = HttpResponse::Ok();
     /// builder.insert_header(
     ///     ContentLanguage(vec![
-    ///         qitem(langtag!(da)),
-    ///         qitem(langtag!(en;;;GB)),
+    ///         qitem(LanguageTag::parse("da").unwrap()),
+    ///         qitem(LanguageTag::parse("en-GB").unwrap()),
     ///     ])
     /// );
     /// ```
diff --git a/src/http/header/encoding.rs b/src/http/header/encoding.rs
index aa49dea45..ce31c100f 100644
--- a/src/http/header/encoding.rs
+++ b/src/http/header/encoding.rs
@@ -1,7 +1,7 @@
 use std::{fmt, str};
 
 pub use self::Encoding::{
-    Brotli, Chunked, Compress, Deflate, EncodingExt, Gzip, Identity, Trailers,
+    Brotli, Chunked, Compress, Deflate, EncodingExt, Gzip, Identity, Trailers, Zstd,
 };
 
 /// A value to represent an encoding used in `Transfer-Encoding`
@@ -22,6 +22,8 @@ pub enum Encoding {
     Identity,
     /// The `trailers` encoding.
     Trailers,
+    /// The `zstd` encoding.
+    Zstd,
     /// Some other encoding that is less common, can be any String.
     EncodingExt(String),
 }
@@ -36,6 +38,7 @@ impl fmt::Display for Encoding {
             Compress => "compress",
             Identity => "identity",
             Trailers => "trailers",
+            Zstd => "zstd",
             EncodingExt(ref s) => s.as_ref(),
         })
     }
@@ -52,6 +55,7 @@ impl str::FromStr for Encoding {
             "compress" => Ok(Compress),
             "identity" => Ok(Identity),
             "trailers" => Ok(Trailers),
+            "zstd" => Ok(Zstd),
             _ => Ok(EncodingExt(s.to_owned())),
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
index cf1bfa590..4bcef3988 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,7 +1,6 @@
 //! Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.
 //!
-//! ## Example
-//!
+//! # Examples
 //! ```no_run
 //! use actix_web::{get, web, App, HttpServer, Responder};
 //!
@@ -20,48 +19,48 @@
 //! }
 //! ```
 //!
-//! ## Documentation & Community Resources
-//!
+//! # Documentation & Community Resources
 //! In addition to this API documentation, several other resources are available:
 //!
 //! * [Website & User Guide](https://actix.rs/)
 //! * [Examples Repository](https://github.com/actix/examples)
+//! * [Community Chat on Discord](https://discord.gg/NWpN5mmg3x)
 //! * [Community Chat on Gitter](https://gitter.im/actix/actix-web)
 //!
 //! To get started navigating the API docs, you may consider looking at the following pages first:
 //!
-//! * [App]: This struct represents an Actix Web application and is used to
+//! * [`App`]: This struct represents an Actix Web application and is used to
 //!   configure routes and other common application settings.
 //!
-//! * [HttpServer]: This struct represents an HTTP server instance and is
+//! * [`HttpServer`]: This struct represents an HTTP server instance and is
 //!   used to instantiate and configure servers.
 //!
-//! * [web]: This module provides essential types for route registration as well as
+//! * [`web`]: This module provides essential types for route registration as well as
 //!   common utilities for request handlers.
 //!
-//! * [HttpRequest] and [HttpResponse]: These
+//! * [`HttpRequest`] and [`HttpResponse`]: These
 //!   structs represent HTTP requests and responses and expose methods for creating, inspecting,
 //!   and otherwise utilizing them.
 //!
-//! ## Features
-//!
+//! # Features
 //! * Supports *HTTP/1.x* and *HTTP/2*
 //! * Streaming and pipelining
 //! * Keep-alive and slow requests handling
 //! * Client/server [WebSockets](https://actix.rs/docs/websockets/) support
-//! * Transparent content compression/decompression (br, gzip, deflate)
+//! * Transparent content compression/decompression (br, gzip, deflate, zstd)
 //! * Powerful [request routing](https://actix.rs/docs/url-dispatch/)
 //! * Multipart streams
 //! * Static assets
 //! * SSL support using OpenSSL or Rustls
 //! * Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
-//! * Includes an async [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
+//! * Includes an async [HTTP client](https://docs.rs/awc/)
 //! * Runs on stable Rust 1.46+
 //!
-//! ## Crate Features
-//!
-//! * `compress` - content encoding compression support (enabled by default)
+//! # Crate Features
 //! * `cookies` - cookies support (enabled by default)
+//! * `compress-brotli` - brotli content encoding compression support (enabled by default)
+//! * `compress-gzip` - gzip and deflate content encoding compression support (enabled by default)
+//! * `compress-zstd` - zstd content encoding compression support (enabled by default)
 //! * `openssl` - HTTPS support via `openssl` crate, supports `HTTP/2`
 //! * `rustls` - HTTPS support via `rustls` crate, supports `HTTP/2`
 //! * `secure-cookies` - secure cookies support
@@ -79,6 +78,7 @@ pub mod error;
 mod extract;
 pub mod guard;
 mod handler;
+mod helpers;
 pub mod http;
 mod info;
 pub mod middleware;
@@ -97,7 +97,7 @@ pub(crate) mod types;
 pub mod web;
 
 pub use actix_http::Response as BaseHttpResponse;
-pub use actix_http::{body, Error, HttpMessage, ResponseError, Result};
+pub use actix_http::{body, HttpMessage};
 #[doc(inline)]
 pub use actix_rt as rt;
 pub use actix_web_codegen::*;
@@ -105,6 +105,7 @@ pub use actix_web_codegen::*;
 pub use cookie;
 
 pub use crate::app::App;
+pub use crate::error::{Error, ResponseError, Result};
 pub use crate::extract::FromRequest;
 pub use crate::request::HttpRequest;
 pub use crate::resource::Resource;
@@ -138,8 +139,11 @@ pub mod dev {
     pub use crate::types::json::JsonBody;
     pub use crate::types::readlines::Readlines;
 
-    pub use actix_http::body::{Body, BodySize, MessageBody, ResponseBody, SizedStream};
-    #[cfg(feature = "compress")]
+    pub use actix_http::body::{
+        AnyBody, Body, BodySize, MessageBody, ResponseBody, SizedStream,
+    };
+
+    #[cfg(feature = "__compress")]
     pub use actix_http::encoding::Decoder as Decompress;
     pub use actix_http::ResponseBuilder as BaseHttpResponseBuilder;
     pub use actix_http::{Extensions, Payload, PayloadStream, RequestHead, ResponseHead};
@@ -167,6 +171,8 @@ pub mod dev {
         fn get_encoding(&self) -> Option<ContentEncoding>;
 
         /// Set content encoding
+        ///
+        /// Must be used with [`crate::middleware::Compress`] to take effect.
         fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self;
     }
 
diff --git a/src/middleware/compat.rs b/src/middleware/compat.rs
index 0e3a4f2b7..0a6256fe2 100644
--- a/src/middleware/compat.rs
+++ b/src/middleware/compat.rs
@@ -1,12 +1,13 @@
 //! For middleware documentation, see [`Compat`].
 
 use std::{
+    error::Error as StdError,
     future::Future,
     pin::Pin,
     task::{Context, Poll},
 };
 
-use actix_http::body::{Body, MessageBody, ResponseBody};
+use actix_http::body::{Body, MessageBody};
 use actix_service::{Service, Transform};
 use futures_core::{future::LocalBoxFuture, ready};
 
@@ -49,7 +50,7 @@ where
     T: Transform<S, Req>,
     T::Future: 'static,
     T::Response: MapServiceResponseBody,
-    Error: From<T::Error>,
+    T::Error: Into<Error>,
 {
     type Response = ServiceResponse;
     type Error = Error;
@@ -74,7 +75,7 @@ impl<S, Req> Service<Req> for CompatMiddleware<S>
 where
     S: Service<Req>,
     S::Response: MapServiceResponseBody,
-    Error: From<S::Error>,
+    S::Error: Into<Error>,
 {
     type Response = ServiceResponse;
     type Error = Error;
@@ -98,12 +99,16 @@ impl<Fut, T, E> Future for CompatMiddlewareFuture<Fut>
 where
     Fut: Future<Output = Result<T, E>>,
     T: MapServiceResponseBody,
-    Error: From<E>,
+    E: Into<Error>,
 {
     type Output = Result<ServiceResponse, Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let res = ready!(self.project().fut.poll(cx))?;
+        let res = match ready!(self.project().fut.poll(cx)) {
+            Ok(res) => res,
+            Err(err) => return Poll::Ready(Err(err.into())),
+        };
+
         Poll::Ready(Ok(res.map_body()))
     }
 }
@@ -113,9 +118,13 @@ pub trait MapServiceResponseBody {
     fn map_body(self) -> ServiceResponse;
 }
 
-impl<B: MessageBody + Unpin + 'static> MapServiceResponseBody for ServiceResponse<B> {
+impl<B> MapServiceResponseBody for ServiceResponse<B>
+where
+    B: MessageBody + Unpin + 'static,
+    B::Error: Into<Box<dyn StdError + 'static>>,
+{
     fn map_body(self) -> ServiceResponse {
-        self.map_body(|_, body| ResponseBody::Other(Body::from_message(body)))
+        self.map_body(|_, body| Body::from_message(body))
     }
 }
 
@@ -135,7 +144,7 @@ mod tests {
     use crate::{web, App, HttpResponse};
 
     #[actix_rt::test]
-    #[cfg(all(feature = "cookies", feature = "compress"))]
+    #[cfg(all(feature = "cookies", feature = "__compress"))]
     async fn test_scope_middleware() {
         use crate::middleware::Compress;
 
@@ -158,7 +167,7 @@ mod tests {
     }
 
     #[actix_rt::test]
-    #[cfg(all(feature = "cookies", feature = "compress"))]
+    #[cfg(all(feature = "cookies", feature = "__compress"))]
     async fn test_resource_scope_middleware() {
         use crate::middleware::Compress;
 
diff --git a/src/middleware/compress.rs b/src/middleware/compress.rs
index 6a56e6de0..0eb4d0a83 100644
--- a/src/middleware/compress.rs
+++ b/src/middleware/compress.rs
@@ -10,10 +10,9 @@ use std::{
 };
 
 use actix_http::{
-    body::MessageBody,
+    body::{MessageBody, ResponseBody},
     encoding::Encoder,
     http::header::{ContentEncoding, ACCEPT_ENCODING},
-    Error,
 };
 use actix_service::{Service, Transform};
 use actix_utils::future::{ok, Ready};
@@ -23,6 +22,7 @@ use pin_project::pin_project;
 use crate::{
     dev::BodyEncoding,
     service::{ServiceRequest, ServiceResponse},
+    Error,
 };
 
 /// Middleware for compressing response payloads.
@@ -59,7 +59,7 @@ where
     B: MessageBody,
     S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
-    type Response = ServiceResponse<Encoder<B>>;
+    type Response = ServiceResponse<ResponseBody<Encoder<B>>>;
     type Error = Error;
     type Transform = CompressMiddleware<S>;
     type InitError = ();
@@ -83,7 +83,7 @@ where
     B: MessageBody,
     S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
-    type Response = ServiceResponse<Encoder<B>>;
+    type Response = ServiceResponse<ResponseBody<Encoder<B>>>;
     type Error = Error;
     type Future = CompressResponse<S, B>;
 
@@ -127,7 +127,7 @@ where
     B: MessageBody,
     S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
-    type Output = Result<ServiceResponse<Encoder<B>>, Error>;
+    type Output = Result<ServiceResponse<ResponseBody<Encoder<B>>>, Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -140,9 +140,9 @@ where
                     *this.encoding
                 };
 
-                Poll::Ready(Ok(
-                    resp.map_body(move |head, body| Encoder::response(enc, head, body))
-                ))
+                Poll::Ready(Ok(resp.map_body(move |head, body| {
+                    Encoder::response(enc, head, ResponseBody::Body(body))
+                })))
             }
             Err(e) => Poll::Ready(Err(e)),
         }
diff --git a/src/middleware/err_handlers.rs b/src/middleware/err_handlers.rs
index 88834f8ce..75cc819bc 100644
--- a/src/middleware/err_handlers.rs
+++ b/src/middleware/err_handlers.rs
@@ -13,8 +13,8 @@ use futures_core::{future::LocalBoxFuture, ready};
 
 use crate::{
     dev::{ServiceRequest, ServiceResponse},
-    error::{Error, Result},
     http::StatusCode,
+    Error, Result,
 };
 
 /// Return type for [`ErrorHandlers`] custom handlers.
diff --git a/src/middleware/logger.rs b/src/middleware/logger.rs
index 40ed9258f..bbb0e3dc4 100644
--- a/src/middleware/logger.rs
+++ b/src/middleware/logger.rs
@@ -21,11 +21,10 @@ use regex::{Regex, RegexSet};
 use time::OffsetDateTime;
 
 use crate::{
-    dev::{BodySize, MessageBody, ResponseBody},
-    error::{Error, Result},
+    dev::{BodySize, MessageBody},
     http::{HeaderName, StatusCode},
     service::{ServiceRequest, ServiceResponse},
-    HttpResponse,
+    Error, HttpResponse, Result,
 };
 
 /// Middleware for logging request and response summaries to the terminal.
@@ -290,13 +289,11 @@ where
         let time = *this.time;
         let format = this.format.take();
 
-        Poll::Ready(Ok(res.map_body(move |_, body| {
-            ResponseBody::Body(StreamLog {
-                body,
-                time,
-                format,
-                size: 0,
-            })
+        Poll::Ready(Ok(res.map_body(move |_, body| StreamLog {
+            body,
+            time,
+            format,
+            size: 0,
         })))
     }
 }
@@ -306,7 +303,7 @@ use pin_project::{pin_project, pinned_drop};
 #[pin_project(PinnedDrop)]
 pub struct StreamLog<B> {
     #[pin]
-    body: ResponseBody<B>,
+    body: B,
     format: Option<Format>,
     size: usize,
     time: OffsetDateTime,
@@ -327,7 +324,13 @@ impl<B> PinnedDrop for StreamLog<B> {
     }
 }
 
-impl<B: MessageBody> MessageBody for StreamLog<B> {
+impl<B> MessageBody for StreamLog<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = Error;
+
     fn size(&self) -> BodySize {
         self.body.size()
     }
@@ -335,14 +338,17 @@ impl<B: MessageBody> MessageBody for StreamLog<B> {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         let this = self.project();
-        match this.body.poll_next(cx) {
-            Poll::Ready(Some(Ok(chunk))) => {
+
+        // TODO: MSRV 1.51: poll_map_err
+        match ready!(this.body.poll_next(cx)) {
+            Some(Ok(chunk)) => {
                 *this.size += chunk.len();
                 Poll::Ready(Some(Ok(chunk)))
             }
-            val => val,
+            Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
+            None => Poll::Ready(None),
         }
     }
 }
diff --git a/src/middleware/mod.rs b/src/middleware/mod.rs
index e24782f07..96a361fcf 100644
--- a/src/middleware/mod.rs
+++ b/src/middleware/mod.rs
@@ -14,7 +14,8 @@ pub use self::err_handlers::{ErrorHandlerResponse, ErrorHandlers};
 pub use self::logger::Logger;
 pub use self::normalize::{NormalizePath, TrailingSlash};
 
-#[cfg(feature = "compress")]
+#[cfg(feature = "__compress")]
 mod compress;
-#[cfg(feature = "compress")]
+
+#[cfg(feature = "__compress")]
 pub use self::compress::Compress;
diff --git a/src/middleware/normalize.rs b/src/middleware/normalize.rs
index ec6c2a344..219af1c6a 100644
--- a/src/middleware/normalize.rs
+++ b/src/middleware/normalize.rs
@@ -137,58 +137,63 @@ where
 
         let original_path = head.uri.path();
 
-        // Either adds a string to the end (duplicates will be removed anyways) or trims all slashes from the end
-        let path = match self.trailing_slash_behavior {
-            TrailingSlash::Always => original_path.to_string() + "/",
-            TrailingSlash::MergeOnly => original_path.to_string(),
-            TrailingSlash::Trim => original_path.trim_end_matches('/').to_string(),
-        };
-
-        // normalize multiple /'s to one /
-        let path = self.merge_slash.replace_all(&path, "/");
-
-        // Ensure root paths are still resolvable. If resulting path is blank after previous step
-        // it means the path was one or more slashes. Reduce to single slash.
-        let path = if path.is_empty() { "/" } else { path.as_ref() };
-
-        // Check whether the path has been changed
-        //
-        // This check was previously implemented as string length comparison
-        //
-        // That approach fails when a trailing slash is added,
-        // and a duplicate slash is removed,
-        // since the length of the strings remains the same
-        //
-        // For example, the path "/v1//s" will be normalized to "/v1/s/"
-        // Both of the paths have the same length,
-        // so the change can not be deduced from the length comparison
-        if path != original_path {
-            let mut parts = head.uri.clone().into_parts();
-            let query = parts.path_and_query.as_ref().and_then(|pq| pq.query());
-
-            let path = if let Some(q) = query {
-                Bytes::from(format!("{}?{}", path, q))
-            } else {
-                Bytes::copy_from_slice(path.as_bytes())
+        // An empty path here means that the URI has no valid path. We skip normalization in this
+        // case, because adding a path can make the URI invalid
+        if !original_path.is_empty() {
+            // Either adds a string to the end (duplicates will be removed anyways) or trims all
+            // slashes from the end
+            let path = match self.trailing_slash_behavior {
+                TrailingSlash::Always => format!("{}/", original_path),
+                TrailingSlash::MergeOnly => original_path.to_string(),
+                TrailingSlash::Trim => original_path.trim_end_matches('/').to_string(),
             };
-            parts.path_and_query = Some(PathAndQuery::from_maybe_shared(path).unwrap());
 
-            let uri = Uri::from_parts(parts).unwrap();
-            req.match_info_mut().get_mut().update(&uri);
-            req.head_mut().uri = uri;
+            // normalize multiple /'s to one /
+            let path = self.merge_slash.replace_all(&path, "/");
+
+            // Ensure root paths are still resolvable. If resulting path is blank after previous
+            // step it means the path was one or more slashes. Reduce to single slash.
+            let path = if path.is_empty() { "/" } else { path.as_ref() };
+
+            // Check whether the path has been changed
+            //
+            // This check was previously implemented as string length comparison
+            //
+            // That approach fails when a trailing slash is added,
+            // and a duplicate slash is removed,
+            // since the length of the strings remains the same
+            //
+            // For example, the path "/v1//s" will be normalized to "/v1/s/"
+            // Both of the paths have the same length,
+            // so the change can not be deduced from the length comparison
+            if path != original_path {
+                let mut parts = head.uri.clone().into_parts();
+                let query = parts.path_and_query.as_ref().and_then(|pq| pq.query());
+
+                let path = match query {
+                    Some(q) => Bytes::from(format!("{}?{}", path, q)),
+                    None => Bytes::copy_from_slice(path.as_bytes()),
+                };
+                parts.path_and_query = Some(PathAndQuery::from_maybe_shared(path).unwrap());
+
+                let uri = Uri::from_parts(parts).unwrap();
+                req.match_info_mut().get_mut().update(&uri);
+                req.head_mut().uri = uri;
+            }
         }
-
         self.service.call(req)
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use actix_http::StatusCode;
     use actix_service::IntoService;
 
     use super::*;
     use crate::{
         dev::ServiceRequest,
+        guard::fn_guard,
         test::{call_service, init_service, TestRequest},
         web, App, HttpResponse,
     };
@@ -199,37 +204,34 @@ mod tests {
             App::new()
                 .wrap(NormalizePath::default())
                 .service(web::resource("/").to(HttpResponse::Ok))
-                .service(web::resource("/v1/something").to(HttpResponse::Ok)),
+                .service(web::resource("/v1/something").to(HttpResponse::Ok))
+                .service(
+                    web::resource("/v2/something")
+                        .guard(fn_guard(|req| req.uri.query() == Some("query=test")))
+                        .to(HttpResponse::Ok),
+                ),
         )
         .await;
 
-        let req = TestRequest::with_uri("/").to_request();
-        let res = call_service(&app, req).await;
-        assert!(res.status().is_success());
+        let test_uris = vec![
+            "/",
+            "/?query=test",
+            "///",
+            "/v1//something",
+            "/v1//something////",
+            "//v1/something",
+            "//v1//////something",
+            "/v2//something?query=test",
+            "/v2//something////?query=test",
+            "//v2/something?query=test",
+            "//v2//////something?query=test",
+        ];
 
-        let req = TestRequest::with_uri("/?query=test").to_request();
-        let res = call_service(&app, req).await;
-        assert!(res.status().is_success());
-
-        let req = TestRequest::with_uri("///").to_request();
-        let res = call_service(&app, req).await;
-        assert!(res.status().is_success());
-
-        let req = TestRequest::with_uri("/v1//something////").to_request();
-        let res = call_service(&app, req).await;
-        assert!(res.status().is_success());
-
-        let req2 = TestRequest::with_uri("//v1/something").to_request();
-        let res2 = call_service(&app, req2).await;
-        assert!(res2.status().is_success());
-
-        let req3 = TestRequest::with_uri("//v1//////something").to_request();
-        let res3 = call_service(&app, req3).await;
-        assert!(res3.status().is_success());
-
-        let req4 = TestRequest::with_uri("/v1//something").to_request();
-        let res4 = call_service(&app, req4).await;
-        assert!(res4.status().is_success());
+        for uri in test_uris {
+            let req = TestRequest::with_uri(uri).to_request();
+            let res = call_service(&app, req).await;
+            assert!(res.status().is_success(), "Failed uri: {}", uri);
+        }
     }
 
     #[actix_rt::test]
@@ -238,38 +240,114 @@ mod tests {
             App::new()
                 .wrap(NormalizePath(TrailingSlash::Trim))
                 .service(web::resource("/").to(HttpResponse::Ok))
-                .service(web::resource("/v1/something").to(HttpResponse::Ok)),
+                .service(web::resource("/v1/something").to(HttpResponse::Ok))
+                .service(
+                    web::resource("/v2/something")
+                        .guard(fn_guard(|req| req.uri.query() == Some("query=test")))
+                        .to(HttpResponse::Ok),
+                ),
         )
         .await;
 
-        // root paths should still work
-        let req = TestRequest::with_uri("/").to_request();
-        let res = call_service(&app, req).await;
-        assert!(res.status().is_success());
+        let test_uris = vec![
+            "/",
+            "///",
+            "/v1/something",
+            "/v1/something/",
+            "/v1/something////",
+            "//v1//something",
+            "//v1//something//",
+            "/v2/something?query=test",
+            "/v2/something/?query=test",
+            "/v2/something////?query=test",
+            "//v2//something?query=test",
+            "//v2//something//?query=test",
+        ];
 
-        let req = TestRequest::with_uri("/?query=test").to_request();
-        let res = call_service(&app, req).await;
-        assert!(res.status().is_success());
+        for uri in test_uris {
+            let req = TestRequest::with_uri(uri).to_request();
+            let res = call_service(&app, req).await;
+            assert!(res.status().is_success(), "Failed uri: {}", uri);
+        }
+    }
 
-        let req = TestRequest::with_uri("///").to_request();
-        let res = call_service(&app, req).await;
-        assert!(res.status().is_success());
+    #[actix_rt::test]
+    async fn trim_root_trailing_slashes_with_query() {
+        let app = init_service(
+            App::new().wrap(NormalizePath(TrailingSlash::Trim)).service(
+                web::resource("/")
+                    .guard(fn_guard(|req| req.uri.query() == Some("query=test")))
+                    .to(HttpResponse::Ok),
+            ),
+        )
+        .await;
 
-        let req = TestRequest::with_uri("/v1/something////").to_request();
-        let res = call_service(&app, req).await;
-        assert!(res.status().is_success());
+        let test_uris = vec!["/?query=test", "//?query=test", "///?query=test"];
 
-        let req2 = TestRequest::with_uri("/v1/something/").to_request();
-        let res2 = call_service(&app, req2).await;
-        assert!(res2.status().is_success());
+        for uri in test_uris {
+            let req = TestRequest::with_uri(uri).to_request();
+            let res = call_service(&app, req).await;
+            assert!(res.status().is_success(), "Failed uri: {}", uri);
+        }
+    }
 
-        let req3 = TestRequest::with_uri("//v1//something//").to_request();
-        let res3 = call_service(&app, req3).await;
-        assert!(res3.status().is_success());
+    #[actix_rt::test]
+    async fn ensure_trailing_slash() {
+        let app = init_service(
+            App::new()
+                .wrap(NormalizePath(TrailingSlash::Always))
+                .service(web::resource("/").to(HttpResponse::Ok))
+                .service(web::resource("/v1/something/").to(HttpResponse::Ok))
+                .service(
+                    web::resource("/v2/something/")
+                        .guard(fn_guard(|req| req.uri.query() == Some("query=test")))
+                        .to(HttpResponse::Ok),
+                ),
+        )
+        .await;
 
-        let req4 = TestRequest::with_uri("//v1//something").to_request();
-        let res4 = call_service(&app, req4).await;
-        assert!(res4.status().is_success());
+        let test_uris = vec![
+            "/",
+            "///",
+            "/v1/something",
+            "/v1/something/",
+            "/v1/something////",
+            "//v1//something",
+            "//v1//something//",
+            "/v2/something?query=test",
+            "/v2/something/?query=test",
+            "/v2/something////?query=test",
+            "//v2//something?query=test",
+            "//v2//something//?query=test",
+        ];
+
+        for uri in test_uris {
+            let req = TestRequest::with_uri(uri).to_request();
+            let res = call_service(&app, req).await;
+            assert!(res.status().is_success(), "Failed uri: {}", uri);
+        }
+    }
+
+    #[actix_rt::test]
+    async fn ensure_root_trailing_slash_with_query() {
+        let app = init_service(
+            App::new()
+                .wrap(NormalizePath(TrailingSlash::Always))
+                .service(
+                    web::resource("/")
+                        .guard(fn_guard(|req| req.uri.query() == Some("query=test")))
+                        .to(HttpResponse::Ok),
+                ),
+        )
+        .await;
+
+        let test_uris = vec!["/?query=test", "//?query=test", "///?query=test"];
+
+        for uri in test_uris {
+            let req = TestRequest::with_uri(uri).to_request();
+            let res = call_service(&app, req).await;
+            assert!(res.status().is_success(), "Failed uri: {}", uri);
+        }
     }
 
     #[actix_rt::test]
@@ -279,7 +357,12 @@ mod tests {
                 .wrap(NormalizePath(TrailingSlash::MergeOnly))
                 .service(web::resource("/").to(HttpResponse::Ok))
                 .service(web::resource("/v1/something").to(HttpResponse::Ok))
-                .service(web::resource("/v1/").to(HttpResponse::Ok)),
+                .service(web::resource("/v1/").to(HttpResponse::Ok))
+                .service(
+                    web::resource("/v2/something")
+                        .guard(fn_guard(|req| req.uri.query() == Some("query=test")))
+                        .to(HttpResponse::Ok),
+                ),
         )
         .await;
 
@@ -295,15 +378,35 @@ mod tests {
             ("/v1////", true),
             ("//v1//", true),
             ("///v1", false),
+            ("/v2/something?query=test", true),
+            ("/v2/something/?query=test", false),
+            ("/v2/something//?query=test", false),
+            ("//v2//something?query=test", true),
         ];
 
-        for (path, success) in tests {
-            let req = TestRequest::with_uri(path).to_request();
+        for (uri, success) in tests {
+            let req = TestRequest::with_uri(uri).to_request();
             let res = call_service(&app, req).await;
-            assert_eq!(res.status().is_success(), success);
+            assert_eq!(res.status().is_success(), success, "Failed uri: {}", uri);
         }
     }
 
+    #[actix_rt::test]
+    async fn no_path() {
+        let app = init_service(
+            App::new()
+                .wrap(NormalizePath::default())
+                .service(web::resource("/").to(HttpResponse::Ok)),
+        )
+        .await;
+
+        // This URI will be interpreted as an authority form, i.e. there is no path nor scheme
+        // (https://datatracker.ietf.org/doc/html/rfc7230#section-5.3.3)
+        let req = TestRequest::with_uri("eh").to_request();
+        let res = call_service(&app, req).await;
+        assert_eq!(res.status(), StatusCode::NOT_FOUND);
+    }
+
     #[actix_rt::test]
     async fn test_in_place_normalization() {
         let srv = |req: ServiceRequest| {
@@ -316,21 +419,18 @@ mod tests {
             .await
             .unwrap();
 
-        let req = TestRequest::with_uri("/v1//something////").to_srv_request();
-        let res = normalize.call(req).await.unwrap();
-        assert!(res.status().is_success());
+        let test_uris = vec![
+            "/v1//something////",
+            "///v1/something",
+            "//v1///something",
+            "/v1//something",
+        ];
 
-        let req2 = TestRequest::with_uri("///v1/something").to_srv_request();
-        let res2 = normalize.call(req2).await.unwrap();
-        assert!(res2.status().is_success());
-
-        let req3 = TestRequest::with_uri("//v1///something").to_srv_request();
-        let res3 = normalize.call(req3).await.unwrap();
-        assert!(res3.status().is_success());
-
-        let req4 = TestRequest::with_uri("/v1//something").to_srv_request();
-        let res4 = normalize.call(req4).await.unwrap();
-        assert!(res4.status().is_success());
+        for uri in test_uris {
+            let req = TestRequest::with_uri(uri).to_srv_request();
+            let res = normalize.call(req).await.unwrap();
+            assert!(res.status().is_success(), "Failed uri: {}", uri);
+        }
     }
 
     #[actix_rt::test]
diff --git a/src/request.rs b/src/request.rs
index e3da991de..42c722c46 100644
--- a/src/request.rs
+++ b/src/request.rs
@@ -7,7 +7,7 @@ use std::{
 
 use actix_http::{
     http::{HeaderMap, Method, Uri, Version},
-    Error, Extensions, HttpMessage, Message, Payload, RequestHead,
+    Extensions, HttpMessage, Message, Payload, RequestHead,
 };
 use actix_router::{Path, Url};
 use actix_utils::future::{ok, Ready};
@@ -17,7 +17,7 @@ use smallvec::SmallVec;
 
 use crate::{
     app_service::AppInitServiceState, config::AppConfig, error::UrlGenerationError,
-    extract::FromRequest, info::ConnectionInfo, rmap::ResourceMap,
+    info::ConnectionInfo, rmap::ResourceMap, Error, FromRequest,
 };
 
 #[cfg(feature = "cookies")]
@@ -356,8 +356,7 @@ impl Drop for HttpRequest {
 
 /// It is possible to get `HttpRequest` as an extractor handler parameter
 ///
-/// ## Example
-///
+/// # Examples
 /// ```
 /// use actix_web::{web, App, HttpRequest};
 /// use serde_derive::Deserialize;
diff --git a/src/request_data.rs b/src/request_data.rs
index 60471cbf9..581943015 100644
--- a/src/request_data.rs
+++ b/src/request_data.rs
@@ -1,9 +1,8 @@
 use std::{any::type_name, ops::Deref};
 
-use actix_http::error::{Error, ErrorInternalServerError};
 use actix_utils::future::{err, ok, Ready};
 
-use crate::{dev::Payload, FromRequest, HttpRequest};
+use crate::{dev::Payload, error::ErrorInternalServerError, Error, FromRequest, HttpRequest};
 
 /// Request-local data extractor.
 ///
diff --git a/src/resource.rs b/src/resource.rs
index 049e56291..8c2b83b60 100644
--- a/src/resource.rs
+++ b/src/resource.rs
@@ -3,7 +3,7 @@ use std::fmt;
 use std::future::Future;
 use std::rc::Rc;
 
-use actix_http::{Error, Extensions};
+use actix_http::Extensions;
 use actix_router::IntoPattern;
 use actix_service::boxed::{self, BoxService, BoxServiceFactory};
 use actix_service::{
@@ -13,14 +13,16 @@ use actix_service::{
 use futures_core::future::LocalBoxFuture;
 use futures_util::future::join_all;
 
-use crate::dev::{insert_slash, AppService, HttpServiceFactory, ResourceDef};
-use crate::extract::FromRequest;
-use crate::guard::Guard;
-use crate::handler::Handler;
-use crate::responder::Responder;
-use crate::route::{Route, RouteService};
-use crate::service::{ServiceRequest, ServiceResponse};
-use crate::{data::Data, HttpResponse};
+use crate::{
+    data::Data,
+    dev::{insert_slash, AppService, HttpServiceFactory, ResourceDef},
+    guard::Guard,
+    handler::Handler,
+    responder::Responder,
+    route::{Route, RouteService},
+    service::{ServiceRequest, ServiceResponse},
+    Error, FromRequest, HttpResponse,
+};
 
 type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
 type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
diff --git a/src/responder.rs b/src/responder.rs
index 7b8288ed8..c5852a501 100644
--- a/src/responder.rs
+++ b/src/responder.rs
@@ -1,8 +1,7 @@
-use std::{borrow::Cow, fmt};
+use std::borrow::Cow;
 
 use actix_http::{
     body::Body,
-    error::InternalError,
     http::{header::IntoHeaderPair, Error as HttpError, HeaderMap, StatusCode},
 };
 use bytes::{Bytes, BytesMut};
@@ -227,15 +226,6 @@ impl<T: Responder> Responder for CustomResponder<T> {
     }
 }
 
-impl<T> Responder for InternalError<T>
-where
-    T: fmt::Debug + fmt::Display + 'static,
-{
-    fn respond_to(self, _: &HttpRequest) -> HttpResponse {
-        HttpResponse::from_error(self.into())
-    }
-}
-
 #[cfg(test)]
 pub(crate) mod tests {
     use actix_service::Service;
@@ -264,7 +254,7 @@ pub(crate) mod tests {
         let resp = srv.call(req).await.unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
         match resp.response().body() {
-            ResponseBody::Body(Body::Bytes(ref b)) => {
+            Body::Bytes(ref b) => {
                 let bytes = b.clone();
                 assert_eq!(bytes, Bytes::from_static(b"some"));
             }
@@ -277,16 +267,28 @@ pub(crate) mod tests {
         fn body(&self) -> &Body;
     }
 
+    impl BodyTest for Body {
+        fn bin_ref(&self) -> &[u8] {
+            match self {
+                Body::Bytes(ref bin) => &bin,
+                _ => unreachable!("bug in test impl"),
+            }
+        }
+        fn body(&self) -> &Body {
+            self
+        }
+    }
+
     impl BodyTest for ResponseBody<Body> {
         fn bin_ref(&self) -> &[u8] {
             match self {
                 ResponseBody::Body(ref b) => match b {
                     Body::Bytes(ref bin) => &bin,
-                    _ => panic!(),
+                    _ => unreachable!("bug in test impl"),
                 },
                 ResponseBody::Other(ref b) => match b {
                     Body::Bytes(ref bin) => &bin,
-                    _ => panic!(),
+                    _ => unreachable!("bug in test impl"),
                 },
             }
         }
diff --git a/src/response/builder.rs b/src/response/builder.rs
index 8b3c0f10d..6e013cae2 100644
--- a/src/response/builder.rs
+++ b/src/response/builder.rs
@@ -1,13 +1,14 @@
 use std::{
     cell::{Ref, RefMut},
     convert::TryInto,
+    error::Error as StdError,
     future::Future,
     pin::Pin,
     task::{Context, Poll},
 };
 
 use actix_http::{
-    body::{Body, BodyStream},
+    body::{AnyBody, BodyStream},
     http::{
         header::{self, HeaderName, IntoHeaderPair, IntoHeaderValue},
         ConnectionType, Error as HttpError, StatusCode,
@@ -32,7 +33,7 @@ use crate::{
 ///
 /// This type can be used to construct an instance of `Response` through a builder-like pattern.
 pub struct HttpResponseBuilder {
-    res: Option<Response<Body>>,
+    res: Option<Response<AnyBody>>,
     err: Option<HttpError>,
     #[cfg(feature = "cookies")]
     cookies: Option<CookieJar>,
@@ -310,16 +311,19 @@ impl HttpResponseBuilder {
     ///
     /// `HttpResponseBuilder` can not be used after this call.
     #[inline]
-    pub fn body<B: Into<Body>>(&mut self, body: B) -> HttpResponse {
-        self.message_body(body.into())
+    pub fn body<B: Into<AnyBody>>(&mut self, body: B) -> HttpResponse<AnyBody> {
+        match self.message_body(body.into()) {
+            Ok(res) => res,
+            Err(err) => HttpResponse::from_error(err),
+        }
     }
 
     /// Set a body and generate `Response`.
     ///
     /// `HttpResponseBuilder` can not be used after this call.
-    pub fn message_body<B>(&mut self, body: B) -> HttpResponse<B> {
+    pub fn message_body<B>(&mut self, body: B) -> Result<HttpResponse<B>, Error> {
         if let Some(err) = self.err.take() {
-            return HttpResponse::from_error(Error::from(err)).into_body();
+            return Err(err.into());
         }
 
         let res = self
@@ -336,12 +340,12 @@ impl HttpResponseBuilder {
             for cookie in jar.delta() {
                 match HeaderValue::from_str(&cookie.to_string()) {
                     Ok(val) => res.headers_mut().append(header::SET_COOKIE, val),
-                    Err(err) => return HttpResponse::from_error(Error::from(err)).into_body(),
+                    Err(err) => return Err(err.into()),
                 };
             }
         }
 
-        res
+        Ok(res)
     }
 
     /// Set a streaming body and generate `Response`.
@@ -351,9 +355,9 @@ impl HttpResponseBuilder {
     pub fn streaming<S, E>(&mut self, stream: S) -> HttpResponse
     where
         S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-        E: Into<Error> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
     {
-        self.body(Body::from_message(BodyStream::new(stream)))
+        self.body(AnyBody::from_message(BodyStream::new(stream)))
     }
 
     /// Set a json body and generate `Response`
@@ -372,9 +376,9 @@ impl HttpResponseBuilder {
                     self.insert_header((header::CONTENT_TYPE, mime::APPLICATION_JSON));
                 }
 
-                self.body(Body::from(body))
+                self.body(AnyBody::from(body))
             }
-            Err(err) => HttpResponse::from_error(JsonPayloadError::Serialize(err).into()),
+            Err(err) => HttpResponse::from_error(JsonPayloadError::Serialize(err)),
         }
     }
 
@@ -383,7 +387,7 @@ impl HttpResponseBuilder {
     /// `HttpResponseBuilder` can not be used after this call.
     #[inline]
     pub fn finish(&mut self) -> HttpResponse {
-        self.body(Body::Empty)
+        self.body(AnyBody::Empty)
     }
 
     /// This method construct new `HttpResponseBuilder`
@@ -412,7 +416,7 @@ impl From<HttpResponseBuilder> for HttpResponse {
     }
 }
 
-impl From<HttpResponseBuilder> for Response<Body> {
+impl From<HttpResponseBuilder> for Response<AnyBody> {
     fn from(mut builder: HttpResponseBuilder) -> Self {
         builder.finish().into()
     }
@@ -422,7 +426,6 @@ impl Future for HttpResponseBuilder {
     type Output = Result<HttpResponse, Error>;
 
     fn poll(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
-        eprintln!("httpresponse future error");
         Poll::Ready(Ok(self.finish()))
     }
 }
@@ -478,42 +481,42 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_json() {
-        let mut resp = HttpResponse::Ok().json(vec!["v1", "v2", "v3"]);
+        let resp = HttpResponse::Ok().json(vec!["v1", "v2", "v3"]);
         let ct = resp.headers().get(CONTENT_TYPE).unwrap();
         assert_eq!(ct, HeaderValue::from_static("application/json"));
         assert_eq!(
-            body::to_bytes(resp.take_body()).await.unwrap().as_ref(),
+            body::to_bytes(resp.into_body()).await.unwrap().as_ref(),
             br#"["v1","v2","v3"]"#
         );
 
-        let mut resp = HttpResponse::Ok().json(&["v1", "v2", "v3"]);
+        let resp = HttpResponse::Ok().json(&["v1", "v2", "v3"]);
         let ct = resp.headers().get(CONTENT_TYPE).unwrap();
         assert_eq!(ct, HeaderValue::from_static("application/json"));
         assert_eq!(
-            body::to_bytes(resp.take_body()).await.unwrap().as_ref(),
+            body::to_bytes(resp.into_body()).await.unwrap().as_ref(),
             br#"["v1","v2","v3"]"#
         );
 
         // content type override
-        let mut resp = HttpResponse::Ok()
+        let resp = HttpResponse::Ok()
             .insert_header((CONTENT_TYPE, "text/json"))
             .json(&vec!["v1", "v2", "v3"]);
         let ct = resp.headers().get(CONTENT_TYPE).unwrap();
         assert_eq!(ct, HeaderValue::from_static("text/json"));
         assert_eq!(
-            body::to_bytes(resp.take_body()).await.unwrap().as_ref(),
+            body::to_bytes(resp.into_body()).await.unwrap().as_ref(),
             br#"["v1","v2","v3"]"#
         );
     }
 
     #[actix_rt::test]
     async fn test_serde_json_in_body() {
-        let mut resp = HttpResponse::Ok().body(
+        let resp = HttpResponse::Ok().body(
             serde_json::to_vec(&serde_json::json!({ "test-key": "test-value" })).unwrap(),
         );
 
         assert_eq!(
-            body::to_bytes(resp.take_body()).await.unwrap().as_ref(),
+            body::to_bytes(resp.into_body()).await.unwrap().as_ref(),
             br#"{"test-key":"test-value"}"#
         );
     }
diff --git a/src/response/response.rs b/src/response/response.rs
index 31868fe0b..9dd804be0 100644
--- a/src/response/response.rs
+++ b/src/response/response.rs
@@ -8,7 +8,7 @@ use std::{
 };
 
 use actix_http::{
-    body::{Body, MessageBody, ResponseBody},
+    body::{AnyBody, Body, MessageBody},
     http::{header::HeaderMap, StatusCode},
     Extensions, Response, ResponseHead,
 };
@@ -25,12 +25,12 @@ use {
 use crate::{error::Error, HttpResponseBuilder};
 
 /// An HTTP Response
-pub struct HttpResponse<B = Body> {
+pub struct HttpResponse<B = AnyBody> {
     res: Response<B>,
-    error: Option<Error>,
+    pub(crate) error: Option<Error>,
 }
 
-impl HttpResponse<Body> {
+impl HttpResponse<AnyBody> {
     /// Create HTTP response builder with specific status.
     #[inline]
     pub fn build(status: StatusCode) -> HttpResponseBuilder {
@@ -48,21 +48,8 @@ impl HttpResponse<Body> {
 
     /// Create an error response.
     #[inline]
-    pub fn from_error(error: Error) -> Self {
-        let res = error.as_response_error().error_response();
-
-        Self {
-            res,
-            error: Some(error),
-        }
-    }
-
-    /// Convert response to response with body
-    pub fn into_body<B>(self) -> HttpResponse<B> {
-        HttpResponse {
-            res: self.res.into_body(),
-            error: self.error,
-        }
+    pub fn from_error(error: impl Into<Error>) -> Self {
+        error.into().as_response_error().error_response()
     }
 }
 
@@ -192,7 +179,7 @@ impl<B> HttpResponse<B> {
 
     /// Get body of this response
     #[inline]
-    pub fn body(&self) -> &ResponseBody<B> {
+    pub fn body(&self) -> &B {
         self.res.body()
     }
 
@@ -206,7 +193,7 @@ impl<B> HttpResponse<B> {
     }
 
     /// Split response and body
-    pub fn into_parts(self) -> (HttpResponse<()>, ResponseBody<B>) {
+    pub fn into_parts(self) -> (HttpResponse<()>, B) {
         let (head, body) = self.res.into_parts();
 
         (
@@ -229,7 +216,7 @@ impl<B> HttpResponse<B> {
     /// Set a body and return previous body value
     pub fn map_body<F, B2>(self, f: F) -> HttpResponse<B2>
     where
-        F: FnOnce(&mut ResponseHead, ResponseBody<B>) -> ResponseBody<B2>,
+        F: FnOnce(&mut ResponseHead, B) -> B2,
     {
         HttpResponse {
             res: self.res.map_body(f),
@@ -238,12 +225,15 @@ impl<B> HttpResponse<B> {
     }
 
     /// Extract response body
-    pub fn take_body(&mut self) -> ResponseBody<B> {
-        self.res.take_body()
+    pub fn into_body(self) -> B {
+        self.res.into_body()
     }
 }
 
-impl<B: MessageBody> fmt::Debug for HttpResponse<B> {
+impl<B> fmt::Debug for HttpResponse<B>
+where
+    B: MessageBody,
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("HttpResponse")
             .field("error", &self.error)
@@ -270,20 +260,25 @@ impl<B> From<HttpResponse<B>> for Response<B> {
 
         // TODO: expose cause somewhere?
         // if let Some(err) = res.error {
-        //     eprintln!("impl<B> From<HttpResponse<B>> for Response<B> let Some(err)");
-        //     return Response::from_error(err).into_body();
+        //     return Response::from_error(err);
         // }
 
         res.res
     }
 }
 
-impl Future for HttpResponse {
+// Future is only implemented for Body payload type because it's the most useful for making simple
+// handlers without async blocks. Making it generic over all MessageBody types requires a future
+// impl on Response which would cause it's body field to be, undesirably, Option<B>.
+//
+// This impl is not particularly efficient due to the Response construction and should probably
+// not be invoked if performance is important. Prefer an async fn/block in such cases.
+impl Future for HttpResponse<Body> {
     type Output = Result<Response<Body>, Error>;
 
     fn poll(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
         if let Some(err) = self.error.take() {
-            return Poll::Ready(Ok(Response::from_error(err).into_body()));
+            return Poll::Ready(Err(err));
         }
 
         Poll::Ready(Ok(mem::replace(
diff --git a/src/route.rs b/src/route.rs
index 0a297b456..44f7e30b8 100644
--- a/src/route.rs
+++ b/src/route.rs
@@ -2,19 +2,19 @@
 
 use std::{future::Future, rc::Rc};
 
-use actix_http::{http::Method, Error};
+use actix_http::http::Method;
 use actix_service::{
     boxed::{self, BoxService, BoxServiceFactory},
     Service, ServiceFactory,
 };
 use futures_core::future::LocalBoxFuture;
 
-use crate::extract::FromRequest;
-use crate::guard::{self, Guard};
-use crate::handler::{Handler, HandlerService};
-use crate::responder::Responder;
-use crate::service::{ServiceRequest, ServiceResponse};
-use crate::HttpResponse;
+use crate::{
+    guard::{self, Guard},
+    handler::{Handler, HandlerService},
+    service::{ServiceRequest, ServiceResponse},
+    Error, FromRequest, HttpResponse, Responder,
+};
 
 /// Resource route definition
 ///
@@ -188,7 +188,7 @@ impl Route {
 
 #[cfg(test)]
 mod tests {
-    use std::time::Duration;
+    use std::{convert::Infallible, time::Duration};
 
     use actix_rt::time::sleep;
     use bytes::Bytes;
@@ -215,7 +215,7 @@ mod tests {
                         }))
                         .route(web::post().to(|| async {
                             sleep(Duration::from_millis(100)).await;
-                            Ok::<_, ()>(HttpResponse::Created())
+                            Ok::<_, Infallible>(HttpResponse::Created())
                         }))
                         .route(web::delete().to(|| async {
                             sleep(Duration::from_millis(100)).await;
diff --git a/src/scope.rs b/src/scope.rs
index 3be6adb0c..412c01d95 100644
--- a/src/scope.rs
+++ b/src/scope.rs
@@ -578,7 +578,7 @@ mod tests {
     use actix_utils::future::ok;
     use bytes::Bytes;
 
-    use crate::dev::{Body, ResponseBody};
+    use crate::dev::Body;
     use crate::http::{header, HeaderValue, Method, StatusCode};
     use crate::middleware::DefaultHeaders;
     use crate::service::ServiceRequest;
@@ -748,7 +748,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
 
         match resp.response().body() {
-            ResponseBody::Body(Body::Bytes(ref b)) => {
+            Body::Bytes(ref b) => {
                 let bytes = b.clone();
                 assert_eq!(bytes, Bytes::from_static(b"project: project1"));
             }
@@ -849,7 +849,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::CREATED);
 
         match resp.response().body() {
-            ResponseBody::Body(Body::Bytes(ref b)) => {
+            Body::Bytes(ref b) => {
                 let bytes = b.clone();
                 assert_eq!(bytes, Bytes::from_static(b"project: project_1"));
             }
@@ -877,7 +877,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::CREATED);
 
         match resp.response().body() {
-            ResponseBody::Body(Body::Bytes(ref b)) => {
+            Body::Bytes(ref b) => {
                 let bytes = b.clone();
                 assert_eq!(bytes, Bytes::from_static(b"project: test - 1"));
             }
diff --git a/src/server.rs b/src/server.rs
index 6577f4d1f..89328215d 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,23 +1,25 @@
 use std::{
     any::Any,
-    cmp, fmt, io,
+    cmp,
+    error::Error as StdError,
+    fmt, io,
     marker::PhantomData,
     net,
     sync::{Arc, Mutex},
 };
 
-use actix_http::{
-    body::MessageBody, Error, Extensions, HttpService, KeepAlive, Request, Response,
-};
+use actix_http::{body::MessageBody, Extensions, HttpService, KeepAlive, Request, Response};
 use actix_server::{Server, ServerBuilder};
-use actix_service::{map_config, IntoServiceFactory, Service, ServiceFactory};
+use actix_service::{
+    map_config, IntoServiceFactory, Service, ServiceFactory, ServiceFactoryExt as _,
+};
 
 #[cfg(feature = "openssl")]
 use actix_tls::accept::openssl::{AlpnError, SslAcceptor, SslAcceptorBuilder};
 #[cfg(feature = "rustls")]
 use actix_tls::accept::rustls::ServerConfig as RustlsServerConfig;
 
-use crate::config::AppConfig;
+use crate::{config::AppConfig, Error};
 
 struct Socket {
     scheme: &'static str,
@@ -81,6 +83,7 @@ where
     S::Service: 'static,
     // S::Service: 'static,
     B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
     /// Create new HTTP server with application factory
     pub fn new(factory: F) -> Self {
@@ -173,6 +176,16 @@ where
         self
     }
 
+    /// Set max number of threads for each worker's blocking task thread pool.
+    ///
+    /// One thread pool is set up **per worker**; not shared across workers.
+    ///
+    /// By default set to 512 / workers.
+    pub fn worker_max_blocking_threads(mut self, num: usize) -> Self {
+        self.builder = self.builder.worker_max_blocking_threads(num);
+        self
+    }
+
     /// Set server keep-alive setting.
     ///
     /// By default keep alive is set to a 5 seconds.
@@ -290,7 +303,11 @@ where
                         svc
                     };
 
-                    svc.finish(map_config(factory(), move |_| {
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
+                    svc.finish(map_config(fac, move |_| {
                         AppConfig::new(false, host.clone(), addr)
                     }))
                     .tcp()
@@ -345,7 +362,11 @@ where
                         svc
                     };
 
-                    svc.finish(map_config(factory(), move |_| {
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
+                    svc.finish(map_config(fac, move |_| {
                         AppConfig::new(true, host.clone(), addr)
                     }))
                     .openssl(acceptor.clone())
@@ -357,7 +378,7 @@ where
     #[cfg(feature = "rustls")]
     /// Use listener for accepting incoming tls connection requests
     ///
-    /// This method sets alpn protocols to "h2" and "http/1.1"
+    /// This method prepends alpn protocols "h2" and "http/1.1" to configured ones
     pub fn listen_rustls(
         self,
         lst: net::TcpListener,
@@ -399,7 +420,11 @@ where
                         svc
                     };
 
-                    svc.finish(map_config(factory(), move |_| {
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
+                    svc.finish(map_config(fac, move |_| {
                         AppConfig::new(true, host.clone(), addr)
                     }))
                     .rustls(config.clone())
@@ -471,7 +496,7 @@ where
     #[cfg(feature = "rustls")]
     /// Start listening for incoming tls connections.
     ///
-    /// This method sets alpn protocols to "h2" and "http/1.1"
+    /// This method prepends alpn protocols "h2" and "http/1.1" to configured ones
     pub fn bind_rustls<A: net::ToSocketAddrs>(
         mut self,
         addr: A,
@@ -522,7 +547,11 @@ where
                     svc
                 };
 
-                svc.finish(map_config(factory(), move |_| config.clone()))
+                let fac = factory()
+                    .into_factory()
+                    .map_err(|err| err.into().error_response());
+
+                svc.finish(map_config(fac, move |_| config.clone()))
             })
         })?;
         Ok(self)
@@ -557,14 +586,20 @@ where
                     c.host.clone().unwrap_or_else(|| format!("{}", socket_addr)),
                     socket_addr,
                 );
+
+                let fac = factory()
+                    .into_factory()
+                    .map_err(|err| err.into().error_response());
+
                 fn_service(|io: UnixStream| async { Ok((io, Protocol::Http1, None)) }).and_then(
                     HttpService::build()
                         .keep_alive(c.keep_alive)
                         .client_timeout(c.client_timeout)
-                        .finish(map_config(factory(), move |_| config.clone())),
+                        .finish(map_config(fac, move |_| config.clone())),
                 )
             },
         )?;
+
         Ok(self)
     }
 }
diff --git a/src/service.rs b/src/service.rs
index 8e881c953..9ebeb77df 100644
--- a/src/service.rs
+++ b/src/service.rs
@@ -2,24 +2,24 @@ use std::cell::{Ref, RefMut};
 use std::rc::Rc;
 use std::{fmt, net};
 
-use actix_http::body::{Body, MessageBody, ResponseBody};
-use actix_http::http::{HeaderMap, Method, StatusCode, Uri, Version};
 use actix_http::{
-    Error, Extensions, HttpMessage, Payload, PayloadStream, RequestHead, Response, ResponseHead,
+    body::{AnyBody, MessageBody},
+    http::{HeaderMap, Method, StatusCode, Uri, Version},
+    Extensions, HttpMessage, Payload, PayloadStream, RequestHead, Response, ResponseHead,
 };
 use actix_router::{IntoPattern, Path, Resource, ResourceDef, Url};
 use actix_service::{IntoServiceFactory, ServiceFactory};
 #[cfg(feature = "cookies")]
 use cookie::{Cookie, ParseError as CookieParseError};
 
-use crate::dev::insert_slash;
-use crate::guard::Guard;
-use crate::info::ConnectionInfo;
-use crate::request::HttpRequest;
-use crate::rmap::ResourceMap;
 use crate::{
     config::{AppConfig, AppService},
-    HttpResponse,
+    dev::insert_slash,
+    guard::Guard,
+    info::ConnectionInfo,
+    request::HttpRequest,
+    rmap::ResourceMap,
+    Error, HttpResponse,
 };
 
 pub trait HttpServiceFactory {
@@ -116,9 +116,9 @@ impl ServiceRequest {
 
     /// Create service response for error
     #[inline]
-    pub fn error_response<B, E: Into<Error>>(self, err: E) -> ServiceResponse<B> {
+    pub fn error_response<E: Into<Error>>(self, err: E) -> ServiceResponse {
         let res = HttpResponse::from_error(err.into());
-        ServiceResponse::new(self.req, res.into_body())
+        ServiceResponse::new(self.req, res)
     }
 
     /// This method returns reference to the request head
@@ -336,27 +336,29 @@ impl fmt::Debug for ServiceRequest {
     }
 }
 
-pub struct ServiceResponse<B = Body> {
+pub struct ServiceResponse<B = AnyBody> {
     request: HttpRequest,
     response: HttpResponse<B>,
 }
 
+impl ServiceResponse<AnyBody> {
+    /// Create service response from the error
+    pub fn from_err<E: Into<Error>>(err: E, request: HttpRequest) -> Self {
+        let response = HttpResponse::from_error(err);
+        ServiceResponse { request, response }
+    }
+}
+
 impl<B> ServiceResponse<B> {
     /// Create service response instance
     pub fn new(request: HttpRequest, response: HttpResponse<B>) -> Self {
         ServiceResponse { request, response }
     }
 
-    /// Create service response from the error
-    pub fn from_err<E: Into<Error>>(err: E, request: HttpRequest) -> Self {
-        let response = HttpResponse::from_error(err.into()).into_body();
-        ServiceResponse { request, response }
-    }
-
     /// Create service response for error
     #[inline]
-    pub fn error_response<E: Into<Error>>(self, err: E) -> Self {
-        Self::from_err(err, self.request)
+    pub fn error_response<E: Into<Error>>(self, err: E) -> ServiceResponse {
+        ServiceResponse::from_err(err, self.request)
     }
 
     /// Create service response
@@ -402,23 +404,18 @@ impl<B> ServiceResponse<B> {
     }
 
     /// Execute closure and in case of error convert it to response.
-    pub fn checked_expr<F, E>(mut self, f: F) -> Self
+    pub fn checked_expr<F, E>(mut self, f: F) -> Result<Self, Error>
     where
         F: FnOnce(&mut Self) -> Result<(), E>,
         E: Into<Error>,
     {
-        match f(&mut self) {
-            Ok(_) => self,
-            Err(err) => {
-                let res = HttpResponse::from_error(err.into());
-                ServiceResponse::new(self.request, res.into_body())
-            }
-        }
+        f(&mut self).map_err(Into::into)?;
+        Ok(self)
     }
 
     /// Extract response body
-    pub fn take_body(&mut self) -> ResponseBody<B> {
-        self.response.take_body()
+    pub fn into_body(self) -> B {
+        self.response.into_body()
     }
 }
 
@@ -426,7 +423,7 @@ impl<B> ServiceResponse<B> {
     /// Set a new body
     pub fn map_body<F, B2>(self, f: F) -> ServiceResponse<B2>
     where
-        F: FnOnce(&mut ResponseHead, ResponseBody<B>) -> ResponseBody<B2>,
+        F: FnOnce(&mut ResponseHead, B) -> B2,
     {
         let response = self.response.map_body(f);
 
@@ -449,7 +446,11 @@ impl<B> From<ServiceResponse<B>> for Response<B> {
     }
 }
 
-impl<B: MessageBody> fmt::Debug for ServiceResponse<B> {
+impl<B> fmt::Debug for ServiceResponse<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let res = writeln!(
             f,
diff --git a/src/test.rs b/src/test.rs
index c2e456e58..de97dc8aa 100644
--- a/src/test.rs
+++ b/src/test.rs
@@ -4,13 +4,14 @@ use std::{net::SocketAddr, rc::Rc};
 
 pub use actix_http::test::TestBuffer;
 use actix_http::{
+    body,
     http::{header::IntoHeaderPair, Method, StatusCode, Uri, Version},
     test::TestRequest as HttpTestRequest,
     Extensions, Request,
 };
 use actix_router::{Path, ResourceDef, Url};
 use actix_service::{IntoService, IntoServiceFactory, Service, ServiceFactory};
-use actix_utils::future::ok;
+use actix_utils::future::{ok, poll_fn};
 use futures_core::Stream;
 use futures_util::StreamExt as _;
 use serde::{de::DeserializeOwned, Serialize};
@@ -151,17 +152,19 @@ pub async fn read_response<S, B>(app: &S, req: Request) -> Bytes
 where
     S: Service<Request, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody + Unpin,
+    B::Error: Into<Error>,
 {
-    let mut resp = app
+    let resp = app
         .call(req)
         .await
         .unwrap_or_else(|e| panic!("read_response failed at application call: {}", e));
 
-    let mut body = resp.take_body();
+    let body = resp.into_body();
     let mut bytes = BytesMut::new();
 
-    while let Some(item) = body.next().await {
-        bytes.extend_from_slice(&item.unwrap());
+    actix_rt::pin!(body);
+    while let Some(item) = poll_fn(|cx| body.as_mut().poll_next(cx)).await {
+        bytes.extend_from_slice(&item.map_err(Into::into).unwrap());
     }
 
     bytes.freeze()
@@ -193,15 +196,19 @@ where
 ///     assert_eq!(result, Bytes::from_static(b"welcome!"));
 /// }
 /// ```
-pub async fn read_body<B>(mut res: ServiceResponse<B>) -> Bytes
+pub async fn read_body<B>(res: ServiceResponse<B>) -> Bytes
 where
     B: MessageBody + Unpin,
+    B::Error: Into<Error>,
 {
-    let mut body = res.take_body();
+    let body = res.into_body();
     let mut bytes = BytesMut::new();
-    while let Some(item) = body.next().await {
-        bytes.extend_from_slice(&item.unwrap());
+
+    actix_rt::pin!(body);
+    while let Some(item) = poll_fn(|cx| body.as_mut().poll_next(cx)).await {
+        bytes.extend_from_slice(&item.map_err(Into::into).unwrap());
     }
+
     bytes.freeze()
 }
 
@@ -245,6 +252,7 @@ where
 pub async fn read_body_json<T, B>(res: ServiceResponse<B>) -> T
 where
     B: MessageBody + Unpin,
+    B::Error: Into<Error>,
     T: DeserializeOwned,
 {
     let body = read_body(res).await;
@@ -268,6 +276,14 @@ where
     Ok(data.freeze())
 }
 
+pub async fn load_body<B>(body: B) -> Result<Bytes, Error>
+where
+    B: MessageBody + Unpin,
+    B::Error: Into<Error>,
+{
+    body::to_bytes(body).await.map_err(Into::into)
+}
+
 /// Helper function that returns a deserialized response body of a TestRequest
 ///
 /// ```
@@ -306,6 +322,7 @@ pub async fn read_response_json<S, B, T>(app: &S, req: Request) -> T
 where
     S: Service<Request, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody + Unpin,
+    B::Error: Into<Error>,
     T: DeserializeOwned,
 {
     let body = read_response(app, req).await;
diff --git a/src/types/either.rs b/src/types/either.rs
index 210495e47..d3b003587 100644
--- a/src/types/either.rs
+++ b/src/types/either.rs
@@ -1,8 +1,14 @@
 //! For either helper, see [`Either`].
 
+use std::{
+    future::Future,
+    mem,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
 use bytes::Bytes;
-use futures_core::future::LocalBoxFuture;
-use futures_util::{FutureExt as _, TryFutureExt as _};
+use futures_core::ready;
 
 use crate::{
     dev,
@@ -180,41 +186,111 @@ where
     R: FromRequest + 'static,
 {
     type Error = EitherExtractError<L::Error, R::Error>;
-    type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>;
+    type Future = EitherExtractFut<L, R>;
     type Config = ();
 
     fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::Future {
-        let req2 = req.clone();
-
-        Bytes::from_request(req, payload)
-            .map_err(EitherExtractError::Bytes)
-            .and_then(|bytes| bytes_to_l_or_r(req2, bytes))
-            .boxed_local()
+        EitherExtractFut {
+            req: req.clone(),
+            state: EitherExtractState::Bytes {
+                bytes: Bytes::from_request(req, payload),
+            },
+        }
     }
 }
 
-async fn bytes_to_l_or_r<L, R>(
-    req: HttpRequest,
-    bytes: Bytes,
-) -> Result<Either<L, R>, EitherExtractError<L::Error, R::Error>>
+#[pin_project::pin_project]
+pub struct EitherExtractFut<L, R>
 where
-    L: FromRequest + 'static,
-    R: FromRequest + 'static,
+    R: FromRequest,
+    L: FromRequest,
 {
-    let fallback = bytes.clone();
-    let a_err;
+    req: HttpRequest,
+    #[pin]
+    state: EitherExtractState<L, R>,
+}
 
-    let mut pl = payload_from_bytes(bytes);
-    match L::from_request(&req, &mut pl).await {
-        Ok(a_data) => return Ok(Either::Left(a_data)),
-        // store A's error for returning if B also fails
-        Err(err) => a_err = err,
-    };
+#[pin_project::pin_project(project = EitherExtractProj)]
+pub enum EitherExtractState<L, R>
+where
+    L: FromRequest,
+    R: FromRequest,
+{
+    Bytes {
+        #[pin]
+        bytes: <Bytes as FromRequest>::Future,
+    },
+    Left {
+        #[pin]
+        left: L::Future,
+        fallback: Bytes,
+    },
+    Right {
+        #[pin]
+        right: R::Future,
+        left_err: Option<L::Error>,
+    },
+}
 
-    let mut pl = payload_from_bytes(fallback);
-    match R::from_request(&req, &mut pl).await {
-        Ok(b_data) => return Ok(Either::Right(b_data)),
-        Err(b_err) => Err(EitherExtractError::Extract(a_err, b_err)),
+impl<R, RF, RE, L, LF, LE> Future for EitherExtractFut<L, R>
+where
+    L: FromRequest<Future = LF, Error = LE>,
+    R: FromRequest<Future = RF, Error = RE>,
+    LF: Future<Output = Result<L, LE>> + 'static,
+    RF: Future<Output = Result<R, RE>> + 'static,
+    LE: Into<Error>,
+    RE: Into<Error>,
+{
+    type Output = Result<Either<L, R>, EitherExtractError<LE, RE>>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.project();
+        let ready = loop {
+            let next = match this.state.as_mut().project() {
+                EitherExtractProj::Bytes { bytes } => {
+                    let res = ready!(bytes.poll(cx));
+                    match res {
+                        Ok(bytes) => {
+                            let fallback = bytes.clone();
+                            let left =
+                                L::from_request(&this.req, &mut payload_from_bytes(bytes));
+                            EitherExtractState::Left { left, fallback }
+                        }
+                        Err(err) => break Err(EitherExtractError::Bytes(err)),
+                    }
+                }
+                EitherExtractProj::Left { left, fallback } => {
+                    let res = ready!(left.poll(cx));
+                    match res {
+                        Ok(extracted) => break Ok(Either::Left(extracted)),
+                        Err(left_err) => {
+                            let right = R::from_request(
+                                &this.req,
+                                &mut payload_from_bytes(mem::take(fallback)),
+                            );
+                            EitherExtractState::Right {
+                                left_err: Some(left_err),
+                                right,
+                            }
+                        }
+                    }
+                }
+                EitherExtractProj::Right { right, left_err } => {
+                    let res = ready!(right.poll(cx));
+                    match res {
+                        Ok(data) => break Ok(Either::Right(data)),
+                        Err(err) => {
+                            break Err(EitherExtractError::Extract(
+                                left_err.take().unwrap(),
+                                err,
+                            ));
+                        }
+                    }
+                }
+            };
+            this.state.set(next);
+        };
+        Poll::Ready(ready)
     }
 }
 
diff --git a/src/types/form.rs b/src/types/form.rs
index 9d2311a45..44d1b952e 100644
--- a/src/types/form.rs
+++ b/src/types/form.rs
@@ -12,11 +12,11 @@ use std::{
 use actix_http::Payload;
 use bytes::BytesMut;
 use encoding_rs::{Encoding, UTF_8};
-use futures_core::future::LocalBoxFuture;
+use futures_core::{future::LocalBoxFuture, ready};
 use futures_util::{FutureExt as _, StreamExt as _};
 use serde::{de::DeserializeOwned, Serialize};
 
-#[cfg(feature = "compress")]
+#[cfg(feature = "__compress")]
 use crate::dev::Decompress;
 use crate::{
     error::UrlencodedError, extract::FromRequest, http::header::CONTENT_LENGTH, web, Error,
@@ -123,11 +123,10 @@ where
 {
     type Config = FormConfig;
     type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<Self, Error>>;
+    type Future = FormExtractFut<T>;
 
     #[inline]
     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
-        let req2 = req.clone();
         let (limit, err_handler) = req
             .app_data::<Self::Config>()
             .or_else(|| {
@@ -137,16 +136,42 @@ where
             .map(|c| (c.limit, c.err_handler.clone()))
             .unwrap_or((16384, None));
 
-        UrlEncoded::new(req, payload)
-            .limit(limit)
-            .map(move |res| match res {
-                Err(err) => match err_handler {
-                    Some(err_handler) => Err((err_handler)(err, &req2)),
-                    None => Err(err.into()),
-                },
-                Ok(item) => Ok(Form(item)),
-            })
-            .boxed_local()
+        FormExtractFut {
+            fut: UrlEncoded::new(req, payload).limit(limit),
+            req: req.clone(),
+            err_handler,
+        }
+    }
+}
+
+type FormErrHandler = Option<Rc<dyn Fn(UrlencodedError, &HttpRequest) -> Error>>;
+
+pub struct FormExtractFut<T> {
+    fut: UrlEncoded<T>,
+    err_handler: FormErrHandler,
+    req: HttpRequest,
+}
+
+impl<T> Future for FormExtractFut<T>
+where
+    T: DeserializeOwned + 'static,
+{
+    type Output = Result<Form<T>, Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+
+        let res = ready!(Pin::new(&mut this.fut).poll(cx));
+
+        let res = match res {
+            Err(err) => match &this.err_handler {
+                Some(err_handler) => Err((err_handler)(err, &this.req)),
+                None => Err(err.into()),
+            },
+            Ok(item) => Ok(Form(item)),
+        };
+
+        Poll::Ready(res)
     }
 }
 
@@ -163,7 +188,7 @@ impl<T: Serialize> Responder for Form<T> {
             Ok(body) => HttpResponse::Ok()
                 .content_type(mime::APPLICATION_WWW_FORM_URLENCODED)
                 .body(body),
-            Err(err) => HttpResponse::from_error(UrlencodedError::Serialize(err).into()),
+            Err(err) => HttpResponse::from_error(UrlencodedError::Serialize(err)),
         }
     }
 }
@@ -193,7 +218,7 @@ impl<T: Serialize> Responder for Form<T> {
 #[derive(Clone)]
 pub struct FormConfig {
     limit: usize,
-    err_handler: Option<Rc<dyn Fn(UrlencodedError, &HttpRequest) -> Error>>,
+    err_handler: FormErrHandler,
 }
 
 impl FormConfig {
@@ -230,9 +255,9 @@ impl Default for FormConfig {
 /// - content type is not `application/x-www-form-urlencoded`
 /// - content length is greater than [limit](UrlEncoded::limit())
 pub struct UrlEncoded<T> {
-    #[cfg(feature = "compress")]
+    #[cfg(feature = "__compress")]
     stream: Option<Decompress<Payload>>,
-    #[cfg(not(feature = "compress"))]
+    #[cfg(not(feature = "__compress"))]
     stream: Option<Payload>,
 
     limit: usize,
@@ -268,10 +293,15 @@ impl<T> UrlEncoded<T> {
             }
         };
 
-        #[cfg(feature = "compress")]
-        let payload = Decompress::from_headers(payload.take(), req.headers());
-        #[cfg(not(feature = "compress"))]
-        let payload = payload.take();
+        let payload = {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "__compress")] {
+                    Decompress::from_headers(payload.take(), req.headers())
+                } else {
+                    payload.take()
+                }
+            }
+        };
 
         UrlEncoded {
             encoding,
diff --git a/src/types/json.rs b/src/types/json.rs
index 322e5cbf3..fc02c8854 100644
--- a/src/types/json.rs
+++ b/src/types/json.rs
@@ -16,7 +16,7 @@ use serde::{de::DeserializeOwned, Serialize};
 
 use actix_http::Payload;
 
-#[cfg(feature = "compress")]
+#[cfg(feature = "__compress")]
 use crate::dev::Decompress;
 use crate::{
     error::{Error, JsonPayloadError},
@@ -127,7 +127,7 @@ impl<T: Serialize> Responder for Json<T> {
             Ok(body) => HttpResponse::Ok()
                 .content_type(mime::APPLICATION_JSON)
                 .body(body),
-            Err(err) => HttpResponse::from_error(JsonPayloadError::Serialize(err).into()),
+            Err(err) => HttpResponse::from_error(JsonPayloadError::Serialize(err)),
         }
     }
 }
@@ -240,7 +240,7 @@ pub struct JsonConfig {
 }
 
 impl JsonConfig {
-    /// Set maximum accepted payload size. By default this limit is 32kB.
+    /// Set maximum accepted payload size. By default this limit is 2MB.
     pub fn limit(mut self, limit: usize) -> Self {
         self.limit = limit;
         self
@@ -273,9 +273,11 @@ impl JsonConfig {
     }
 }
 
+const DEFAULT_LIMIT: usize = 2_097_152; // 2 mb
+
 /// Allow shared refs used as default.
 const DEFAULT_CONFIG: JsonConfig = JsonConfig {
-    limit: 32_768, // 2^15 bytes, (~32kB)
+    limit: DEFAULT_LIMIT,
     err_handler: None,
     content_type: None,
 };
@@ -298,9 +300,9 @@ pub enum JsonBody<T> {
     Body {
         limit: usize,
         length: Option<usize>,
-        #[cfg(feature = "compress")]
+        #[cfg(feature = "__compress")]
         payload: Decompress<Payload>,
-        #[cfg(not(feature = "compress"))]
+        #[cfg(not(feature = "__compress"))]
         payload: Payload,
         buf: BytesMut,
         _res: PhantomData<T>,
@@ -343,13 +345,18 @@ where
         // As the internal usage always call JsonBody::limit after JsonBody::new.
         // And limit check to return an error variant of JsonBody happens there.
 
-        #[cfg(feature = "compress")]
-        let payload = Decompress::from_headers(payload.take(), req.headers());
-        #[cfg(not(feature = "compress"))]
-        let payload = payload.take();
+        let payload = {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "__compress")] {
+                    Decompress::from_headers(payload.take(), req.headers())
+                } else {
+                    payload.take()
+                }
+            }
+        };
 
         JsonBody::Body {
-            limit: 32_768,
+            limit: DEFAULT_LIMIT,
             length,
             payload,
             buf: BytesMut::with_capacity(8192),
@@ -357,7 +364,7 @@ where
         }
     }
 
-    /// Set maximum accepted payload size. The default limit is 32kB.
+    /// Set maximum accepted payload size. The default limit is 2MB.
     pub fn limit(self, limit: usize) -> Self {
         match self {
             JsonBody::Body {
@@ -368,7 +375,10 @@ where
             } => {
                 if let Some(len) = length {
                     if len > limit {
-                        return JsonBody::Error(Some(JsonPayloadError::Overflow));
+                        return JsonBody::Error(Some(JsonPayloadError::OverflowKnownLength {
+                            length: len,
+                            limit,
+                        }));
                     }
                 }
 
@@ -405,8 +415,11 @@ where
                 match res {
                     Some(chunk) => {
                         let chunk = chunk?;
-                        if (buf.len() + chunk.len()) > *limit {
-                            return Poll::Ready(Err(JsonPayloadError::Overflow));
+                        let buf_len = buf.len() + chunk.len();
+                        if buf_len > *limit {
+                            return Poll::Ready(Err(JsonPayloadError::Overflow {
+                                limit: *limit,
+                            }));
                         } else {
                             buf.extend_from_slice(&chunk);
                         }
@@ -435,7 +448,7 @@ mod tests {
             header::{self, CONTENT_LENGTH, CONTENT_TYPE},
             StatusCode,
         },
-        test::{load_stream, TestRequest},
+        test::{load_body, TestRequest},
     };
 
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -445,7 +458,12 @@ mod tests {
 
     fn json_eq(err: JsonPayloadError, other: JsonPayloadError) -> bool {
         match err {
-            JsonPayloadError::Overflow => matches!(other, JsonPayloadError::Overflow),
+            JsonPayloadError::Overflow { .. } => {
+                matches!(other, JsonPayloadError::Overflow { .. })
+            }
+            JsonPayloadError::OverflowKnownLength { .. } => {
+                matches!(other, JsonPayloadError::OverflowKnownLength { .. })
+            }
             JsonPayloadError::ContentType => matches!(other, JsonPayloadError::ContentType),
             _ => false,
         }
@@ -487,15 +505,15 @@ mod tests {
                 };
                 let resp =
                     HttpResponse::BadRequest().body(serde_json::to_string(&msg).unwrap());
-                InternalError::from_response(err, resp.into()).into()
+                InternalError::from_response(err, resp).into()
             }))
             .to_http_parts();
 
         let s = Json::<MyObject>::from_request(&req, &mut pl).await;
-        let mut resp = HttpResponse::from_error(s.err().unwrap());
+        let resp = HttpResponse::from_error(s.err().unwrap());
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
 
-        let body = load_stream(resp.take_body()).await.unwrap();
+        let body = load_body(resp.into_body()).await.unwrap();
         let msg: MyObject = serde_json::from_slice(&body).unwrap();
         assert_eq!(msg.name, "invalid request");
     }
@@ -538,7 +556,7 @@ mod tests {
 
         let s = Json::<MyObject>::from_request(&req, &mut pl).await;
         assert!(format!("{}", s.err().unwrap())
-            .contains("Json payload size is bigger than allowed"));
+            .contains("JSON payload (16 bytes) is larger than allowed (limit: 10 bytes)."));
 
         let (req, mut pl) = TestRequest::default()
             .insert_header((
@@ -589,7 +607,30 @@ mod tests {
         let json = JsonBody::<MyObject>::new(&req, &mut pl, None)
             .limit(100)
             .await;
-        assert!(json_eq(json.err().unwrap(), JsonPayloadError::Overflow));
+        assert!(json_eq(
+            json.err().unwrap(),
+            JsonPayloadError::OverflowKnownLength {
+                length: 10000,
+                limit: 100
+            }
+        ));
+
+        let (req, mut pl) = TestRequest::default()
+            .insert_header((
+                header::CONTENT_TYPE,
+                header::HeaderValue::from_static("application/json"),
+            ))
+            .set_payload(Bytes::from_static(&[0u8; 1000]))
+            .to_http_parts();
+
+        let json = JsonBody::<MyObject>::new(&req, &mut pl, None)
+            .limit(100)
+            .await;
+
+        assert!(json_eq(
+            json.err().unwrap(),
+            JsonPayloadError::Overflow { limit: 100 }
+        ));
 
         let (req, mut pl) = TestRequest::default()
             .insert_header((
@@ -686,6 +727,7 @@ mod tests {
         assert!(s.is_err());
 
         let err_str = s.err().unwrap().to_string();
-        assert!(err_str.contains("Json payload size is bigger than allowed"));
+        assert!(err_str
+            .contains("JSON payload (16 bytes) is larger than allowed (limit: 10 bytes)."));
     }
 }
diff --git a/src/types/path.rs b/src/types/path.rs
index 50e2cb510..9dab79414 100644
--- a/src/types/path.rs
+++ b/src/types/path.rs
@@ -2,12 +2,15 @@
 
 use std::{fmt, ops, sync::Arc};
 
-use actix_http::error::{Error, ErrorNotFound};
 use actix_router::PathDeserializer;
 use actix_utils::future::{ready, Ready};
 use serde::de;
 
-use crate::{dev::Payload, error::PathError, FromRequest, HttpRequest};
+use crate::{
+    dev::Payload,
+    error::{Error, ErrorNotFound, PathError},
+    FromRequest, HttpRequest,
+};
 
 /// Extract typed data from request path segments.
 ///
@@ -292,11 +295,8 @@ mod tests {
     async fn test_custom_err_handler() {
         let (req, mut pl) = TestRequest::with_uri("/name/user1/")
             .app_data(PathConfig::default().error_handler(|err, _| {
-                error::InternalError::from_response(
-                    err,
-                    HttpResponse::Conflict().finish().into(),
-                )
-                .into()
+                error::InternalError::from_response(err, HttpResponse::Conflict().finish())
+                    .into()
             }))
             .to_http_parts();
 
diff --git a/src/types/payload.rs b/src/types/payload.rs
index f88800855..3b0d1d6c6 100644
--- a/src/types/payload.rs
+++ b/src/types/payload.rs
@@ -7,14 +7,17 @@ use std::{
     task::{Context, Poll},
 };
 
-use actix_http::error::{ErrorBadRequest, PayloadError};
+use actix_http::error::PayloadError;
 use actix_utils::future::{ready, Either, Ready};
 use bytes::{Bytes, BytesMut};
 use encoding_rs::{Encoding, UTF_8};
 use futures_core::{ready, stream::Stream};
 use mime::Mime;
 
-use crate::{dev, http::header, web, Error, FromRequest, HttpMessage, HttpRequest};
+use crate::{
+    dev, error::ErrorBadRequest, http::header, web, Error, FromRequest, HttpMessage,
+    HttpRequest,
+};
 
 /// Extract a request's raw payload stream.
 ///
@@ -279,9 +282,9 @@ impl Default for PayloadConfig {
 pub struct HttpMessageBody {
     limit: usize,
     length: Option<usize>,
-    #[cfg(feature = "compress")]
+    #[cfg(feature = "__compress")]
     stream: dev::Decompress<dev::Payload>,
-    #[cfg(not(feature = "compress"))]
+    #[cfg(not(feature = "__compress"))]
     stream: dev::Payload,
     buf: BytesMut,
     err: Option<PayloadError>,
@@ -309,10 +312,15 @@ impl HttpMessageBody {
             }
         }
 
-        #[cfg(feature = "compress")]
-        let stream = dev::Decompress::from_headers(payload.take(), req.headers());
-        #[cfg(not(feature = "compress"))]
-        let stream = payload.take();
+        let stream = {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "__compress")] {
+                    dev::Decompress::from_headers(payload.take(), req.headers())
+                } else {
+                    payload.take()
+                }
+            }
+        };
 
         HttpMessageBody {
             stream,
diff --git a/src/types/query.rs b/src/types/query.rs
index 978d00b5f..613a438d3 100644
--- a/src/types/query.rs
+++ b/src/types/query.rs
@@ -267,7 +267,7 @@ mod tests {
         let req = TestRequest::with_uri("/name/user1/")
             .app_data(QueryConfig::default().error_handler(|e, _| {
                 let resp = HttpResponse::UnprocessableEntity().finish();
-                InternalError::from_response(e, resp.into()).into()
+                InternalError::from_response(e, resp).into()
             }))
             .to_srv_request();
 
diff --git a/tests/test_server.rs b/tests/test_server.rs
index 2760cc7fb..520eb5ce2 100644
--- a/tests/test_server.rs
+++ b/tests/test_server.rs
@@ -29,10 +29,11 @@ use openssl::{
     x509::X509,
 };
 use rand::{distributions::Alphanumeric, Rng};
+use zstd::stream::{read::Decoder as ZstdDecoder, write::Encoder as ZstdEncoder};
 
 use actix_web::dev::BodyEncoding;
 use actix_web::middleware::{Compress, NormalizePath, TrailingSlash};
-use actix_web::{dev, web, App, Error, HttpResponse};
+use actix_web::{web, App, Error, HttpResponse};
 
 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
                    Hello World Hello World Hello World Hello World Hello World \
@@ -160,9 +161,7 @@ async fn test_body_gzip2() {
     let srv = actix_test::start_with(actix_test::config().h1(), || {
         App::new()
             .wrap(Compress::new(ContentEncoding::Gzip))
-            .service(web::resource("/").route(web::to(|| {
-                HttpResponse::Ok().body(STR).into_body::<dev::Body>()
-            })))
+            .service(web::resource("/").route(web::to(|| HttpResponse::Ok().body(STR))))
     });
 
     let mut response = srv
@@ -478,6 +477,125 @@ async fn test_body_brotli() {
     assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
 }
 
+#[actix_rt::test]
+async fn test_body_zstd() {
+    let srv = actix_test::start_with(actix_test::config().h1(), || {
+        App::new()
+            .wrap(Compress::new(ContentEncoding::Zstd))
+            .service(web::resource("/").route(web::to(move || HttpResponse::Ok().body(STR))))
+    });
+
+    // client request
+    let mut response = srv
+        .get("/")
+        .append_header((ACCEPT_ENCODING, "zstd"))
+        .no_decompress()
+        .send()
+        .await
+        .unwrap();
+    assert!(response.status().is_success());
+
+    // read response
+    let bytes = response.body().await.unwrap();
+
+    // decode
+    let mut e = ZstdDecoder::new(&bytes[..]).unwrap();
+    let mut dec = Vec::new();
+    e.read_to_end(&mut dec).unwrap();
+    assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
+}
+
+#[actix_rt::test]
+async fn test_body_zstd_streaming() {
+    let srv = actix_test::start_with(actix_test::config().h1(), || {
+        App::new()
+            .wrap(Compress::new(ContentEncoding::Zstd))
+            .service(web::resource("/").route(web::to(move || {
+                HttpResponse::Ok()
+                    .streaming(TestBody::new(Bytes::from_static(STR.as_ref()), 24))
+            })))
+    });
+
+    // client request
+    let mut response = srv
+        .get("/")
+        .append_header((ACCEPT_ENCODING, "zstd"))
+        .no_decompress()
+        .send()
+        .await
+        .unwrap();
+    assert!(response.status().is_success());
+
+    // read response
+    let bytes = response.body().await.unwrap();
+
+    // decode
+    let mut e = ZstdDecoder::new(&bytes[..]).unwrap();
+    let mut dec = Vec::new();
+    e.read_to_end(&mut dec).unwrap();
+    assert_eq!(Bytes::from(dec), Bytes::from_static(STR.as_ref()));
+}
+
+#[actix_rt::test]
+async fn test_zstd_encoding() {
+    let srv = actix_test::start_with(actix_test::config().h1(), || {
+        App::new().service(
+            web::resource("/").route(web::to(move |body: Bytes| HttpResponse::Ok().body(body))),
+        )
+    });
+
+    let mut e = ZstdEncoder::new(Vec::new(), 5).unwrap();
+    e.write_all(STR.as_ref()).unwrap();
+    let enc = e.finish().unwrap();
+
+    // client request
+    let request = srv
+        .post("/")
+        .append_header((CONTENT_ENCODING, "zstd"))
+        .send_body(enc.clone());
+    let mut response = request.await.unwrap();
+    assert!(response.status().is_success());
+
+    // read response
+    let bytes = response.body().await.unwrap();
+    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
+}
+
+#[actix_rt::test]
+async fn test_zstd_encoding_large() {
+    let data = rand::thread_rng()
+        .sample_iter(&Alphanumeric)
+        .take(320_000)
+        .map(char::from)
+        .collect::<String>();
+
+    let srv = actix_test::start_with(actix_test::config().h1(), || {
+        App::new().service(
+            web::resource("/")
+                .app_data(web::PayloadConfig::new(320_000))
+                .route(web::to(move |body: Bytes| {
+                    HttpResponse::Ok().streaming(TestBody::new(body, 10240))
+                })),
+        )
+    });
+
+    let mut e = ZstdEncoder::new(Vec::new(), 5).unwrap();
+    e.write_all(data.as_ref()).unwrap();
+    let enc = e.finish().unwrap();
+
+    // client request
+    let request = srv
+        .post("/")
+        .append_header((CONTENT_ENCODING, "zstd"))
+        .send_body(enc.clone());
+    let mut response = request.await.unwrap();
+    assert!(response.status().is_success());
+
+    // read response
+    let bytes = response.body().limit(320_000).await.unwrap();
+    assert_eq!(bytes, Bytes::from(data));
+}
+
 #[actix_rt::test]
 async fn test_encoding() {
     let srv = actix_test::start_with(actix_test::config().h1(), || {
@@ -903,7 +1021,7 @@ async fn test_normalize() {
     let srv = actix_test::start_with(actix_test::config().h1(), || {
         App::new()
             .wrap(NormalizePath::new(TrailingSlash::Trim))
-            .service(web::resource("/one").route(web::to(|| HttpResponse::Ok().finish())))
+            .service(web::resource("/one").route(web::to(HttpResponse::Ok)))
     });
 
     let response = srv.get("/one/").send().await.unwrap();