Merge remote-tracking branch 'origin/arrays/clone-discard' into arrays/conversion

Author: mark-koch

Cargo.lock

@@ -66,10 +66,10 @@ static_assertions = "1.1.0"
 strum = "0.27.0"
 thiserror = "2.0.12"
 typetag = "0.2.20"
-clap = { version = "4.5.36" }
+clap = { version = "4.5.37" }
 clio = "0.3.5"
 clap-verbosity-flag = "3.0.1"
-assert_cmd = "2.0.14"
+assert_cmd = "2.0.17"
 assert_fs = "1.1.1"
 predicates = "3.1.0"
 indexmap = "2.9.0"

Cargo.toml

@@ -23,9 +23,9 @@ use crate::types::type_param::{TypeArg, TypeParam};
 use crate::types::{CustomCheckFailure, Type, TypeBound, TypeName};
 use crate::Extension;
 
-pub use array_clone::{GenericArrayClone, GenericArrayCloneDef};
+pub use array_clone::{GenericArrayClone, GenericArrayCloneDef, ARRAY_CLONE_OP_ID};
 pub use array_conversion::{Direction, GenericArrayConvert, GenericArrayConvertDef, FROM, INTO};
-pub use array_discard::{GenericArrayDiscard, GenericArrayDiscardDef};
+pub use array_discard::{GenericArrayDiscard, GenericArrayDiscardDef, ARRAY_DISCARD_OP_ID};
 pub use array_kind::ArrayKind;
 pub use array_op::{GenericArrayOp, GenericArrayOpDef};
 pub use array_repeat::{GenericArrayRepeat, GenericArrayRepeatDef, ARRAY_REPEAT_OP_ID};
@@ -75,9 +75,9 @@ pub type ArrayScanDef = GenericArrayScanDef<Array>;
 /// Array operations.
 pub type ArrayOp = GenericArrayOp<Array>;
 /// The array clone operation.
-pub type ArrayClone = GenericArrayRepeat<Array>;
+pub type ArrayClone = GenericArrayClone<Array>;
 /// The array discard operation.
-pub type ArrayDiscard = GenericArrayRepeat<Array>;
+pub type ArrayDiscard = GenericArrayDiscard<Array>;
 /// The array repeat operation.
 pub type ArrayRepeat = GenericArrayRepeat<Array>;
 /// The array scan operation.

hugr-core/src/std_extensions/collections/array.rs

@@ -122,12 +122,17 @@ pub struct GenericArrayClone<AK: ArrayKind> {
 
 impl<AK: ArrayKind> GenericArrayClone<AK> {
     /// Creates a new array clone op.
-    pub fn new(elem_ty: Type, size: u64) -> Option<Self> {
-        elem_ty.copyable().then_some(GenericArrayClone {
-            elem_ty,
-            size,
-            _kind: PhantomData,
-        })
+    ///
+    /// Returns an error if the proveded element type is not copyable.
+    pub fn new(elem_ty: Type, size: u64) -> Result<Self, OpLoadError> {
+        elem_ty
+            .copyable()
+            .then_some(GenericArrayClone {
+                elem_ty,
+                size,
+                _kind: PhantomData,
+            })
+            .ok_or(SignatureError::InvalidTypeArgs.into())
     }
 }
 
@@ -202,7 +207,10 @@ mod tests {
         let new_op: GenericArrayClone<AK> = optype.cast().unwrap();
         assert_eq!(new_op, op);
 
-        assert_eq!(GenericArrayClone::<AK>::new(qb_t(), 2), None);
+        assert_eq!(
+            GenericArrayClone::<AK>::new(qb_t(), 2),
+            Err(OpLoadError::InvalidArgs(SignatureError::InvalidTypeArgs))
+        );
     }
 
     #[rstest]