Add binary types to ConstValue and Value. #569

value/src/deserializer.rs

@@ -14,18 +14,21 @@ use serde::forward_to_deserialize_any;
 pub struct DeserializerError(String);
 
 impl de::Error for DeserializerError {
+    #[inline]
     fn custom<T: fmt::Display>(msg: T) -> Self {
         DeserializerError(msg.to_string())
     }
 }
 
 impl std::error::Error for DeserializerError {
+    #[inline]
     fn description(&self) -> &str {
         "Value deserializer error"
     }
 }
 
 impl fmt::Display for DeserializerError {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             DeserializerError(msg) => write!(f, "{}", msg),
@@ -34,18 +37,21 @@ impl fmt::Display for DeserializerError {
 }
 
 impl From<de::value::Error> for DeserializerError {
+    #[inline]
     fn from(e: de::value::Error) -> DeserializerError {
         DeserializerError(e.to_string())
     }
 }
 
 impl ConstValue {
+    #[inline]
     fn unexpected(&self) -> Unexpected {
         match self {
             ConstValue::Null => Unexpected::Unit,
             ConstValue::Number(_) => Unexpected::Other("number"),
             ConstValue::String(v) => Unexpected::Str(v),
             ConstValue::Boolean(v) => Unexpected::Bool(*v),
+            ConstValue::Binary(v) => Unexpected::Bytes(v),
             ConstValue::Enum(v) => Unexpected::Str(v),
             ConstValue::List(_) => Unexpected::Seq,
             ConstValue::Object(_) => Unexpected::Map,
@@ -95,6 +101,7 @@ where
 impl<'de> de::Deserializer<'de> for ConstValue {
     type Error = DeserializerError;
 
+    #[inline]
     fn deserialize_any<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
     where
         V: Visitor<'de>,
@@ -106,6 +113,7 @@ impl<'de> de::Deserializer<'de> for ConstValue {
                 .map_err(|err| DeserializerError(err.to_string())),
             ConstValue::String(v) => visitor.visit_str(&v),
             ConstValue::Boolean(v) => visitor.visit_bool(v),
+            ConstValue::Binary(bytes) => visitor.visit_byte_buf(bytes),
             ConstValue::Enum(v) => visitor.visit_str(v.as_str()),
             ConstValue::List(v) => visit_array(v, visitor),
             ConstValue::Object(v) => visit_object(v, visitor),
@@ -118,6 +126,7 @@ impl<'de> de::Deserializer<'de> for ConstValue {
         tuple_struct map struct identifier ignored_any
     }
 
+    #[inline]
     fn deserialize_option<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
     where
         V: Visitor<'de>,
@@ -128,6 +137,7 @@ impl<'de> de::Deserializer<'de> for ConstValue {
         }
     }
 
+    #[inline]
     fn deserialize_newtype_struct<V>(
         self,
         _name: &'static str,
@@ -181,6 +191,11 @@ impl<'de> de::Deserializer<'de> for ConstValue {
 
         visitor.visit_enum(EnumDeserializer { variant, value })
     }
+
+    #[inline]
+    fn is_human_readable(&self) -> bool {
+        false
+    }
 }
 
 struct EnumDeserializer {
@@ -192,6 +207,7 @@ impl<'de> EnumAccess<'de> for EnumDeserializer {
     type Error = DeserializerError;
     type Variant = VariantDeserializer;
 
+    #[inline]
     fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), DeserializerError>
     where
         V: DeserializeSeed<'de>,
@@ -217,6 +233,7 @@ struct VariantDeserializer {
 impl<'de> VariantAccess<'de> for VariantDeserializer {
     type Error = DeserializerError;
 
+    #[inline]
     fn unit_variant(self) -> Result<(), DeserializerError> {
         match self.value {
             Some(value) => Deserialize::deserialize(value),
@@ -224,6 +241,7 @@ impl<'de> VariantAccess<'de> for VariantDeserializer {
         }
     }
 
+    #[inline]
     fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, DeserializerError>
     where
         T: DeserializeSeed<'de>,
@@ -337,6 +355,7 @@ impl<'de> SeqAccess<'de> for SeqDeserializer {
         }
     }
 
+    #[inline]
     fn size_hint(&self) -> Option<usize> {
         match self.iter.size_hint() {
             (lower, Some(upper)) if lower == upper => Some(upper),
@@ -351,6 +370,7 @@ struct MapDeserializer {
 }
 
 impl MapDeserializer {
+    #[inline]
     fn new(map: BTreeMap<Name, ConstValue>) -> Self {
         MapDeserializer {
             iter: map.into_iter(),
@@ -376,6 +396,7 @@ impl<'de> MapAccess<'de> for MapDeserializer {
         }
     }
 
+    #[inline]
     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, DeserializerError>
     where
         T: DeserializeSeed<'de>,
@@ -386,6 +407,7 @@ impl<'de> MapAccess<'de> for MapDeserializer {
         }
     }
 
+    #[inline]
     fn size_hint(&self) -> Option<usize> {
         match self.iter.size_hint() {
             (lower, Some(upper)) if lower == upper => Some(upper),
@@ -419,6 +441,7 @@ struct MapKeyDeserializer {
 impl<'de> serde::Deserializer<'de> for MapKeyDeserializer {
     type Error = DeserializerError;
 
+    #[inline]
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, DeserializerError>
     where
         V: Visitor<'de>,
@@ -426,6 +449,7 @@ impl<'de> serde::Deserializer<'de> for MapKeyDeserializer {
         NameDeserializer::new(self.key).deserialize_any(visitor)
     }
 
+    #[inline]
     fn deserialize_enum<V>(
         self,
         name: &'static str,
@@ -452,6 +476,7 @@ struct NameDeserializer {
 }
 
 impl NameDeserializer {
+    #[inline]
     fn new(value: Name) -> Self {
         NameDeserializer { value }
     }
@@ -460,6 +485,7 @@ impl NameDeserializer {
 impl<'de> de::Deserializer<'de> for NameDeserializer {
     type Error = DeserializerError;
 
+    #[inline]
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, DeserializerError>
     where
         V: de::Visitor<'de>,
@@ -475,6 +501,7 @@ impl<'de> de::Deserializer<'de> for NameDeserializer {
 }
 
 /// Interpret a `ConstValue` as an instance of type `T`.
+#[inline]
 pub fn from_value<T: DeserializeOwned>(value: ConstValue) -> Result<T, DeserializerError> {
     T::deserialize(value)
 }

value/src/lib.rs

@@ -3,9 +3,10 @@
 #![warn(missing_docs)]
 #![forbid(unsafe_code)]
 
-mod de;
+mod deserializer;
 mod macros;
-mod ser;
+mod serializer;
+mod value_serde;
 mod variables;
 
 use std::borrow::{Borrow, Cow};
@@ -16,12 +17,11 @@ use std::iter::FromIterator;
 use std::ops::Deref;
 use std::sync::Arc;
 
-use serde::ser::Error;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-pub use de::{from_value, DeserializerError};
+pub use deserializer::{from_value, DeserializerError};
-pub use ser::{to_value, SerializerError};
 pub use serde_json::Number;
+pub use serializer::{to_value, SerializerError};
 
 pub use variables::Variables;
 
@@ -121,8 +121,7 @@ impl<'de> Deserialize<'de> for Name {
 /// serialize `Upload` will fail, and `Enum` and `Upload` cannot be deserialized.
 ///
 /// [Reference](https://spec.graphql.org/June2018/#Value).
-#[derive(Clone, Debug, Eq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq)]
-#[serde(untagged)]
 pub enum ConstValue {
     /// `null`.
     Null,
@@ -132,8 +131,9 @@ pub enum ConstValue {
     String(String),
     /// A boolean.
     Boolean(bool),
+    /// A binary.
+    Binary(Vec<u8>),
     /// An enum. These are typically in `SCREAMING_SNAKE_CASE`.
-    #[serde(skip_deserializing)]
     Enum(Name),
     /// A list of values.
     List(Vec<ConstValue>),
@@ -151,6 +151,7 @@ impl PartialEq for ConstValue {
             (ConstValue::Enum(a), ConstValue::String(b)) => a == b,
             (ConstValue::String(a), ConstValue::Enum(b)) => a == b,
             (ConstValue::Enum(a), ConstValue::Enum(b)) => a == b,
+            (ConstValue::Binary(a), ConstValue::Binary(b)) => a == b,
             (ConstValue::List(a), ConstValue::List(b)) => {
                 if a.len() != b.len() {
                     return false;
@@ -267,6 +268,7 @@ impl ConstValue {
             Self::Number(num) => Value::Number(num),
             Self::String(s) => Value::String(s),
             Self::Boolean(b) => Value::Boolean(b),
+            Self::Binary(bytes) => Value::Binary(bytes),
             Self::Enum(v) => Value::Enum(v),
             Self::List(items) => {
                 Value::List(items.into_iter().map(ConstValue::into_value).collect())
@@ -311,6 +313,7 @@ impl Display for ConstValue {
             Self::String(val) => write_quoted(val, f),
             Self::Boolean(true) => f.write_str("true"),
             Self::Boolean(false) => f.write_str("false"),
+            Self::Binary(bytes) => write_binary(bytes, f),
             Self::Null => f.write_str("null"),
             Self::Enum(name) => f.write_str(name),
             Self::List(items) => write_list(items, f),
@@ -341,11 +344,9 @@ impl TryFrom<ConstValue> for serde_json::Value {
 /// deserialized.
 ///
 /// [Reference](https://spec.graphql.org/June2018/#Value).
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
-#[serde(untagged)]
 pub enum Value {
     /// A variable, without the `$`.
-    #[serde(serialize_with = "fail_serialize_variable", skip_deserializing)]
     Variable(Name),
     /// `null`.
     Null,
@@ -355,8 +356,9 @@ pub enum Value {
     String(String),
     /// A boolean.
     Boolean(bool),
+    /// A binary.
+    Binary(Vec<u8>),
     /// An enum. These are typically in `SCREAMING_SNAKE_CASE`.
-    #[serde(skip_deserializing)]
     Enum(Name),
     /// A list of values.
     List(Vec<Value>),
@@ -383,6 +385,7 @@ impl Value {
             Self::Number(num) => ConstValue::Number(num),
             Self::String(s) => ConstValue::String(s),
             Self::Boolean(b) => ConstValue::Boolean(b),
+            Self::Binary(v) => ConstValue::Binary(v),
             Self::Enum(v) => ConstValue::Enum(v),
             Self::List(items) => ConstValue::List(
                 items
@@ -439,6 +442,7 @@ impl Display for Value {
             Self::String(val) => write_quoted(val, f),
             Self::Boolean(true) => f.write_str("true"),
             Self::Boolean(false) => f.write_str("false"),
+            Self::Binary(bytes) => write_binary(bytes, f),
             Self::Null => f.write_str("null"),
             Self::Enum(name) => f.write_str(name),
             Self::List(items) => write_list(items, f),
@@ -466,10 +470,6 @@ impl TryFrom<Value> for serde_json::Value {
     }
 }
 
-fn fail_serialize_variable<S: Serializer>(_: &str, _: S) -> Result<S::Ok, S::Error> {
-    Err(S::Error::custom("cannot serialize variable"))
-}
-
 fn write_quoted(s: &str, f: &mut Formatter<'_>) -> fmt::Result {
     f.write_char('"')?;
     for c in s.chars() {
@@ -485,21 +485,45 @@ fn write_quoted(s: &str, f: &mut Formatter<'_>) -> fmt::Result {
     }
     f.write_char('"')
 }
-fn write_list<T: Display>(list: impl IntoIterator<Item = T>, f: &mut Formatter<'_>) -> fmt::Result {
+
+fn write_binary(bytes: &[u8], f: &mut Formatter<'_>) -> fmt::Result {
     f.write_char('[')?;
-    for item in list {
+    let mut iter = bytes.iter().copied();
-        item.fmt(f)?;
+    if let Some(value) = iter.next() {
+        value.fmt(f)?;
+    }
+    for value in iter {
         f.write_char(',')?;
+        value.fmt(f)?;
     }
     f.write_char(']')
 }
+
+fn write_list<T: Display>(list: impl IntoIterator<Item = T>, f: &mut Formatter<'_>) -> fmt::Result {
+    f.write_char('[')?;
+    let mut iter = list.into_iter();
+    if let Some(item) = iter.next() {
+        item.fmt(f)?;
+    }
+    for item in iter {
+        f.write_char(',')?;
+        item.fmt(f)?;
+    }
+    f.write_char(']')
+}
+
 fn write_object<K: Display, V: Display>(
     object: impl IntoIterator<Item = (K, V)>,
     f: &mut Formatter<'_>,
 ) -> fmt::Result {
     f.write_char('{')?;
-    for (name, value) in object {
+    let mut iter = object.into_iter();
-        write!(f, "{}: {},", name, value)?;
+    if let Some((name, value)) = iter.next() {
+        write!(f, "{}: {}", name, value)?;
+    }
+    for (name, value) in iter {
+        f.write_char(',')?;
+        write!(f, "{}: {}", name, value)?;
     }
     f.write_char('}')
 }

value/src/serializer.rs

@@ -32,6 +32,7 @@ impl ser::Error for SerializerError {
 }
 
 /// Convert a `T` into `ConstValue` which is an enum that can represent any valid GraphQL data.
+#[inline]
 pub fn to_value<T: ser::Serialize>(value: T) -> Result<ConstValue, SerializerError> {
     value.serialize(Serializer)
 }
@@ -49,46 +50,57 @@ impl ser::Serializer for Serializer {
     type SerializeStruct = SerializeStruct;
     type SerializeStructVariant = SerializeStructVariant;
 
+    #[inline]
     fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Boolean(v))
     }
 
+    #[inline]
     fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Number(v.into()))
     }
 
+    #[inline]
     fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Number(v.into()))
     }
 
+    #[inline]
     fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Number(v.into()))
     }
 
+    #[inline]
     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Number(v.into()))
     }
 
+    #[inline]
     fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Number(v.into()))
     }
 
+    #[inline]
     fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Number(v.into()))
     }
 
+    #[inline]
     fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Number(v.into()))
     }
 
+    #[inline]
     fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Number(v.into()))
     }
 
+    #[inline]
     fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
         self.serialize_f64(v as f64)
     }
 
+    #[inline]
     fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
         match Number::from_f64(v) {
             Some(v) => Ok(ConstValue::Number(v)),
@@ -96,22 +108,27 @@ impl ser::Serializer for Serializer {
         }
     }
 
+    #[inline]
     fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
         Err(SerializerError("char is not supported.".to_string()))
     }
 
+    #[inline]
     fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::String(v.to_string()))
     }
 
-    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
+    #[inline]
-        Err(SerializerError("bytes is not supported.".to_string()))
+    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
+        Ok(ConstValue::Binary(v.to_vec()))
     }
 
+    #[inline]
     fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Null)
     }
 
+    #[inline]
     fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
     where
         T: ser::Serialize,
@@ -119,14 +136,17 @@ impl ser::Serializer for Serializer {
         value.serialize(self)
     }
 
+    #[inline]
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Null)
     }
 
+    #[inline]
     fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Null)
     }
 
+    #[inline]
     fn serialize_unit_variant(
         self,
         _name: &'static str,
@@ -136,6 +156,7 @@ impl ser::Serializer for Serializer {
         Ok(ConstValue::String(variant.to_string()))
     }
 
+    #[inline]
     fn serialize_newtype_struct<T: ?Sized>(
         self,
         _name: &'static str,
@@ -147,6 +168,7 @@ impl ser::Serializer for Serializer {
         value.serialize(self)
     }
 
+    #[inline]
     fn serialize_newtype_variant<T: ?Sized>(
         self,
         _name: &'static str,
@@ -164,14 +186,17 @@ impl ser::Serializer for Serializer {
         })
     }
 
+    #[inline]
     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
         Ok(SerializeSeq(vec![]))
     }
 
+    #[inline]
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
         Ok(SerializeTuple(vec![]))
     }
 
+    #[inline]
     fn serialize_tuple_struct(
         self,
         _name: &'static str,
@@ -180,6 +205,7 @@ impl ser::Serializer for Serializer {
         Ok(SerializeTupleStruct(vec![]))
     }
 
+    #[inline]
     fn serialize_tuple_variant(
         self,
         _name: &'static str,
@@ -193,6 +219,7 @@ impl ser::Serializer for Serializer {
         ))
     }
 
+    #[inline]
     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
         Ok(SerializeMap {
             map: BTreeMap::new(),
@@ -200,6 +227,7 @@ impl ser::Serializer for Serializer {
         })
     }
 
+    #[inline]
     fn serialize_struct(
         self,
         _name: &'static str,
@@ -208,6 +236,7 @@ impl ser::Serializer for Serializer {
         Ok(SerializeStruct(BTreeMap::new()))
     }
 
+    #[inline]
     fn serialize_struct_variant(
         self,
         _name: &'static str,
@@ -217,6 +246,11 @@ impl ser::Serializer for Serializer {
     ) -> Result<Self::SerializeStructVariant, Self::Error> {
         Ok(SerializeStructVariant(Name::new(variant), BTreeMap::new()))
     }
+
+    #[inline]
+    fn is_human_readable(&self) -> bool {
+        false
+    }
 }
 
 struct SerializeSeq(Vec<ConstValue>);
@@ -225,6 +259,7 @@ impl ser::SerializeSeq for SerializeSeq {
     type Ok = ConstValue;
     type Error = SerializerError;
 
+    #[inline]
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
     where
         T: ser::Serialize,
@@ -234,6 +269,7 @@ impl ser::SerializeSeq for SerializeSeq {
         Ok(())
     }
 
+    #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::List(self.0))
     }
@@ -245,6 +281,7 @@ impl ser::SerializeTuple for SerializeTuple {
     type Ok = ConstValue;
     type Error = SerializerError;
 
+    #[inline]
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
     where
         T: ser::Serialize,
@@ -254,6 +291,7 @@ impl ser::SerializeTuple for SerializeTuple {
         Ok(())
     }
 
+    #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::List(self.0))
     }
@@ -265,6 +303,7 @@ impl ser::SerializeTupleStruct for SerializeTupleStruct {
     type Ok = ConstValue;
     type Error = SerializerError;
 
+    #[inline]
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
     where
         T: ser::Serialize,
@@ -274,6 +313,7 @@ impl ser::SerializeTupleStruct for SerializeTupleStruct {
         Ok(())
     }
 
+    #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::List(self.0))
     }
@@ -285,6 +325,7 @@ impl ser::SerializeTupleVariant for SerializeTupleVariant {
     type Ok = ConstValue;
     type Error = SerializerError;
 
+    #[inline]
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
     where
         T: ser::Serialize,
@@ -294,6 +335,7 @@ impl ser::SerializeTupleVariant for SerializeTupleVariant {
         Ok(())
     }
 
+    #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
         let mut map = BTreeMap::new();
         map.insert(self.0, ConstValue::List(self.1));
@@ -310,6 +352,7 @@ impl ser::SerializeMap for SerializeMap {
     type Ok = ConstValue;
     type Error = SerializerError;
 
+    #[inline]
     fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
     where
         T: ser::Serialize,
@@ -319,6 +362,7 @@ impl ser::SerializeMap for SerializeMap {
         Ok(())
     }
 
+    #[inline]
     fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
     where
         T: ser::Serialize,
@@ -328,6 +372,7 @@ impl ser::SerializeMap for SerializeMap {
         Ok(())
     }
 
+    #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Object(self.map))
     }
@@ -339,6 +384,7 @@ impl ser::SerializeStruct for SerializeStruct {
     type Ok = ConstValue;
     type Error = SerializerError;
 
+    #[inline]
     fn serialize_field<T: ?Sized>(
         &mut self,
         key: &'static str,
@@ -353,6 +399,7 @@ impl ser::SerializeStruct for SerializeStruct {
         Ok(())
     }
 
+    #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
         Ok(ConstValue::Object(self.0))
     }
@@ -364,6 +411,7 @@ impl ser::SerializeStructVariant for SerializeStructVariant {
     type Ok = ConstValue;
     type Error = SerializerError;
 
+    #[inline]
     fn serialize_field<T: ?Sized>(
         &mut self,
         key: &'static str,
@@ -378,6 +426,7 @@ impl ser::SerializeStructVariant for SerializeStructVariant {
         Ok(())
     }
 
+    #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
         let mut map = BTreeMap::new();
         map.insert(self.0, ConstValue::Object(self.1));
@@ -385,6 +434,7 @@ impl ser::SerializeStructVariant for SerializeStructVariant {
     }
 }
 
+#[inline]
 fn key_must_be_a_string() -> SerializerError {
     SerializerError("Key must be a string".to_string())
 }
@@ -402,66 +452,82 @@ impl serde::Serializer for MapKeySerializer {
     type SerializeStruct = Impossible<Name, SerializerError>;
     type SerializeStructVariant = Impossible<Name, SerializerError>;
 
+    #[inline]
     fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
         Ok(Name::new(v))
     }
 
+    #[inline]
     fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
     where
         T: Serialize,
@@ -469,14 +535,17 @@ impl serde::Serializer for MapKeySerializer {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_unit_variant(
         self,
         _name: &'static str,
@@ -486,6 +555,7 @@ impl serde::Serializer for MapKeySerializer {
         Ok(Name::new(variant))
     }
 
+    #[inline]
     fn serialize_newtype_struct<T: ?Sized>(
         self,
         _name: &'static str,
@@ -497,6 +567,7 @@ impl serde::Serializer for MapKeySerializer {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_newtype_variant<T: ?Sized>(
         self,
         _name: &'static str,
@@ -510,14 +581,17 @@ impl serde::Serializer for MapKeySerializer {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_tuple_struct(
         self,
         _name: &'static str,
@@ -526,6 +600,7 @@ impl serde::Serializer for MapKeySerializer {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_tuple_variant(
         self,
         _name: &'static str,
@@ -536,10 +611,12 @@ impl serde::Serializer for MapKeySerializer {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_struct(
         self,
         _name: &'static str,
@@ -548,6 +625,7 @@ impl serde::Serializer for MapKeySerializer {
         Err(key_must_be_a_string())
     }
 
+    #[inline]
     fn serialize_struct_variant(
         self,
         _name: &'static str,

value/src/value_serde.rs

@@ -0,0 +1,293 @@
+use std::collections::BTreeMap;
+use std::fmt::{self, Formatter};
+
+use serde::de::{Error as DeError, MapAccess, SeqAccess, Visitor};
+use serde::ser::Error as SerError;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::{ConstValue, Number, Value};
+
+impl Serialize for ConstValue {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            ConstValue::Null => serializer.serialize_none(),
+            ConstValue::Number(v) => v.serialize(serializer),
+            ConstValue::String(v) => serializer.serialize_str(v),
+            ConstValue::Boolean(v) => serializer.serialize_bool(*v),
+            ConstValue::Binary(v) => serializer.serialize_bytes(v),
+            ConstValue::Enum(v) => serializer.serialize_str(v),
+            ConstValue::List(v) => v.serialize(serializer),
+            ConstValue::Object(v) => v.serialize(serializer),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ConstValue {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        struct ValueVisitor;
+
+        impl<'de> Visitor<'de> for ValueVisitor {
+            type Value = ConstValue;
+
+            #[inline]
+            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+                formatter.write_str("any valid value")
+            }
+
+            #[inline]
+            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(ConstValue::Boolean(v))
+            }
+
+            #[inline]
+            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(ConstValue::Number(v.into()))
+            }
+
+            #[inline]
+            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(ConstValue::Number(v.into()))
+            }
+
+            #[inline]
+            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Number::from_f64(v).map_or(ConstValue::Null, ConstValue::Number))
+            }
+
+            #[inline]
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(ConstValue::String(v.to_string()))
+            }
+
+            #[inline]
+            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(ConstValue::String(v))
+            }
+
+            #[inline]
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(ConstValue::Binary(v.to_vec()))
+            }
+
+            #[inline]
+            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(ConstValue::Binary(v))
+            }
+
+            #[inline]
+            fn visit_none<E>(self) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(ConstValue::Null)
+            }
+
+            #[inline]
+            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                Deserialize::deserialize(deserializer)
+            }
+
+            #[inline]
+            fn visit_unit<E>(self) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(ConstValue::Null)
+            }
+
+            fn visit_seq<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
+            where
+                A: SeqAccess<'de>,
+            {
+                let mut vec = Vec::new();
+                while let Some(elem) = visitor.next_element()? {
+                    vec.push(elem);
+                }
+                Ok(ConstValue::List(vec))
+            }
+
+            fn visit_map<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
+            where
+                A: MapAccess<'de>,
+            {
+                let mut map = BTreeMap::new();
+                while let Some((name, value)) = visitor.next_entry()? {
+                    map.insert(name, value);
+                }
+                Ok(ConstValue::Object(map))
+            }
+        }
+
+        deserializer.deserialize_any(ValueVisitor)
+    }
+}
+
+impl Serialize for Value {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            Value::Variable(_) => Err(S::Error::custom("cannot serialize variable")),
+            Value::Null => serializer.serialize_none(),
+            Value::Number(v) => v.serialize(serializer),
+            Value::String(v) => serializer.serialize_str(v),
+            Value::Boolean(v) => serializer.serialize_bool(*v),
+            Value::Binary(v) => serializer.serialize_bytes(v),
+            Value::Enum(v) => serializer.serialize_str(v),
+            Value::List(v) => v.serialize(serializer),
+            Value::Object(v) => v.serialize(serializer),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for Value {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        struct ValueVisitor;
+
+        impl<'de> Visitor<'de> for ValueVisitor {
+            type Value = Value;
+
+            #[inline]
+            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+                formatter.write_str("any valid value")
+            }
+
+            #[inline]
+            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Value::Boolean(v))
+            }
+
+            #[inline]
+            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Value::Number(v.into()))
+            }
+
+            #[inline]
+            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Value::Number(v.into()))
+            }
+
+            #[inline]
+            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Number::from_f64(v).map_or(Value::Null, Value::Number))
+            }
+
+            #[inline]
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Value::String(v.to_string()))
+            }
+
+            #[inline]
+            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Value::String(v))
+            }
+
+            #[inline]
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Value::Binary(v.to_vec()))
+            }
+
+            #[inline]
+            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Value::Binary(v))
+            }
+
+            #[inline]
+            fn visit_none<E>(self) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Value::Null)
+            }
+
+            #[inline]
+            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                Deserialize::deserialize(deserializer)
+            }
+
+            #[inline]
+            fn visit_unit<E>(self) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                Ok(Value::Null)
+            }
+
+            fn visit_seq<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
+            where
+                A: SeqAccess<'de>,
+            {
+                let mut vec = Vec::new();
+                while let Some(elem) = visitor.next_element()? {
+                    vec.push(elem);
+                }
+                Ok(Value::List(vec))
+            }
+
+            fn visit_map<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
+            where
+                A: MapAccess<'de>,
+            {
+                let mut map = BTreeMap::new();
+                while let Some((name, value)) = visitor.next_entry()? {
+                    map.insert(name, value);
+                }
+                Ok(Value::Object(map))
+            }
+        }
+
+        deserializer.deserialize_any(ValueVisitor)
+    }
+}

value/tests/test_serde.rs

@@ -19,6 +19,7 @@ fn test_serde() {
     test_value(Some(100i32));
     test_value(ConstValue::Null);
     test_value(vec![0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    test_value(b"123456".to_vec());
 
     #[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
     struct NewType(i32);
@@ -52,3 +53,11 @@ fn test_serde() {
         b: Some(Enum::B),
     });
 }
+
+#[test]
+fn test_binary() {
+    assert_eq!(
+        to_value(Value::Binary(b"123456".to_vec())).unwrap(),
+        ConstValue::Binary(b"123456".to_vec())
+    );
+}