Add TypeBase<RV> w/out default, Type is alias for TypeBase<false>

When inference had figured out that Type == Type::<true>, we must now write TypeRV explicitly :(

Author: acl-cqc

hugr-core/src/builder/dataflow.rs

@@ -212,7 +212,7 @@ pub(crate) mod test {
 
     use crate::std_extensions::logic::test::and_op;
     use crate::types::type_param::TypeParam;
-    use crate::types::{FunTypeVarArgs, FunctionType, Type, TypeBound};
+    use crate::types::{FunTypeVarArgs, FunctionType, Type, TypeBound, TypeRV};
     use crate::utils::test_quantum_extension::h_gate;
     use crate::{
         builder::test::{n_identity, BIT, NAT, QB},
@@ -533,7 +533,7 @@ pub(crate) mod test {
     #[test]
     fn no_outer_row_variables() -> Result<(), BuildError> {
         let e = crate::hugr::validate::test::extension_with_eval_parallel();
-        let tv = Type::new_row_var_use(0, TypeBound::Copyable);
+        let tv = TypeRV::new_row_var_use(0, TypeBound::Copyable);
         // Can *declare* a function that takes a function-value of unknown #args
         FunctionBuilder::new(
             "bad_eval",

hugr-core/src/extension/op_def.rs

@@ -496,7 +496,7 @@ pub(super) mod test {
     use crate::ops::{CustomOp, OpName};
     use crate::std_extensions::collections::{EXTENSION, LIST_TYPENAME};
     use crate::types::type_param::{TypeArgError, TypeParam};
-    use crate::types::{FunctionType, PolyFuncType, Type, TypeArg, TypeBound};
+    use crate::types::{FunctionType, PolyFuncType, Type, TypeArg, TypeBound, TypeRV};
     use crate::{const_extension_ids, Extension};
 
     const_extension_ids! {
@@ -734,7 +734,7 @@ pub(super) mod test {
             Ok(FunctionType::new_endo(tv))
         );
         // But not with an external row variable
-        let arg: TypeArg = Type::new_row_var_use(0, TypeBound::Eq).into();
+        let arg: TypeArg = TypeRV::new_row_var_use(0, TypeBound::Eq).into();
         assert_eq!(
             def.compute_signature(&[arg.clone()], &EMPTY_REG),
             Err(SignatureError::TypeArgMismatch(

hugr-core/src/extension/prelude.rs

@@ -544,7 +544,7 @@ mod test {
     #[test]
     fn test_external_symbol() {
         let subject = ConstExternalSymbol::new("foo", Type::UNIT, false);
-        assert_eq!(subject.get_type(), Type::<false>::UNIT);
+        assert_eq!(subject.get_type(), Type::UNIT);
         assert_eq!(subject.name(), "@foo");
         assert!(subject.validate().is_ok());
         assert_eq!(

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

@@ -14,7 +14,9 @@ use crate::std_extensions::arithmetic::int_ops::INT_OPS_REGISTRY;
 use crate::std_extensions::arithmetic::int_types::{self, int_custom_type, ConstInt, INT_TYPES};
 use crate::std_extensions::logic::NotOp;
 use crate::types::type_param::TypeParam;
-use crate::types::{FunTypeVarArgs, FunctionType, PolyFuncType, SumType, Type, TypeArg, TypeBound};
+use crate::types::{
+    FunTypeVarArgs, FunctionType, PolyFuncType, SumType, Type, TypeArg, TypeBound, TypeRV,
+};
 use crate::{type_row, OutgoingPort};
 
 use itertools::Itertools;
@@ -30,7 +32,7 @@ const QB: Type = crate::extension::prelude::QB_T;
 /// Version 1 of the Testing HUGR serialisation format, see `testing_hugr.py`.
 #[derive(Serialize, Deserialize, PartialEq, Debug, Default)]
 struct SerTestingV1 {
-    typ: Option<crate::types::Type<true>>,
+    typ: Option<crate::types::TypeRV>,
     sum_type: Option<crate::types::SumType>,
     poly_func_type: Option<crate::types::PolyFuncType>,
     value: Option<crate::ops::Value>,
@@ -85,7 +87,7 @@ macro_rules! impl_sertesting_from {
     };
 }
 
-impl_sertesting_from!(crate::types::Type<true>, typ);
+impl_sertesting_from!(crate::types::TypeRV, typ);
 impl_sertesting_from!(crate::types::SumType, sum_type);
 impl_sertesting_from!(crate::types::PolyFuncType, poly_func_type);
 impl_sertesting_from!(crate::ops::Value, value);
@@ -99,9 +101,9 @@ impl From<PolyFuncType<false>> for TestingModel {
     }
 }
 
-impl From<Type<false>> for TestingModel {
-    fn from(v: Type<false>) -> Self {
-        let t: Type<true> = v.into();
+impl From<Type> for TestingModel {
+    fn from(v: Type) -> Self {
+        let t: TypeRV = v.into();
         t.into()
     }
 }
@@ -382,16 +384,15 @@ fn constants_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
 
 #[test]
 fn serialize_types_roundtrip() {
-    let g: Type<true> = Type::new_function(FunctionType::new_endo(vec![]));
-
+    let g = Type::new_function(FunctionType::new_endo(vec![]));
     check_testing_roundtrip(g.clone());
 
     // A Simple tuple
-    let t: Type = Type::new_tuple(vec![USIZE_T.into(), g]);
+    let t = Type::new_tuple(vec![USIZE_T.into(), g]);
     check_testing_roundtrip(t);
 
     // A Classic sum
-    let t: Type<true> = Type::new_sum([type_row![USIZE_T], type_row![FLOAT64_TYPE]]);
+    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);
@@ -438,11 +439,11 @@ fn polyfunctype1() -> PolyFuncType<false> {
 }
 
 fn polyfunctype2() -> PolyFuncType {
-    let tv0 = Type::new_row_var_use(0, TypeBound::Any);
-    let tv1 = Type::new_row_var_use(1, TypeBound::Eq);
+    let tv0 = TypeRV::new_row_var_use(0, TypeBound::Any);
+    let tv1 = TypeRV::new_row_var_use(1, TypeBound::Eq);
     let params = [TypeBound::Any, TypeBound::Eq].map(TypeParam::new_list);
     let inputs = vec![
-        Type::new_function(FunTypeVarArgs::new(tv0.clone(), tv1.clone())),
+        TypeRV::new_function(FunTypeVarArgs::new(tv0.clone(), tv1.clone())),
         tv0,
     ];
     let res = PolyFuncType::new(params, FunTypeVarArgs::new(inputs, tv1));
@@ -461,7 +462,7 @@ fn polyfunctype2() -> PolyFuncType {
 #[case(PolyFuncType::new([TypeParam::Tuple { params: [TypeBound::Any.into(), TypeParam::bounded_nat(2.try_into().unwrap())].into() }], FunctionType::new_endo(type_row![])))]
 #[case(PolyFuncType::new(
     [TypeParam::new_list(TypeBound::Any)],
-    FunctionType::new_endo(Type::new_tuple(Type::new_row_var_use(0, TypeBound::Any)))))]
+    FunctionType::new_endo(Type::new_tuple(TypeRV::new_row_var_use(0, TypeBound::Any)))))]
 fn roundtrip_polyfunctype_fixedlen(#[case] poly_func_type: PolyFuncType<false>) {
     check_testing_roundtrip(poly_func_type)
 }
@@ -474,7 +475,7 @@ fn roundtrip_polyfunctype_fixedlen(#[case] poly_func_type: PolyFuncType<false>)
 #[case(PolyFuncType::new([TypeParam::Tuple { params: [TypeBound::Any.into(), TypeParam::bounded_nat(2.try_into().unwrap())].into() }], FunctionType::new_endo(type_row![])))]
 #[case(PolyFuncType::new(
     [TypeParam::new_list(TypeBound::Any)],
-    FunTypeVarArgs::new_endo(Type::new_row_var_use(0, TypeBound::Any))))]
+    FunTypeVarArgs::new_endo(TypeRV::new_row_var_use(0, TypeBound::Any))))]
 #[case(polyfunctype2())]
 fn roundtrip_polyfunctype_varlen(#[case] poly_func_type: PolyFuncType<true>) {
     check_testing_roundtrip(poly_func_type)

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

@@ -18,7 +18,7 @@ use crate::std_extensions::logic::test::{and_op, or_op};
 use crate::std_extensions::logic::{self, NotOp};
 use crate::types::type_param::{TypeArg, TypeArgError};
 use crate::types::{
-    CustomType, FunTypeVarArgs, FunctionType, PolyFuncType, Type, TypeBound, TypeRow,
+    CustomType, FunTypeVarArgs, FunctionType, PolyFuncType, Type, TypeBound, TypeRV, TypeRow,
 };
 use crate::{const_extension_ids, type_row, Direction, IncomingPort, Node};
 
@@ -573,16 +573,16 @@ pub(crate) fn extension_with_eval_parallel() -> Extension {
     let rowp = TypeParam::new_list(TypeBound::Any);
     let mut e = Extension::new(EXT_ID);
 
-    let inputs = Type::new_row_var_use(0, TypeBound::Any);
-    let outputs = Type::new_row_var_use(1, TypeBound::Any);
-    let evaled_fn = Type::new_function(FunTypeVarArgs::new(inputs.clone(), outputs.clone()));
+    let inputs = TypeRV::new_row_var_use(0, TypeBound::Any);
+    let outputs = TypeRV::new_row_var_use(1, TypeBound::Any);
+    let evaled_fn = TypeRV::new_function(FunTypeVarArgs::new(inputs.clone(), outputs.clone()));
     let pf = PolyFuncType::new(
         [rowp.clone(), rowp.clone()],
         FunTypeVarArgs::new(vec![evaled_fn, inputs], outputs),
     );
     e.add_op("eval".into(), "".into(), pf).unwrap();
 
-    let rv = |idx| Type::new_row_var_use(idx, TypeBound::Any);
+    let rv = |idx| TypeRV::new_row_var_use(idx, TypeBound::Any);
     let pf = PolyFuncType::new(
         [rowp.clone(), rowp.clone(), rowp.clone(), rowp.clone()],
         FunctionType::new(
@@ -630,7 +630,7 @@ fn instantiate_row_variables() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-fn seq1ty(t: Type<true>) -> TypeArg {
+fn seq1ty(t: TypeRV) -> TypeArg {
     TypeArg::Sequence {
         elems: vec![t.into()],
     }
@@ -639,7 +639,7 @@ fn seq1ty(t: Type<true>) -> TypeArg {
 #[test]
 fn row_variables() -> Result<(), Box<dyn std::error::Error>> {
     let e = extension_with_eval_parallel();
-    let tv = Type::new_row_var_use(0, TypeBound::Any);
+    let tv = TypeRV::new_row_var_use(0, TypeBound::Any);
     let inner_ft = Type::new_function(FunTypeVarArgs::new_endo(tv.clone()));
     let ft_usz = Type::new_function(FunTypeVarArgs::new_endo(vec![tv.clone(), USIZE_T.into()]));
     let mut fb = FunctionBuilder::new(

hugr-core/src/ops/constant.rs

@@ -688,14 +688,12 @@ mod test {
                     32, // Target around 32 total elements
                     3,  // Each collection is up to 3 elements long
                     |child_strat| {
-                        (any::<Type<false>>(), vec(child_strat, 0..3)).prop_map(
-                            |(typ, children)| {
-                                Self::new(ListValue::new(
-                                    typ,
-                                    children.into_iter().map(|e| Value::Extension { e }),
-                                ))
-                            },
-                        )
+                        (any::<Type>(), vec(child_strat, 0..3)).prop_map(|(typ, children)| {
+                            Self::new(ListValue::new(
+                                typ,
+                                children.into_iter().map(|e| Value::Extension { e }),
+                            ))
+                        })
                     },
                 )
                 .boxed()

hugr-core/src/std_extensions/arithmetic/conversions.rs

@@ -12,7 +12,7 @@ use crate::{
     },
     ops::{custom::ExtensionOp, NamedOp},
     type_row,
-    types::{FunTypeVarArgs, PolyFuncType, Type, TypeArg},
+    types::{FunTypeVarArgs, PolyFuncType, TypeArg, TypeRV},
     Extension,
 };
 
@@ -46,7 +46,7 @@ impl MakeOpDef for ConvertOpDef {
             match self {
                 trunc_s | trunc_u => FunTypeVarArgs::new(
                     type_row![FLOAT64_TYPE],
-                    Type::<true>::from(sum_with_error(int_tv(0))),
+                    TypeRV::from(sum_with_error(int_tv(0))),
                 ),
                 convert_s | convert_u => {
                     FunTypeVarArgs::new(vec![int_tv(0)], type_row![FLOAT64_TYPE])