JSON compatibility layer in Rust.

Author: zrho

hugr-core/src/types/serialize.rs

@@ -1,10 +1,16 @@
+use std::sync::Arc;
+
+use ordered_float::OrderedFloat;
+
 use super::{FuncValueType, MaybeRV, RowVariable, SumType, TypeBase, TypeBound, TypeEnum};
 
 use super::custom::CustomType;
 
 use crate::extension::SignatureError;
 use crate::extension::prelude::{qb_t, usize_t};
 use crate::ops::AliasDecl;
+use crate::types::type_param::{TypeArgVariable, UpperBound};
+use crate::types::{Term, Type};
 
 #[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
 #[serde(tag = "t")]
@@ -60,3 +66,133 @@ impl<RV: MaybeRV> TryFrom<SerSimpleType> for TypeBase<RV> {
         })
     }
 }
+
+#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
+#[non_exhaustive]
+#[serde(tag = "tp")]
+pub(super) enum TypeParamSer {
+    Type { b: TypeBound },
+    BoundedNat { bound: UpperBound },
+    String,
+    Bytes,
+    Float,
+    StaticType,
+    List { param: Box<Term> },
+    Tuple { params: Vec<Term> },
+}
+
+#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
+#[non_exhaustive]
+#[serde(tag = "tya")]
+pub(super) enum TypeArgSer {
+    Type {
+        ty: Type,
+    },
+    BoundedNat {
+        n: u64,
+    },
+    String {
+        arg: String,
+    },
+    Bytes {
+        #[serde(with = "base64")]
+        value: Arc<[u8]>,
+    },
+    Float {
+        value: OrderedFloat<f64>,
+    },
+    List {
+        elems: Vec<Term>,
+    },
+    Tuple {
+        elems: Vec<Term>,
+    },
+    Variable {
+        #[serde(flatten)]
+        v: TypeArgVariable,
+    },
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub(super) enum TermSer {
+    TypeArg(TypeArgSer),
+    TypeParam(TypeParamSer),
+}
+
+impl From<Term> for TermSer {
+    fn from(value: Term) -> Self {
+        match value {
+            Term::RuntimeType { b } => TermSer::TypeParam(TypeParamSer::Type { b }),
+            Term::StaticType => TermSer::TypeParam(TypeParamSer::StaticType),
+            Term::BoundedNatType { bound } => {
+                TermSer::TypeParam(TypeParamSer::BoundedNat { bound })
+            }
+            Term::StringType => TermSer::TypeParam(TypeParamSer::String),
+            Term::BytesType => TermSer::TypeParam(TypeParamSer::Bytes),
+            Term::FloatType => TermSer::TypeParam(TypeParamSer::Float),
+            Term::ListType { param } => TermSer::TypeParam(TypeParamSer::List {
+                param: Box::new(*param),
+            }),
+            Term::TupleType { params } => TermSer::TypeParam(TypeParamSer::Tuple { params }),
+            Term::Type { ty } => TermSer::TypeArg(TypeArgSer::Type { ty }),
+            Term::BoundedNat { n } => TermSer::TypeArg(TypeArgSer::BoundedNat { n }),
+            Term::String { arg } => TermSer::TypeArg(TypeArgSer::String { arg }),
+            Term::Bytes { value } => TermSer::TypeArg(TypeArgSer::Bytes { value }),
+            Term::Float { value } => TermSer::TypeArg(TypeArgSer::Float { value }),
+            Term::List { elems } => TermSer::TypeArg(TypeArgSer::List { elems }),
+            Term::Tuple { elems } => TermSer::TypeArg(TypeArgSer::Tuple { elems }),
+            Term::Variable { v } => TermSer::TypeArg(TypeArgSer::Variable { v }),
+        }
+    }
+}
+
+impl From<TermSer> for Term {
+    fn from(value: TermSer) -> Self {
+        match value {
+            TermSer::TypeParam(param) => match param {
+                TypeParamSer::Type { b } => Term::RuntimeType { b },
+                TypeParamSer::StaticType => Term::StaticType,
+                TypeParamSer::BoundedNat { bound } => Term::BoundedNatType { bound },
+                TypeParamSer::String => Term::StringType,
+                TypeParamSer::Bytes => Term::BytesType,
+                TypeParamSer::Float => Term::FloatType,
+                TypeParamSer::List { param } => Term::ListType { param },
+                TypeParamSer::Tuple { params } => Term::TupleType { params },
+            },
+            TermSer::TypeArg(arg) => match arg {
+                TypeArgSer::Type { ty } => Term::Type { ty },
+                TypeArgSer::BoundedNat { n } => Term::BoundedNat { n },
+                TypeArgSer::String { arg } => Term::String { arg },
+                TypeArgSer::Bytes { value } => Term::Bytes { value },
+                TypeArgSer::Float { value } => Term::Float { value },
+                TypeArgSer::List { elems } => Term::List { elems },
+                TypeArgSer::Tuple { elems } => Term::Tuple { elems },
+                TypeArgSer::Variable { v } => Term::Variable { v },
+            },
+        }
+    }
+}
+
+/// Helper for to serialize and deserialize the byte string in [`TypeArg::Bytes`] via base64.
+mod base64 {
+    use std::sync::Arc;
+
+    use base64::Engine as _;
+    use base64::prelude::BASE64_STANDARD;
+    use serde::{Deserialize, Serialize};
+    use serde::{Deserializer, Serializer};
+
+    pub fn serialize<S: Serializer>(v: &Arc<[u8]>, s: S) -> Result<S::Ok, S::Error> {
+        let base64 = BASE64_STANDARD.encode(v);
+        base64.serialize(s)
+    }
+
+    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Arc<[u8]>, D::Error> {
+        let base64 = String::deserialize(d)?;
+        BASE64_STANDARD
+            .decode(base64.as_bytes())
+            .map(|v| v.into())
+            .map_err(serde::de::Error::custom)
+    }
+}

hugr-core/src/types/type_param.rs

@@ -61,7 +61,10 @@ pub type TypeParam = Term;
     Clone, Debug, PartialEq, Eq, Hash, derive_more::Display, serde::Deserialize, serde::Serialize,
 )]
 #[non_exhaustive]
-#[serde(tag = "t")]
+#[serde(
+    from = "crate::types::serialize::TermSer",
+    into = "crate::types::serialize::TermSer"
+)]
 pub enum Term {
     /// The type of runtime types.
     #[display("Type{}", match b {
@@ -124,7 +127,6 @@ pub enum Term {
     #[display("bytes")]
     Bytes {
         /// The value of the literal.
-        #[serde(with = "base64")]
         value: Arc<[u8]>,
     },
     /// A 64-bit floating point number. Instance of [`Term::FloatType`].
@@ -558,29 +560,6 @@ pub enum TypeArgError {
     InvalidValue(TypeArg),
 }
 
-/// Helper for to serialize and deserialize the byte string in `TypeArg::Bytes` via base64.
-mod base64 {
-    use std::sync::Arc;
-
-    use base64::Engine as _;
-    use base64::prelude::BASE64_STANDARD;
-    use serde::{Deserialize, Serialize};
-    use serde::{Deserializer, Serializer};
-
-    pub fn serialize<S: Serializer>(v: &Arc<[u8]>, s: S) -> Result<S::Ok, S::Error> {
-        let base64 = BASE64_STANDARD.encode(v);
-        base64.serialize(s)
-    }
-
-    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Arc<[u8]>, D::Error> {
-        let base64 = String::deserialize(d)?;
-        BASE64_STANDARD
-            .decode(base64.as_bytes())
-            .map(|v| v.into())
-            .map_err(serde::de::Error::custom)
-    }
-}
-
 #[cfg(test)]
 mod test {
     use itertools::Itertools;