diff --git a/src/derive/convert.rs b/src/derive/convert.rs
index 06a7597..6d98b6a 100644
--- a/src/derive/convert.rs
+++ b/src/derive/convert.rs
@@ -2,6 +2,21 @@ use crate::coder::{Buffer, Decoder, Encoder, Result, View};
 use crate::derive::{Decode, Encode};
 use core::num::NonZeroUsize;
 
+#[allow(unused)]
+macro_rules! impl_convert {
+    ($want: path, $have: ty) => {
+        impl Encode for $want {
+            type Encoder = crate::derive::convert::ConvertIntoEncoder<$have>;
+        }
+        impl<'a> Decode<'a> for $want {
+            type Decoder = crate::derive::convert::ConvertFromDecoder<'a, $have>;
+        }
+    };
+}
+
+#[allow(unused)]
+pub(crate) use impl_convert;
+
 // Like [`From`] but we can implement it ourselves.
 pub(crate) trait ConvertFrom<T>: Sized {
     fn convert_from(value: T) -> Self;
diff --git a/src/derive/impls.rs b/src/derive/impls.rs
index ca7eb39..4c98231 100644
--- a/src/derive/impls.rs
+++ b/src/derive/impls.rs
@@ -18,11 +18,6 @@ use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 use core::num::*;
 
-#[cfg(feature = "std")]
-use core::hash::{BuildHasher, Hash};
-#[cfg(feature = "std")]
-use std::collections::{HashMap, HashSet};
-
 macro_rules! impl_both {
     ($t:ty, $encoder:ident, $decoder:ident) => {
         impl Encode for $t {
@@ -33,6 +28,7 @@ macro_rules! impl_both {
         }
     };
 }
+pub(crate) use impl_both;
 impl_both!(bool, BoolEncoder, BoolDecoder);
 impl_both!(f32, F32Encoder, F32Decoder);
 impl_both!(String, StrEncoder, StrDecoder);
@@ -150,14 +146,6 @@ impl<T: Encode> Encode for BTreeSet<T> {
 impl<'a, T: Decode<'a> + Ord> Decode<'a> for BTreeSet<T> {
     type Decoder = VecDecoder<'a, T>;
 }
-#[cfg(feature = "std")]
-impl<T: Encode, S> Encode for HashSet<T, S> {
-    type Encoder = VecEncoder<T>;
-}
-#[cfg(feature = "std")]
-impl<'a, T: Decode<'a> + Eq + Hash, S: BuildHasher + Default> Decode<'a> for HashSet<T, S> {
-    type Decoder = VecDecoder<'a, T>;
-}
 
 impl<K: Encode, V: Encode> Encode for BTreeMap<K, V> {
     type Encoder = MapEncoder<K, V>;
@@ -165,16 +153,6 @@ impl<K: Encode, V: Encode> Encode for BTreeMap<K, V> {
 impl<'a, K: Decode<'a> + Ord, V: Decode<'a>> Decode<'a> for BTreeMap<K, V> {
     type Decoder = MapDecoder<'a, K, V>;
 }
-#[cfg(feature = "std")]
-impl<K: Encode, V: Encode, S> Encode for HashMap<K, V, S> {
-    type Encoder = MapEncoder<K, V>;
-}
-#[cfg(feature = "std")]
-impl<'a, K: Decode<'a> + Eq + Hash, V: Decode<'a>, S: BuildHasher + Default> Decode<'a>
-    for HashMap<K, V, S>
-{
-    type Decoder = MapDecoder<'a, K, V>;
-}
 
 impl<T: Encode, E: Encode> Encode for core::result::Result<T, E> {
     type Encoder = ResultEncoder<T, E>;
@@ -184,42 +162,49 @@ impl<'a, T: Decode<'a>, E: Decode<'a>> Decode<'a> for core::result::Result<T, E>
 }
 
 #[cfg(feature = "std")]
-macro_rules! impl_convert {
-    ($want: path, $have: ty) => {
-        impl Encode for $want {
-            type Encoder = super::convert::ConvertIntoEncoder<$have>;
-        }
-        impl<'a> Decode<'a> for $want {
-            type Decoder = super::convert::ConvertFromDecoder<'a, $have>;
-        }
-    };
-}
+mod with_std {
+    use super::*;
+    use crate::derive::convert::impl_convert;
+    use core::hash::{BuildHasher, Hash};
+    use std::collections::{HashMap, HashSet};
+
+    impl<T: Encode, S> Encode for HashSet<T, S> {
+        type Encoder = VecEncoder<T>;
+    }
+    impl<'a, T: Decode<'a> + Eq + Hash, S: BuildHasher + Default> Decode<'a> for HashSet<T, S> {
+        type Decoder = VecDecoder<'a, T>;
+    }
+    impl<K: Encode, V: Encode, S> Encode for HashMap<K, V, S> {
+        type Encoder = MapEncoder<K, V>;
+    }
+    impl<'a, K: Decode<'a> + Eq + Hash, V: Decode<'a>, S: BuildHasher + Default> Decode<'a>
+        for HashMap<K, V, S>
+    {
+        type Decoder = MapDecoder<'a, K, V>;
+    }
 
-#[cfg(feature = "std")]
-macro_rules! impl_ipvx_addr {
-    ($addr: ident, $repr: ident) => {
-        impl_convert!(std::net::$addr, $repr);
-    };
-}
+    macro_rules! impl_ipvx_addr {
+        ($addr: ident, $repr: ident) => {
+            impl_convert!(std::net::$addr, $repr);
+        };
+    }
 
-#[cfg(feature = "std")]
-impl_ipvx_addr!(Ipv4Addr, u32);
-#[cfg(feature = "std")]
-impl_ipvx_addr!(Ipv6Addr, u128);
-#[cfg(feature = "std")]
-impl_convert!(std::net::IpAddr, super::ip_addr::IpAddrConversion);
-#[cfg(feature = "std")]
-impl_convert!(
-    std::net::SocketAddrV4,
-    super::ip_addr::SocketAddrV4Conversion
-);
-#[cfg(feature = "std")]
-impl_convert!(
-    std::net::SocketAddrV6,
-    super::ip_addr::SocketAddrV6Conversion
-);
-#[cfg(feature = "std")]
-impl_convert!(std::net::SocketAddr, super::ip_addr::SocketAddrConversion);
+    impl_ipvx_addr!(Ipv4Addr, u32);
+    impl_ipvx_addr!(Ipv6Addr, u128);
+    impl_convert!(std::net::IpAddr, crate::derive::ip_addr::IpAddrConversion);
+    impl_convert!(
+        std::net::SocketAddrV4,
+        crate::derive::ip_addr::SocketAddrV4Conversion
+    );
+    impl_convert!(
+        std::net::SocketAddrV6,
+        crate::derive::ip_addr::SocketAddrV6Conversion
+    );
+    impl_convert!(
+        std::net::SocketAddr,
+        crate::derive::ip_addr::SocketAddrConversion
+    );
+}
 
 impl<T> Encode for PhantomData<T> {
     type Encoder = EmptyCoder;
diff --git a/src/derive/mod.rs b/src/derive/mod.rs
index fc4c6fc..6b114da 100644
--- a/src/derive/mod.rs
+++ b/src/derive/mod.rs
@@ -5,7 +5,7 @@ use alloc::vec::Vec;
 use core::num::NonZeroUsize;
 
 mod array;
-mod convert;
+pub(crate) mod convert;
 mod duration;
 mod empty;
 mod impls;
diff --git a/src/serde/de.rs b/src/serde/de.rs
index 9252dcd..da09a81 100644
--- a/src/serde/de.rs
+++ b/src/serde/de.rs
@@ -117,21 +117,23 @@ macro_rules! specify {
             _ => {
                 // Either create the correct decoder if unspecified or diverge via panic/error.
                 #[cold]
+                #[rustfmt::skip]
                 fn cold<'de>(decoder: &mut SerdeDecoder<'de>, input: &mut &'de [u8]) -> Result<()> {
                     let &mut SerdeDecoder::Unspecified { length } = decoder else {
-                            type_changed!()
-                        };
+                        type_changed!()
+                    };
                     *decoder = SerdeDecoder::$variant(Default::default());
                     decoder.populate(input, length)
                 }
                 cold(&mut *$self.decoder, &mut *$self.input)?;
             }
         }
+        #[rustfmt::skip]
         let SerdeDecoder::$variant(d) = &mut *$self.decoder else {
-                // Safety: `cold` gets called when decoder isn't the correct decoder. `cold` either
-                // errors or sets lazy to the correct decoder.
-                unsafe { core::hint::unreachable_unchecked() };
-            };
+            // Safety: `cold` gets called when decoder isn't the correct decoder. `cold` either
+            // errors or sets lazy to the correct decoder.
+            unsafe { core::hint::unreachable_unchecked() };
+        };
         d
     }};
 }