feat: Value representation of Simple values

ciborium-ll/src/hdr.rs

@@ -107,7 +107,9 @@ impl TryFrom<Title> for Header {
 
             Title(Major::Other, Minor::More) => Self::Break,
             Title(Major::Other, Minor::This(x)) => Self::Simple(x),
-            Title(Major::Other, Minor::Next1(x)) => Self::Simple(x[0]),
+            // Two-byte sequences for simple values below 32 are not considered well-formed
+            Title(Major::Other, Minor::Next1([0..=31])) => Err(InvalidError(()))?,
+            Title(Major::Other, Minor::Next1([x])) => Self::Simple(x),
             Title(Major::Other, Minor::Next2(x)) => Self::Float(f16::from_be_bytes(x).into()),
             Title(Major::Other, Minor::Next4(x)) => Self::Float(f32::from_be_bytes(x).into()),
             Title(Major::Other, Minor::Next8(x)) => Self::Float(f64::from_be_bytes(x)),
@@ -140,6 +142,11 @@ impl From<Header> for Title {
 
             Header::Simple(x) => match x {
                 x @ 0..=23 => Title(Major::Other, Minor::This(x)),
+                // Simple(24) is irrepresentable
+                // Simple(25) to Simple(27) are floats
+                // Simple(28) to Simple(30) are reserved
+                // Should this panic or error (i.e. use TryFrom instead of From) ?
+                // See: https://www.rfc-editor.org/rfc/rfc8949.html#section-3.3
                 x => Title(Major::Other, Minor::Next1([x])),
             },
 

ciborium-ll/src/lib.rs

@@ -273,12 +273,19 @@ mod tests {
             (Header::Float(INFINITY), "fb7ff0000000000000", false),
             (Header::Float(NAN), "fb7ff8000000000000", false),
             (Header::Float(-INFINITY), "fbfff0000000000000", false),
+            (Header::Simple(0), "e0", true),
+            (Header::Simple(1), "e1", true),
+            (Header::Simple(16), "f0", true),
+            (Header::Simple(17), "f1", true),
+            (Header::Simple(18), "f2", true),
+            (Header::Simple(19), "f3", true),
             (Header::Simple(simple::FALSE), "f4", true),
             (Header::Simple(simple::TRUE), "f5", true),
             (Header::Simple(simple::NULL), "f6", true),
             (Header::Simple(simple::UNDEFINED), "f7", true),
-            (Header::Simple(16), "f0", true),
-            (Header::Simple(24), "f818", true),
+            (Header::Break, "ff", true),
+            (Header::Simple(32), "f820", true),
+            (Header::Simple(64), "f840", true),
             (Header::Simple(255), "f8ff", true),
             (Header::Tag(0), "c0", true),
             (Header::Tag(1), "c1", true),

ciborium/src/de/mod.rs

@@ -213,25 +213,22 @@ where
             Header::Simple(simple::FALSE) => self.deserialize_bool(visitor),
             Header::Simple(simple::TRUE) => self.deserialize_bool(visitor),
             Header::Simple(simple::NULL) => self.deserialize_option(visitor),
-            Header::Simple(simple::UNDEFINED) => self.deserialize_option(visitor),
-            h @ Header::Simple(..) => Err(h.expected("known simple value")),
+            Header::Simple(_) => self.recurse(|me| {
+                let mut simple_de =
+                    crate::simple::SimpleDeserializer::<_, Self>::new(&mut me.decoder);
+                visitor.visit_newtype_struct(&mut simple_de)
+            }),
 
             h @ Header::Break => Err(h.expected("non-break")),
         }
     }
 
     #[inline]
     fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
-        loop {
-            let offset = self.decoder.offset();
-
-            return match self.decoder.pull()? {
-                Header::Tag(..) => continue,
-                Header::Simple(simple::FALSE) => visitor.visit_bool(false),
-                Header::Simple(simple::TRUE) => visitor.visit_bool(true),
-                _ => Err(Error::semantic(offset, "expected bool")),
-            };
-        }
+        self.recurse(|me| {
+            let mut simple_de = crate::simple::SimpleDeserializer::<_, Self>::new(&mut me.decoder);
+            simple_de.deserialize_bool(visitor)
+        })
     }
 
     #[inline]

ciborium/src/lib.rs

@@ -94,6 +94,7 @@ extern crate alloc;
 
 pub mod de;
 pub mod ser;
+pub mod simple;
 pub mod tag;
 pub mod value;
 

ciborium/src/ser/mod.rs

@@ -200,10 +200,16 @@ where
     #[inline]
     fn serialize_newtype_struct<U: ?Sized + ser::Serialize>(
         self,
-        _name: &'static str,
+        name: &'static str,
         value: &U,
     ) -> Result<(), Self::Error> {
-        value.serialize(self)
+        match name {
+            "@@SIMPLE@@" => match value.serialize(crate::simple::Serializer) {
+                Ok(x) => Ok(self.0.push(Header::Simple(x))?),
+                _ => Err(Error::Value("expected simple value".into())),
+            },
+            _ => value.serialize(self),
+        }
     }
 
     #[inline]