feat: Cleanup Display of types and arguments

Author: aborgna-q

hugr-core/src/hugr/views/snapshots/hugr_core__hugr__views__tests__dot_func.snap

@@ -3,7 +3,7 @@ source: hugr-core/src/hugr/views/tests.rs
 expression: h.dot_string()
 ---
 digraph {
-0 [shape=plain label=<<table border="1"><tr><td align="text" border="0" colspan="1">(0) FuncDefn: "test"</td></tr><tr><td port="out0" align="text" colspan="1" cellpadding="1" >0: [Bool] -&gt; [[]][Bool]</td></tr></table>>]
+0 [shape=plain label=<<table border="1"><tr><td align="text" border="0" colspan="1">(0) FuncDefn: "test"</td></tr><tr><td port="out0" align="text" colspan="1" cellpadding="1" >0: [Bool] -&gt; [Bool]</td></tr></table>>]
 1 [shape=plain label=<<table border="1"><tr><td align="text" border="0" colspan="1">(1) Input</td></tr><tr><td port="out0" align="text" colspan="1" cellpadding="1" >0: Bool</td></tr></table>>]
 1:out0 -> 2:in0 [style=""]
 2 [shape=plain label=<<table border="1"><tr><td port="in0" align="text" colspan="1" cellpadding="1" >0: Bool</td></tr><tr><td align="text" border="0" colspan="1">(2) Output</td></tr></table>>]

hugr-core/src/hugr/views/snapshots/hugr_core__hugr__views__tests__dot_module.snap

@@ -4,7 +4,7 @@ expression: h.dot_string()
 ---
 digraph {
 0 [shape=plain label=<<table border="1"><tr><td align="text" border="0" colspan="1">(0) Module</td></tr></table>>]
-1 [shape=plain label=<<table border="1"><tr><td align="text" border="0" colspan="1">(1) FuncDecl: "test"</td></tr><tr><td port="out0" align="text" colspan="1" cellpadding="1" >0: [Bool] -&gt; [[]][Bool]</td></tr></table>>]
+1 [shape=plain label=<<table border="1"><tr><td align="text" border="0" colspan="1">(1) FuncDecl: "test"</td></tr><tr><td port="out0" align="text" colspan="1" cellpadding="1" >0: [Bool] -&gt; [Bool]</td></tr></table>>]
 hier0 [shape=plain label="0"]
 hier0 -> hier1  [style = "dashed"] 
 hier1 [shape=plain label="1"]

hugr-core/src/types.rs

@@ -265,24 +265,27 @@ impl<RV: MaybeRV> From<SumType> for TypeBase<RV> {
 #[derive(Clone, Debug, Eq, Hash, derive_more::Display)]
 /// Core types
 pub enum TypeEnum<RV: MaybeRV> {
-    // TODO optimise with Box<CustomType> ?
+    /// An extension type.
+    //
+    // TODO optimise with `Box<CustomType>`?
     // or some static version of this?
-    #[allow(missing_docs)]
     Extension(CustomType),
-    #[allow(missing_docs)]
+    /// An alias of a type.
     #[display("Alias({})", _0.name())]
     Alias(AliasDecl),
-    #[allow(missing_docs)]
-    #[display("Function({_0})")]
+    /// A function type.
+    #[display("{_0}")]
     Function(Box<FuncValueType>),
-    // Index into TypeParams, and cache of TypeBound (checked in validation)
-    #[allow(missing_docs)]
-    #[display("Variable({_0})")]
+    /// A type variable, defined by an index into a list of type parameters.
+    //
+    // We cache the TypeBound here (checked in validation)
+    #[display("var#{_0}")]
     Variable(usize, TypeBound),
     /// RowVariable. Of course, this requires that `RV` has instances, [NoRV] doesn't.
     #[display("RowVar({_0})")]
     RowVar(RV),
-    #[allow(missing_docs)]
+    /// Sum of types.
+    #[display("{_0}")]
     Sum(SumType),
 }
 
@@ -688,7 +691,7 @@ pub(crate) mod test {
         ]);
         assert_eq!(
             &t.to_string(),
-            "[usize, Function([[]][]), my_custom, Alias(my_alias)]"
+            "[usize, [] -> [], my_custom, Alias(my_alias)]"
         );
     }
 

hugr-core/src/types/custom.rs

@@ -155,11 +155,13 @@ impl CustomType {
 
 impl Display for CustomType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.args.is_empty() {
-            write!(f, "{}", self.id)
-        } else {
-            write!(f, "{}({:?})", self.id, self.args)
+        write!(f, "{}", self.id)?;
+        if !self.args.is_empty() {
+            write!(f, "(")?;
+            crate::utils::display_list(&self.args, f)?;
+            write!(f, ")")?;
         }
+        Ok(())
     }
 }
 

hugr-core/src/types/poly_func.rs

@@ -1,5 +1,7 @@
 //! Polymorphic Function Types
 
+use std::borrow::Cow;
+
 use itertools::Itertools;
 
 use crate::extension::SignatureError;
@@ -131,14 +133,17 @@ impl<RV: MaybeRV> PolyFuncTypeBase<RV> {
     }
 
     /// Helper function for the Display implementation
-    fn display_params(&self) -> String {
+    fn display_params(&self) -> Cow<'static, str> {
         if self.params.is_empty() {
-            return String::new();
+            return Cow::Borrowed("");
         }
-        format!(
-            "forall {}. ",
-            self.params.iter().map(ToString::to_string).join(" ")
-        )
+        let params_list = self
+            .params
+            .iter()
+            .enumerate()
+            .map(|(i, param)| format!("(var#{i} : {param})"))
+            .join(" ");
+        Cow::Owned(format!("∀ {params_list}. ",))
     }
 
     /// Returns a mutable reference to the body of the function type.

hugr-core/src/types/signature.rs

@@ -3,7 +3,7 @@
 use itertools::Either;
 
 use std::borrow::Cow;
-use std::fmt::{self, Display, Write};
+use std::fmt::{self, Display};
 
 use super::type_param::TypeParam;
 use super::type_row::TypeRowBase;
@@ -279,13 +279,11 @@ impl Signature {
 
 impl<RV: MaybeRV> Display for FuncTypeBase<RV> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if !self.input.is_empty() {
-            self.input.fmt(f)?;
-            f.write_str(" -> ")?;
+        self.input.fmt(f)?;
+        f.write_str(" -> ")?;
+        if !self.runtime_reqs.is_empty() {
+            self.runtime_reqs.fmt(f)?;
         }
-        f.write_char('[')?;
-        self.runtime_reqs.fmt(f)?;
-        f.write_char(']')?;
         self.output.fmt(f)
     }
 }

hugr-core/src/types/type_param.rs

@@ -4,6 +4,7 @@
 //!
 //! [`TypeDef`]: crate::extension::TypeDef
 
+use itertools::Itertools;
 #[cfg(test)]
 use proptest_derive::Arbitrary;
 use std::num::NonZeroU64;
@@ -19,7 +20,7 @@ use crate::extension::SignatureError;
 #[derive(
     Clone, Debug, PartialEq, Eq, Hash, derive_more::Display, serde::Deserialize, serde::Serialize,
 )]
-#[display("{}", "_0.map(|i|i.to_string()).unwrap_or(\"-\".to_string())")]
+#[display("{}", _0.map(|i|i.to_string()).unwrap_or("-".to_string()))]
 #[cfg_attr(test, derive(Arbitrary))]
 pub struct UpperBound(Option<NonZeroU64>);
 impl UpperBound {
@@ -56,11 +57,19 @@ impl UpperBound {
 #[serde(tag = "tp")]
 pub enum TypeParam {
     /// Argument is a [TypeArg::Type].
+    #[display("Type{}", match b {
+        TypeBound::Any => "".to_string(),
+        _ => format!("[{b}]")
+    })]
     Type {
         /// Bound for the type parameter.
         b: TypeBound,
     },
     /// Argument is a [TypeArg::BoundedNat] that is less than the upper bound.
+    #[display("{}", match bound.value() {
+        Some(v) => format!("BoundedNat[{v}]"),
+        None => "Nat".to_string()
+    })]
     BoundedNat {
         /// Upper bound for the Nat parameter.
         bound: UpperBound,
@@ -69,12 +78,13 @@ pub enum TypeParam {
     String,
     /// Argument is a [TypeArg::Sequence]. A list of indeterminate size containing
     /// parameters all of the (same) specified element type.
+    #[display("List[{param}]")]
     List {
         /// The [TypeParam] describing each element of the list.
         param: Box<TypeParam>,
     },
     /// Argument is a [TypeArg::Sequence]. A tuple of parameters.
-    #[display("Tuple({})", "params.iter().map(|t|t.to_string()).join(\", \")")]
+    #[display("Tuple[{}]", params.iter().map(|t|t.to_string()).join(", "))]
     Tuple {
         /// The [TypeParam]s contained in the tuple.
         params: Vec<TypeParam>,
@@ -144,29 +154,31 @@ impl From<UpperBound> for TypeParam {
 #[serde(tag = "tya")]
 pub enum TypeArg {
     /// Where the (Type/Op)Def declares that an argument is a [TypeParam::Type]
+    #[display("Type({ty})")]
     Type {
-        #[allow(missing_docs)]
+        /// The concrete type for the parameter.
         ty: Type,
     },
     /// Instance of [TypeParam::BoundedNat]. 64-bit unsigned integer.
+    #[display("{n}")]
     BoundedNat {
-        #[allow(missing_docs)]
+        /// The integer value for the parameter.
         n: u64,
     },
     ///Instance of [TypeParam::String]. UTF-8 encoded string argument.
     #[display("\"{arg}\"")]
     String {
-        #[allow(missing_docs)]
+        /// The string value for the parameter.
         arg: String,
     },
     /// Instance of [TypeParam::List] or [TypeParam::Tuple], defined by a
     /// sequence of elements.
-    #[display("Sequence({})", {
+    #[display("({})", {
         use itertools::Itertools as _;
         elems.iter().map(|t|t.to_string()).join(",")
     })]
     Sequence {
-        #[allow(missing_docs)]
+        /// List of element types
         elems: Vec<TypeArg>,
     },
     /// Instance of [TypeParam::Extensions], providing the extension ids.
@@ -181,6 +193,7 @@ pub enum TypeArg {
     /// Variable (used in type schemes or inside polymorphic functions),
     /// but not a [TypeArg::Type] (not even a row variable i.e. [TypeParam::List] of type)
     /// nor [TypeArg::Extensions] - see [TypeArg::new_var_use]
+    #[display("{}", v)]
     Variable {
         #[allow(missing_docs)]
         #[serde(flatten)]
@@ -235,7 +248,7 @@ impl From<ExtensionSet> for TypeArg {
 #[derive(
     Clone, Debug, PartialEq, Eq, Hash, serde::Deserialize, serde::Serialize, derive_more::Display,
 )]
-#[display("TypeArgVariable({idx})")]
+#[display("var#{idx}")]
 pub struct TypeArgVariable {
     idx: usize,
     cached_decl: TypeParam,

hugr-passes/src/monomorphize.rs

@@ -654,7 +654,7 @@ mod test {
     #[rstest]
     #[case::bounded_nat(vec![0.into()], "$foo$$n(0)")]
     #[case::type_unit(vec![Type::UNIT.into()], "$foo$$t(Unit)")]
-    #[case::type_int(vec![INT_TYPES[2].to_owned().into()], "$foo$$t(int([BoundedNat { n: 2 }]))")]
+    #[case::type_int(vec![INT_TYPES[2].to_owned().into()], "$foo$$t(int(2))")]
     #[case::string(vec!["arg".into()], "$foo$$s(arg)")]
     #[case::dollar_string(vec!["$arg".into()], "$foo$$s(\\$arg)")]
     #[case::sequence(vec![vec![0.into(), Type::UNIT.into()].into()], "$foo$$seq($n(0)$t(Unit))")]