Tweak preserves::ser API

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, &placeholders)).unwrap();
         println!("== w bytes = {:?}", v_bytes_1);
         println!("== v bytes = {:?}", v_bytes_2);
         assert_eq!(v_bytes_1, v_bytes_2);

implementations/rust/src/ser.rs

@@ -14,15 +14,15 @@ pub struct Error {
     inner: writer::Error,
 }
 
-impl std::convert::From<writer::Error> for Error {
-    fn from(inner: writer::Error) -> Self {
-        Error { inner }
+impl std::convert::From<Error> for writer::Error {
+    fn from(e: Error) -> Self {
+        e.inner
     }
 }
 
-impl<D: super::value::Domain> std::convert::From<crate::value::error::Error<D>> for Error {
-    fn from(_inner: crate::value::error::Error<D>) -> Self {
-        magic_error()
+impl std::convert::From<writer::Error> for Error {
+    fn from(inner: writer::Error) -> Self {
+        Error { inner }
     }
 }
 
@@ -47,7 +47,7 @@ pub struct Serializer<W: Writer, N: NestedValue<D>, D: Domain> {
 }
 
 impl<W: Writer, N: NestedValue<D>, D: Domain> Serializer<W, N, D> {
-    pub fn new(write: W, placeholders: DecodePlaceholderMap<N, D>) -> Self {
+    pub fn new(write: W, placeholders: &DecodePlaceholderMap<N, D>) -> Self {
         Serializer { write, placeholders: Some(invert_map(&placeholders)) }
     }
 
@@ -57,9 +57,7 @@ impl<W: Writer, N: NestedValue<D>, D: Domain> Serializer<W, N, D> {
             None => Ok(self.write.write_symbol(s)?),
         }
     }
-}
 
-impl<W: Writer> Serializer<W, PlainValue<NullDomain>, NullDomain> {
     pub fn without_placeholders(write: W) -> Self {
         Serializer { write, placeholders: None }
     }
@@ -71,11 +69,6 @@ pub struct SerializeCompound<'a, W: Writer, N: NestedValue<D>, D: Domain> {
     count: Option<usize>,
 }
 
-fn magic_error() -> Error {
-    Error { inner: writer::Error::new(std::io::ErrorKind::InvalidData,
-                                      "Internal error handling magic Value encoding") }
-}
-
 impl<'a, W: Writer, N: NestedValue<D>, D: Domain> serde::Serializer for &'a mut Serializer<W, N, D> {
     type Ok = ();
     type Error = Error;
@@ -399,6 +392,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::without_placeholders(write);
+    let mut ser: Serializer<W, PlainValue<NullDomain>, NullDomain> =
+        Serializer::without_placeholders(write);
     value.serialize(&mut ser)
 }