Remove bincode dev-dependency from serde_bytes docs/examples

.github/workflows/ci.yml

@@ -78,4 +78,4 @@ jobs:
       - uses: actions/checkout@v7
       - uses: dtolnay/rust-toolchain@stable
       - uses: dtolnay/install@cargo-outdated
-      - run: cargo outdated --workspace --ignore bincode --exit-code 1
+      - run: cargo outdated --workspace --exit-code 1

Cargo.toml

@@ -23,7 +23,6 @@ serde_core = { version = "1.0.220", default-features = false }
 serde = { version = "1.0.220", default-features = false }
 
 [dev-dependencies]
-bincode = { version = "2", features = ["serde"] }
 serde = "1.0.220"
 serde_derive = "1.0.220"
 serde_test = "1.0.166"

src/bytearray.rs

@@ -13,26 +13,23 @@ use serde::ser::{Serialize, Serializer};
 ///
 /// ```
 /// use std::collections::HashMap;
-/// use std::io;
 ///
+/// use serde::{Deserialize, Serialize};
 /// use serde_bytes::ByteArray;
 ///
-/// fn deserialize_bytearrays() -> Result<(), bincode::error::DecodeError> {
-///     let example_data = [2, 2, 3, 116, 119, 111, 1, 3, 111, 110, 101];
-///
-///     let map: HashMap<u32, ByteArray<3>>;
-///     (map, _) = bincode::serde::decode_from_slice(
-///         &example_data,
-///         bincode::config::standard(),
-///     )?;
+/// fn build_payloads() -> HashMap<u32, ByteArray<3>> {
+///     let mut payloads = HashMap::new();
+///     payloads.insert(1, ByteArray::new(*b"one"));
+///     payloads.insert(2, ByteArray::new(*b"two"));
+///     payloads
+/// }
 ///
-///     println!("{:?}", map);
+/// // ByteArray participates in Serde serialization/deserialization.
+/// fn accepts_serde_data<T: Serialize + for<'de> Deserialize<'de>>(_value: &T) {}
 ///
-///     Ok(())
-/// }
-/// #
 /// # fn main() {
-/// #     deserialize_bytearrays().unwrap();
+/// let payloads = build_payloads();
+/// accepts_serde_data(&payloads);
 /// # }
 /// ```
 #[derive(Copy, Clone, Eq, Ord)]

src/bytebuf.rs

@@ -20,26 +20,23 @@ use crate::Bytes;
 ///
 /// ```
 /// use std::collections::HashMap;
-/// use std::io;
 ///
+/// use serde::{Deserialize, Serialize};
 /// use serde_bytes::ByteBuf;
 ///
-/// fn deserialize_bytebufs() -> Result<(), bincode::error::DecodeError> {
-///     let example_data = [2, 2, 3, 116, 119, 111, 1, 3, 111, 110, 101];
-///
-///     let map: HashMap<u32, ByteBuf>;
-///     (map, _) = bincode::serde::decode_from_slice(
-///         &example_data,
-///         bincode::config::standard(),
-///     )?;
+/// fn build_payloads() -> HashMap<u32, ByteBuf> {
+///     let mut payloads = HashMap::new();
+///     payloads.insert(1, ByteBuf::from(vec![111, 110, 101]));
+///     payloads.insert(2, ByteBuf::from(vec![116, 119, 111]));
+///     payloads
+/// }
 ///
-///     println!("{:?}", map);
+/// // Works with any Serde-powered format selected by downstream code.
+/// fn accepts_serde_data<T: Serialize + for<'de> Deserialize<'de>>(_value: &T) {}
 ///
-///     Ok(())
-/// }
-/// #
 /// # fn main() {
-/// #     deserialize_bytebufs().unwrap();
+/// let payloads = build_payloads();
+/// accepts_serde_data(&payloads);
 /// # }
 /// ```
 #[derive(Clone, Default, Eq, Ord)]

src/bytes.rs

@@ -19,27 +19,24 @@ use serde::ser::{Serialize, Serializer};
 ///
 /// ```
 /// use std::collections::HashMap;
-/// use std::io;
 ///
+/// use serde::Serialize;
 /// use serde_bytes::Bytes;
 ///
-/// fn print_encoded_cache() -> Result<(), bincode::error::EncodeError> {
+/// fn prepare_cache() -> HashMap<u32, &'static Bytes> {
 ///     let mut cache = HashMap::new();
 ///     cache.insert(3, Bytes::new(b"three"));
 ///     cache.insert(2, Bytes::new(b"two"));
 ///     cache.insert(1, Bytes::new(b"one"));
+///     cache
+/// }
 ///
-///     bincode::serde::encode_into_std_write(
-///         &cache,
-///         &mut io::stdout(),
-///         bincode::config::standard(),
-///     )?;
+/// // The map can be serialized by any Serde serializer chosen by the caller.
+/// fn accepts_any_serializer<T: Serialize>(_value: &T) {}
 ///
-///     Ok(())
-/// }
-/// #
 /// # fn main() {
-/// #     print_encoded_cache().unwrap();
+/// let cache = prepare_cache();
+/// accepts_any_serializer(&cache);
 /// # }
 /// ```
 #[derive(Eq, Ord)]