diff --git a/implementations/rust/Cargo.toml b/implementations/rust/Cargo.toml
index 5c45cbe..29e3c27 100644
--- a/implementations/rust/Cargo.toml
+++ b/implementations/rust/Cargo.toml
@@ -16,3 +16,4 @@ num = "0.2"
 num_enum = "0.4.1"
 serde = { version = "1.0", features = ["derive"] }
 serde_bytes = "0.11"
+bytes = "0.5.4"
diff --git a/implementations/rust/src/lib.rs b/implementations/rust/src/lib.rs
index ad97d9c..9681839 100644
--- a/implementations/rust/src/lib.rs
+++ b/implementations/rust/src/lib.rs
@@ -402,7 +402,7 @@ mod samples_tests {
         placeholders.insert(0, Value::symbol("SimpleValue"));
         let v_bytes_1 = Codec::new(placeholders.clone()).encode_bytes(&w).unwrap();
         let mut v_bytes_2 = Vec::new();
-        v.serialize(&mut crate::ser::Serializer::new(&mut v_bytes_2, &placeholders)).unwrap();
+        v.serialize(&mut crate::ser::Serializer::new(&mut v_bytes_2, Some(&crate::value::invert_map(&placeholders)))).unwrap();
         println!("== w bytes = {:?}", v_bytes_1);
         println!("== v bytes = {:?}", v_bytes_2);
         assert_eq!(v_bytes_1, v_bytes_2);
diff --git a/implementations/rust/src/ser.rs b/implementations/rust/src/ser.rs
index 1e78760..aba3ea9 100644
--- a/implementations/rust/src/ser.rs
+++ b/implementations/rust/src/ser.rs
@@ -3,7 +3,7 @@ use super::value::writer::{self, Writer};
 use super::value::{
     Value, NestedValue, PlainValue,
     Domain, NullDomain,
-    DecodePlaceholderMap, EncodePlaceholderMap, invert_map,
+    EncodePlaceholderMap,
     Encoder,
 };
 
@@ -41,14 +41,14 @@ impl std::fmt::Display for Error {
 impl std::error::Error for Error {}
 
 #[derive(Debug)]
-pub struct Serializer<W: Writer, N: NestedValue<D>, D: Domain> {
-    pub write: W,
-    placeholders: Option<EncodePlaceholderMap<N, D>>,
+pub struct Serializer<'a, W: Writer, N: NestedValue<D>, D: Domain> {
+    pub write: &'a mut W,
+    placeholders: Option<&'a EncodePlaceholderMap<N, D>>,
 }
 
-impl<W: Writer, N: NestedValue<D>, D: Domain> Serializer<W, N, D> {
-    pub fn new(write: W, placeholders: &DecodePlaceholderMap<N, D>) -> Self {
-        Serializer { write, placeholders: Some(invert_map(&placeholders)) }
+impl<'a, W: Writer, N: NestedValue<D>, D: Domain> Serializer<'a, W, N, D> {
+    pub fn new(write: &'a mut W, placeholders: Option<&'a EncodePlaceholderMap<N, D>>) -> Self {
+        Serializer { write, placeholders }
     }
 
     fn write_symbol(&mut self, s: &str) -> Result<()> {
@@ -57,28 +57,24 @@ impl<W: Writer, N: NestedValue<D>, D: Domain> Serializer<W, N, D> {
             None => Ok(self.write.write_symbol(s)?),
         }
     }
-
-    pub fn without_placeholders(write: W) -> Self {
-        Serializer { write, placeholders: None }
-    }
 }
 
 #[derive(Debug)]
-pub struct SerializeCompound<'a, W: Writer, N: NestedValue<D>, D: Domain> {
-    ser: &'a mut Serializer<W, N, D>,
+pub struct SerializeCompound<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> {
+    ser: &'a mut Serializer<'b, W, N, D>,
     count: Option<usize>,
 }
 
-impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a mut Serializer<W, N, D> {
+impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a mut Serializer<'b, W, N, D> {
     type Ok = ();
     type Error = Error;
-    type SerializeSeq = SerializeCompound<'a, W, N, D>;
-    type SerializeTuple = SerializeCompound<'a, W, N, D>;
-    type SerializeTupleStruct = SerializeCompound<'a, W, N, D>;
-    type SerializeTupleVariant = SerializeCompound<'a, W, N, D>;
-    type SerializeMap = SerializeCompound<'a, W, N, D>;
-    type SerializeStruct = SerializeCompound<'a, W, N, D>;
-    type SerializeStructVariant = SerializeCompound<'a, W, N, D>;
+    type SerializeSeq = SerializeCompound<'a, 'b, W, N, D>;
+    type SerializeTuple = SerializeCompound<'a, 'b, W, N, D>;
+    type SerializeTupleStruct = SerializeCompound<'a, 'b, W, N, D>;
+    type SerializeTupleVariant = SerializeCompound<'a, 'b, W, N, D>;
+    type SerializeMap = SerializeCompound<'a, 'b, W, N, D>;
+    type SerializeStruct = SerializeCompound<'a, 'b, W, N, D>;
+    type SerializeStructVariant = SerializeCompound<'a, 'b, W, N, D>;
 
     fn serialize_bool(self, v: bool) -> Result<()> {
         Ok(self.write.write_bool(v)?)
@@ -181,12 +177,12 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a mut
         if name == crate::value::value::MAGIC_VALUE {
             let b = unsafe { Box::from_raw(*((value as *const T) as *const u64) as *mut &Value<N, D>) };
             let v: &Value<N, D> = *b;
-            Encoder::new(&mut self.write, self.placeholders.as_ref()).write_value(v)?;
+            Encoder::new(self.write, self.placeholders).write_value(v)?;
             Ok(())
         } else if name == crate::value::value::MAGIC_NESTEDVALUE {
             let b = unsafe { Box::from_raw(*((value as *const T) as *const u64) as *mut &N) };
             let v: &N = *b;
-            Encoder::new(&mut self.write, self.placeholders.as_ref()).write(v)?;
+            Encoder::new(self.write, self.placeholders).write(v)?;
             Ok(())
         } else {
             // TODO: This is apparently discouraged, and we should apparently just serialize `value`?
@@ -271,7 +267,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a mut
     }
 }
 
-impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeCompound<'a, W, N, D> {
+impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for SerializeCompound<'a, 'b, W, N, D> {
     type Ok = ();
     type Error = Error;
 
@@ -291,7 +287,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeMap for S
     }
 }
 
-impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeCompound<'a, W, N, D> {
+impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct for SerializeCompound<'a, 'b, W, N, D> {
     type Ok = ();
     type Error = Error;
 
@@ -309,7 +305,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStruct fo
     }
 }
 
-impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for SerializeCompound<'a, W, N, D> {
+impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVariant for SerializeCompound<'a, 'b, W, N, D> {
     type Ok = ();
     type Error = Error;
 
@@ -327,7 +323,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeStructVar
     }
 }
 
-impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeCompound<'a, W, N, D> {
+impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for SerializeCompound<'a, 'b, W, N, D> {
     type Ok = ();
     type Error = Error;
 
@@ -343,7 +339,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTuple for
     }
 }
 
-impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for SerializeCompound<'a, W, N, D> {
+impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStruct for SerializeCompound<'a, 'b, W, N, D> {
     type Ok = ();
     type Error = Error;
 
@@ -359,7 +355,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleStru
     }
 }
 
-impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for SerializeCompound<'a, W, N, D> {
+impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVariant for SerializeCompound<'a, 'b, W, N, D> {
     type Ok = ();
     type Error = Error;
 
@@ -375,7 +371,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeTupleVari
     }
 }
 
-impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeCompound<'a, W, N, D> {
+impl<'a, 'b, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for SerializeCompound<'a, 'b, W, N, D> {
     type Ok = ();
     type Error = Error;
 
@@ -391,8 +387,7 @@ impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::ser::SerializeSeq for S
     }
 }
 
-pub fn to_writer<W: Writer, T: Serialize>(write: W, value: &T) -> Result<()> {
-    let mut ser: Serializer<W, PlainValue<NullDomain>, NullDomain> =
-        Serializer::without_placeholders(write);
+pub fn to_writer<W: Writer, T: Serialize>(write: &mut W, value: &T) -> Result<()> {
+    let mut ser: Serializer<'_, W, PlainValue<NullDomain>, NullDomain> = Serializer::new(write, None);
     value.serialize(&mut ser)
 }