Make SequenceWriter generic over Error type

examples/no_std.rs

@@ -17,11 +17,13 @@ fn main() {
     };
 
     let computed = asn1::write(|w| {
-        w.write_element(&asn1::SequenceWriter::new(&|w: &mut asn1::Writer| {
-            w.write_element(&1i64)?;
-            w.write_element(&3i64)?;
-            Ok(())
-        }))
+        w.write_element(&asn1::SequenceWriter::<asn1::WriteError>::new(
+            &|w: &mut asn1::Writer| {
+                w.write_element(&1i64)?;
+                w.write_element(&3i64)?;
+                Ok(())
+            },
+        ))
     })
     .unwrap();
     unsafe {

src/lib.rs

@@ -43,7 +43,7 @@
 //! # let r = 0u64;
 //! # let s = 0u64;
 //! let result = asn1::write(|w| {
-//!     w.write_element(&asn1::SequenceWriter::new(&|w| {
+//!     w.write_element(&asn1::SequenceWriter::<asn1::WriteError>::new(&|w| {
 //!         w.write_element(&r)?;
 //!         w.write_element(&s)?;
 //!         Ok(())

src/types.rs

@@ -1668,22 +1668,22 @@ impl SimpleAsn1Writable for Sequence<'_> {
 
 /// Writes an ASN.1 `SEQUENCE` using a callback that writes the inner
 /// elements.
-pub struct SequenceWriter<'a> {
-    f: &'a dyn Fn(&mut Writer<'_>) -> WriteResult,
+pub struct SequenceWriter<'a, E: From<WriteError> = WriteError> {
+    f: &'a dyn Fn(&mut Writer<'_>) -> Result<(), E>,
 }
 
-impl<'a> SequenceWriter<'a> {
+impl<'a, E: From<WriteError>> SequenceWriter<'a, E> {
     #[inline]
-    pub fn new(f: &'a dyn Fn(&mut Writer<'_>) -> WriteResult) -> Self {
+    pub fn new(f: &'a dyn Fn(&mut Writer<'_>) -> Result<(), E>) -> Self {
         SequenceWriter { f }
     }
 }
 
-impl SimpleAsn1Writable for SequenceWriter<'_> {
-    type Error = WriteError;
+impl<E: From<WriteError>> SimpleAsn1Writable for SequenceWriter<'_, E> {
+    type Error = E;
     const TAG: Tag = Tag::constructed(0x10);
     #[inline]
-    fn write_data(&self, dest: &mut WriteBuf) -> WriteResult {
+    fn write_data(&self, dest: &mut WriteBuf) -> Result<(), E> {
         (self.f)(&mut Writer::new(dest))
     }
 

src/writer.rs

@@ -838,8 +838,10 @@ mod tests {
         );
 
         assert_eq!(
-            write(|w| { w.write_implicit_element(&SequenceWriter::new(&|_w| { Ok(()) }), 2) })
-                .unwrap(),
+            write(|w| {
+                w.write_implicit_element(&SequenceWriter::<WriteError>::new(&|_w| Ok(())), 2)
+            })
+            .unwrap(),
             b"\xa2\x00"
         );
     }