remove type annots, fix doclinks, various comments

Author: acl-cqc

hugr-core/src/extension/op_def.rs

@@ -235,7 +235,7 @@ impl SignatureFunc {
         args: &[TypeArg],
         exts: &ExtensionRegistry,
     ) -> Result<FunctionType, SignatureError> {
-        let temp: TypeSchemeRV;
+        let temp: TypeSchemeRV; // to keep alive
         let (pf, args) = match &self {
             SignatureFunc::TypeScheme(custom) => {
                 custom.validate.validate(args, def, exts)?;

hugr-core/src/extension/prelude.rs

@@ -436,7 +436,7 @@ mod test {
             .instantiate([])
             .unwrap();
 
-        let ext_type: Type = Type::new_extension(ext_def);
+        let ext_type = Type::new_extension(ext_def);
         assert_eq!(ext_type, ERROR_TYPE);
 
         let error_val = ConstError::new(2, "my message");

hugr-core/src/extension/type_def.rs

@@ -182,14 +182,14 @@ mod test {
             description: "Some parametrised type".into(),
             bound: TypeDefBound::FromParams(vec![0]),
         };
-        let typ: Type = Type::new_extension(
+        let typ = Type::new_extension(
             def.instantiate(vec![TypeArg::Type {
                 ty: Type::new_function(FunctionType::new(vec![], vec![])),
             }])
             .unwrap(),
         );
         assert_eq!(typ.least_upper_bound(), TypeBound::Copyable);
-        let typ2: Type = Type::new_extension(def.instantiate([USIZE_T.into()]).unwrap());
+        let typ2 = Type::new_extension(def.instantiate([USIZE_T.into()]).unwrap());
         assert_eq!(typ2.least_upper_bound(), TypeBound::Eq);
 
         // And some bad arguments...firstly, wrong kind of TypeArg:

hugr-core/src/hugr/serialize/test.rs

@@ -381,7 +381,7 @@ fn constants_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
 
 #[test]
 fn serialize_types_roundtrip() {
-    let g = Type::new_function(FunctionType::new_endo(vec![]));
+    let g: Type = Type::new_function(FunctionType::new_endo(vec![]));
     check_testing_roundtrip(g.clone());
 
     // A Simple tuple
@@ -392,7 +392,7 @@ fn serialize_types_roundtrip() {
     let t = TypeRV::new_sum([type_row![USIZE_T], type_row![FLOAT64_TYPE]]);
     check_testing_roundtrip(t);
 
-    let t: Type = Type::new_unit_sum(4);
+    let t = Type::new_unit_sum(4);
     check_testing_roundtrip(t);
 }
 

hugr-core/src/hugr/validate.rs

@@ -298,11 +298,8 @@ impl<'a, 'b> ValidationContext<'a, 'b> {
         match &port_kind {
             EdgeKind::Value(ty) => ty.validate(self.extension_registry, var_decls),
             // Static edges must *not* refer to type variables declared by enclosing FuncDefns
-            // as these are only types at runtime. (Note the choice of `allow_row_vars` as `false` is arbitrary here.)
+            // as these are only types at runtime.
             EdgeKind::Const(ty) => ty.validate(self.extension_registry, &[]),
-            // Allow function "value" to have unknown arity. A Call node will have to provide
-            // TypeArgs that produce a known arity, but a LoadFunction might pass the function
-            // value ("function pointer") around without knowing how to call it.
             EdgeKind::Function(pf) => pf.validate(self.extension_registry),
             _ => Ok(()),
         }

hugr-core/src/ops/constant.rs

@@ -593,7 +593,7 @@ mod test {
     fn function_value(simple_dfg_hugr: Hugr) {
         let v = Value::function(simple_dfg_hugr).unwrap();
 
-        let correct_type: Type = Type::new_function(FunctionType::new_endo(type_row![
+        let correct_type = Type::new_function(FunctionType::new_endo(type_row![
             crate::extension::prelude::BOOL_T
         ]));
 
@@ -652,12 +652,12 @@ mod test {
         let yaml_const: Value =
             CustomSerialized::new(typ_int.clone(), YamlValue::Number(6.into()), ex_id.clone())
                 .into();
-        let classic_t: Type = Type::new_extension(typ_int.clone());
+        let classic_t = Type::new_extension(typ_int.clone());
         assert_matches!(classic_t.least_upper_bound(), TypeBound::Eq);
         assert_eq!(yaml_const.get_type(), classic_t);
 
         let typ_qb = CustomType::new("my_type", vec![], ex_id, TypeBound::Eq);
-        let t: Type = Type::new_extension(typ_qb.clone());
+        let t = Type::new_extension(typ_qb.clone());
         assert_ne!(yaml_const.get_type(), t);
     }
 

hugr-core/src/types.rs

@@ -50,7 +50,7 @@ pub enum EdgeKind {
     Value(Type),
     /// A reference to a static constant value - must be a Copyable type
     Const(Type),
-    /// A reference to a function i.e. [FuncDecl] or [FuncDefn]
+    /// A reference to a function i.e. [FuncDecl] or [FuncDefn].
     ///
     /// [FuncDecl]: crate::ops::FuncDecl
     /// [FuncDefn]: crate::ops::FuncDefn
@@ -259,7 +259,7 @@ impl<RV: MaybeRV> TypeEnum<RV> {
 /// # use hugr::types::{Type, TypeBound};
 /// # use hugr::type_row;
 ///
-/// let sum: Type = Type::new_sum([type_row![], type_row![]]);
+/// let sum = Type::new_sum([type_row![], type_row![]]);
 /// assert_eq!(sum.least_upper_bound(), TypeBound::Eq);
 /// ```
 ///
@@ -614,7 +614,6 @@ pub(crate) mod test {
         assert_eq!(pred1, pred2);
 
         let pred_direct = SumType::Unit { size: 2 };
-        // Pick <false> arbitrarily
         assert_eq!(pred1, Type::from(pred_direct));
     }
 

hugr-core/src/types/poly_func.rs

@@ -28,15 +28,15 @@ use super::{signature::FuncTypeBase, MaybeRV, NoRV, RowVariable};
     "params.iter().map(ToString::to_string).join(\" \")",
     "body"
 )]
-pub struct TypeSchemeBase<ROWVARS: MaybeRV = RowVariable> {
+pub struct TypeSchemeBase<RV: MaybeRV> {
     /// The declared type parameters, i.e., these must be instantiated with
     /// the same number of [TypeArg]s before the function can be called. This
     /// defines the indices used by variables inside the body.
     #[cfg_attr(test, proptest(strategy = "vec(any_with::<TypeParam>(params), 0..3)"))]
     params: Vec<TypeParam>,
     /// Template for the function. May contain variables up to length of [Self::params]
-    #[cfg_attr(test, proptest(strategy = "any_with::<FuncTypeBase<ROWVARS>>(params)"))]
-    body: FuncTypeBase<ROWVARS>,
+    #[cfg_attr(test, proptest(strategy = "any_with::<FuncTypeBase<RV>>(params)"))]
+    body: FuncTypeBase<RV>,
 }
 
 /// The polymorphic type of a [Call]-able function ([FuncDecl] or [FuncDefn]).
@@ -106,7 +106,7 @@ impl<RV: MaybeRV> TypeSchemeBase<RV> {
     }
 
     /// Create a new TypeSchemeBase given the kinds of the variables it declares
-    /// and the underlying function type.
+    /// and the underlying [FuncTypeBase].
     pub fn new(params: impl Into<Vec<TypeParam>>, body: impl Into<FuncTypeBase<RV>>) -> Self {
         Self {
             params: params.into(),

hugr-core/src/types/serialize.rs

@@ -58,7 +58,7 @@ impl<RV: MaybeRV> TryFrom<SerSimpleType> for TypeBase<RV> {
             SerSimpleType::Opaque(o) => TypeBase::new_extension(o),
             SerSimpleType::Alias(a) => TypeBase::new_alias(a),
             SerSimpleType::V { i, b } => TypeBase::new_var_use(i, b),
-            // We can't use new_row_var because that returns Type<true> not Type<RV>.
+            // We can't use new_row_var because that returns TypeRV not TypeBase<RV>.
             SerSimpleType::R { i, b } => TypeBase::new(TypeEnum::RowVar(
                 RV::try_from_rv(RowVariable(i, b))
                     .map_err(|var| SignatureError::RowVarWhereTypeExpected { var })?,

hugr-core/src/types/signature.rs

@@ -17,13 +17,13 @@ use {crate::proptest::RecursionDepth, ::proptest::prelude::*, proptest_derive::A
 
 #[derive(Clone, Debug, Eq, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(test, derive(Arbitrary), proptest(params = "RecursionDepth"))]
-/// Describes the edges required to/from a node (when ROWVARS=false);
-/// or (when ROWVARS=true) the type of a [Graph] or the inputs/outputs from an OpDef
+/// Describes the edges required to/from a node or inside a [FuncDefn] (when ROWVARS=[NoRV]);
+/// or (when ROWVARS=[RowVariable]) the type of a higher-order [function value] or the inputs/outputs from an OpDef
 ///
 /// ROWVARS specifies whether it may contain [RowVariable]s or not.
 ///
-/// [Graph]: crate::ops::constant::Value::Function
-/// [RowVariable]: crate::types::TypeEnum::RowVariable
+/// [function value]: crate::ops::constant::Value::Function
+/// [FuncDefn]: crate::ops::FuncDefn
 pub struct FuncTypeBase<ROWVARS: MaybeRV> {
     /// Value inputs of the function.
     #[cfg_attr(test, proptest(strategy = "any_with::<TypeRowBase<ROWVARS>>(params)"))]
@@ -35,12 +35,17 @@ pub struct FuncTypeBase<ROWVARS: MaybeRV> {
     pub extension_reqs: ExtensionSet,
 }
 
-/// The concept of "signature" in the spec - the edges required to/from a node or graph
-/// and also the target (value) of a call (static).
+/// The concept of "signature" in the spec - the edges required to/from a node
+/// or within a [FuncDefn], also the target (value) of a call (static).
+/// 
+/// [FuncDefn]: crate::ops::FuncDefn
 pub type FunctionType = FuncTypeBase<NoRV>;
 
 /// A function that may contain [RowVariable]s and thus has potentially-unknown arity;
-/// passable as a value round a Hugr (see [Type::new_function]) but not a valid node type.
+/// used for [OpDef]'s and passable as a value round a Hugr (see [Type::new_function])
+/// but not a valid node type.
+/// 
+/// [OpDef]: crate::extension::OpDef
 pub type FunctionTypeRV = FuncTypeBase<RowVariable>;
 
 impl<RV: MaybeRV> FuncTypeBase<RV> {
@@ -63,7 +68,7 @@ impl<RV: MaybeRV> FuncTypeBase<RV> {
         Self {
             input: input.into(),
             output: output.into(),
-            extension_reqs: ExtensionSet::default(),
+            extension_reqs: ExtensionSet::new(),
         }
     }
 

hugr-core/src/types/type_param.rs

@@ -46,11 +46,11 @@ impl UpperBound {
     }
 }
 
-/// A *kind* of [TypeArg]. Thus, a parameter declared by a [TypeSchemeRV] (e.g. [OpDef]),
-/// specifying a value that may (resp. must) be provided to instantiate it.
+/// A *kind* of [TypeArg]. Thus, a parameter declared by a [TypeScheme] or [TypeSchemeRV],
+/// specifying a value that must be provided statically in order to instantiate it.
 ///
+/// [TypeScheme]: super::TypeScheme
 /// [TypeSchemeRV]: super::TypeSchemeRV
-/// [OpDef]: crate::extension::OpDef
 #[derive(
     Clone, Debug, PartialEq, Eq, derive_more::Display, serde::Deserialize, serde::Serialize,
 )]

hugr/benches/benchmarks/types.rs

@@ -10,10 +10,10 @@ use criterion::{black_box, criterion_group, AxisScale, Criterion, PlotConfigurat
 fn make_complex_type() -> Type {
     let qb = QB_T;
     let int = USIZE_T;
-    let q_register: Type = Type::new_tuple(vec![qb; 8]);
+    let q_register = Type::new_tuple(vec![qb; 8]);
     let b_register = Type::new_tuple(vec![int; 8]);
     let q_alias = Type::new_alias(AliasDecl::new("QReg", TypeBound::Any));
-    let sum: Type = Type::new_sum([q_register, q_alias]);
+    let sum = Type::new_sum([q_register, q_alias]);
     Type::new_function(FunctionType::new(vec![sum], vec![b_register]))
 }