no_std support.

This PR is similar to other no-std PRs, however it takes the approach of
using the new [`core::error`] module in Rust 1.81. This means that no-std
mode has an MSRV of Rust 1.81, while the existing MSRV of 1.49 is still
supported for existing users, as suggested [here].

This PR also preserves semver compatibility, and avoids adding any new
dependencies or required features for existing users. And it avoids
modifying the tests and benchmark sources, as those don't need to be no-std.
And it avoids making any unrelated changes.

And, it adds CI coverage and README.md documentation.

[here]: #563 (comment)
[`core::error`]: https://doc.rust-lang.org/stable/core/error/index.html

Fixes #551.

Author: sunfishcode

.github/workflows/ci.yml

@@ -88,6 +88,19 @@ jobs:
       - name: Test
         run: cargo check -p http
 
+  no-std:
+    name: Check no_std
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Check
+        run: cargo check --no-default-features --features=no-std
+
   wasm:
     name: WASM
     #needs: [style]

Cargo.toml

@@ -33,13 +33,16 @@ exclude = [
 ]
 
 [features]
-default = ["std"]
-std = []
+default = ["std", "bytes/default", "fnv/default"]
+std = ["bytes/std", "fnv/std"]
+no-std = ["hashbrown", "ahash"]
 
 [dependencies]
-bytes = "1"
-fnv = "1.0.5"
+bytes = { version = "1", default-features = false }
+fnv = { version = "1.0.5", default-features = false }
 itoa = "1"
+hashbrown = { version = "0.15.2", optional = true }
+ahash = { version = "0.8.6", default-features = false, optional = true }
 
 [dev-dependencies]
 quickcheck = "1"

README.md

@@ -66,6 +66,11 @@ This project follows the [Tokio MSRV][msrv] and is currently set to `1.49`.
 
 [msrv]: https://github.com/tokio-rs/tokio/#supported-rust-versions
 
+# no-std support
+
+For no-std support, disable the default "std" feature and enable the "no-std"
+feature. no-std support has an MSRV of Rust 1.81.
+
 # License
 
 Licensed under either of

src/byte_str.rs

@@ -1,6 +1,7 @@
 use bytes::Bytes;
 
-use std::{ops, str};
+use alloc::string::String;
+use core::{ops, str};
 
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub(crate) struct ByteStr {
@@ -46,7 +47,7 @@ impl ByteStr {
         ByteStr { bytes }
     }
 
-    pub(crate) fn from_utf8(bytes: Bytes) -> Result<ByteStr, std::str::Utf8Error> {
+    pub(crate) fn from_utf8(bytes: Bytes) -> Result<ByteStr, core::str::Utf8Error> {
         str::from_utf8(&bytes)?;
         // Invariant: just checked is utf8
         Ok(ByteStr { bytes })

src/convert.rs

@@ -1,11 +1,11 @@
 macro_rules! if_downcast_into {
     ($in_ty:ty, $out_ty:ty, $val:ident, $body:expr) => {{
-        if std::any::TypeId::of::<$in_ty>() == std::any::TypeId::of::<$out_ty>() {
+        if core::any::TypeId::of::<$in_ty>() == core::any::TypeId::of::<$out_ty>() {
             // Store the value in an `Option` so we can `take`
             // it after casting to `&mut dyn Any`.
             let mut slot = Some($val);
             // Re-write the `$val` ident with the downcasted value.
-            let $val = (&mut slot as &mut dyn std::any::Any)
+            let $val = (&mut slot as &mut dyn core::any::Any)
                 .downcast_mut::<Option<$out_ty>>()
                 .unwrap()
                 .take()

src/error.rs

@@ -1,6 +1,9 @@
+#[cfg(not(feature = "std"))]
+use core::error;
+use core::fmt;
+use core::result;
+#[cfg(feature = "std")]
 use std::error;
-use std::fmt;
-use std::result;
 
 use crate::header;
 use crate::header::MaxSizeReached;
@@ -132,8 +135,8 @@ impl From<header::InvalidHeaderValue> for Error {
     }
 }
 
-impl From<std::convert::Infallible> for Error {
-    fn from(err: std::convert::Infallible) -> Error {
+impl From<core::convert::Infallible> for Error {
+    fn from(err: core::convert::Infallible) -> Error {
         match err {}
     }
 }

src/extensions.rs

@@ -1,7 +1,11 @@
-use std::any::{Any, TypeId};
+use alloc::boxed::Box;
+use core::any::{Any, TypeId};
+use core::fmt;
+use core::hash::{BuildHasherDefault, Hasher};
+#[cfg(not(feature = "std"))]
+use hashbrown::HashMap;
+#[cfg(feature = "std")]
 use std::collections::HashMap;
-use std::fmt;
-use std::hash::{BuildHasherDefault, Hasher};
 
 type AnyMap = HashMap<TypeId, Box<dyn AnyClone + Send + Sync>, BuildHasherDefault<IdHasher>>;
 

src/header/map.rs

@@ -1,10 +1,15 @@
-use std::collections::hash_map::RandomState;
-use std::collections::HashMap;
-use std::convert::TryFrom;
-use std::hash::{BuildHasher, Hash, Hasher};
-use std::iter::{FromIterator, FusedIterator};
-use std::marker::PhantomData;
-use std::{fmt, mem, ops, ptr, vec};
+use alloc::boxed::Box;
+use alloc::vec;
+use alloc::vec::Vec;
+use core::convert::TryFrom;
+use core::hash::{BuildHasher, Hash, Hasher};
+use core::iter::{FromIterator, FusedIterator};
+use core::marker::PhantomData;
+use core::{fmt, mem, ops, ptr};
+#[cfg(feature = "std")]
+use std::collections::{hash_map::RandomState, HashMap};
+#[cfg(not(feature = "std"))]
+use {ahash::RandomState, hashbrown::HashMap};
 
 use crate::Error;
 
@@ -116,7 +121,7 @@ pub struct IntoIter<T> {
 /// associated value.
 #[derive(Debug)]
 pub struct Keys<'a, T> {
-    inner: ::std::slice::Iter<'a, Bucket<T>>,
+    inner: ::core::slice::Iter<'a, Bucket<T>>,
 }
 
 /// `HeaderMap` value iterator.
@@ -209,7 +214,7 @@ pub struct ValueIterMut<'a, T> {
 #[derive(Debug)]
 pub struct ValueDrain<'a, T> {
     first: Option<T>,
-    next: Option<::std::vec::IntoIter<T>>,
+    next: Option<::alloc::vec::IntoIter<T>>,
     lt: PhantomData<&'a mut HeaderMap<T>>,
 }
 
@@ -3574,7 +3579,10 @@ impl fmt::Display for MaxSizeReached {
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for MaxSizeReached {}
+#[cfg(not(feature = "std"))]
+impl core::error::Error for MaxSizeReached {}
 
 // ===== impl Utils =====
 
@@ -3736,6 +3744,7 @@ mod into_header_name {
 
 mod as_header_name {
     use super::{Entry, HdrName, HeaderMap, HeaderName, InvalidHeaderName, MaxSizeReached};
+    use alloc::string::String;
 
     /// A marker trait used to identify values that can be used as search keys
     /// to a `HeaderMap`.

src/header/name.rs

@@ -1,13 +1,18 @@
 use crate::byte_str::ByteStr;
 use bytes::{Bytes, BytesMut};
 
-use std::borrow::Borrow;
-use std::convert::TryFrom;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::borrow::Borrow;
+use core::convert::TryFrom;
+#[cfg(not(feature = "std"))]
+use core::error::Error;
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::mem::MaybeUninit;
+use core::str::FromStr;
+#[cfg(feature = "std")]
 use std::error::Error;
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::mem::MaybeUninit;
-use std::str::FromStr;
 
 /// Represents an HTTP header field name
 ///
@@ -89,7 +94,7 @@ macro_rules! standard_headers {
                 match *self {
                     // Safety: test_parse_standard_headers ensures these &[u8]s are &str-safe.
                     $(
-                    StandardHeader::$konst => unsafe { std::str::from_utf8_unchecked( $name_bytes ) },
+                    StandardHeader::$konst => unsafe { core::str::from_utf8_unchecked( $name_bytes ) },
                     )+
                 }
             }

src/header/value.rs

@@ -1,11 +1,16 @@
 use bytes::{Bytes, BytesMut};
 
-use std::convert::TryFrom;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::convert::TryFrom;
+#[cfg(not(feature = "std"))]
+use core::error::Error;
+use core::fmt::Write;
+use core::hash::{Hash, Hasher};
+use core::str::FromStr;
+use core::{cmp, fmt, str};
+#[cfg(feature = "std")]
 use std::error::Error;
-use std::fmt::Write;
-use std::hash::{Hash, Hasher};
-use std::str::FromStr;
-use std::{cmp, fmt, str};
 
 use crate::header::name::HeaderName;
 
@@ -234,7 +239,7 @@ impl HeaderValue {
     }
 
     fn from_shared(src: Bytes) -> Result<HeaderValue, InvalidHeaderValue> {
-        HeaderValue::try_from_generic(src, std::convert::identity)
+        HeaderValue::try_from_generic(src, core::convert::identity)
     }
 
     fn try_from_generic<T: AsRef<[u8]>, F: FnOnce(T) -> Bytes>(