Split sequence into tuple and list in Python.

Author: zrho

hugr-py/src/hugr/_serialization/tys.py

@@ -158,12 +158,20 @@ def deserialize(self) -> tys.StringArg:
         return tys.StringArg(value=self.arg)
 
 
-class SequenceArg(BaseTypeArg):
-    tya: Literal["Sequence"] = "Sequence"
+class ListArg(BaseTypeArg):
+    tya: Literal["List"] = "List"
     elems: list[TypeArg]
 
-    def deserialize(self) -> tys.SequenceArg:
-        return tys.SequenceArg(elems=deser_it(self.elems))
+    def deserialize(self) -> tys.ListArg:
+        return tys.ListArg(elems=deser_it(self.elems))
+
+
+class TupleArg(BaseTypeArg):
+    tya: Literal["Tuple"] = "Tuple"
+    elems: list[TypeArg]
+
+    def deserialize(self) -> tys.TupleArg:
+        return tys.TupleArg(elems=deser_it(self.elems))
 
 
 class VariableArg(BaseTypeArg):
@@ -179,7 +187,12 @@ class TypeArg(RootModel):
     """A type argument."""
 
     root: Annotated[
-        TypeTypeArg | BoundedNatArg | StringArg | SequenceArg | VariableArg,
+        TypeTypeArg
+        | BoundedNatArg
+        | StringArg
+        | ListArg
+        | TupleArg
+        | VariableArg,
         WrapValidator(_json_custom_error_validator),
     ] = Field(discriminator="tya")
 

hugr-py/src/hugr/ops.py

@@ -534,7 +534,7 @@ def cached_signature(self) -> tys.FunctionType | None:
         )
 
     def type_args(self) -> list[tys.TypeArg]:
-        return [tys.SequenceArg([t.type_arg() for t in self.types])]
+        return [tys.ListArg([t.type_arg() for t in self.types])]
 
     def __call__(self, *elements: ComWire) -> Command:
         return super().__call__(*elements)
@@ -576,7 +576,7 @@ def cached_signature(self) -> tys.FunctionType | None:
         )
 
     def type_args(self) -> list[tys.TypeArg]:
-        return [tys.SequenceArg([t.type_arg() for t in self.types])]
+        return [tys.ListArg([t.type_arg() for t in self.types])]
 
     @property
     def num_out(self) -> int:

hugr-py/src/hugr/tys.py

@@ -245,26 +245,43 @@ def to_model(self) -> model.Term:
 
 
 @dataclass(frozen=True)
-class SequenceArg(TypeArg):
-    """Sequence of type arguments, for a :class:`ListParam` or :class:`TupleParam`."""
+class ListArg(TypeArg):
+    """Sequence of type arguments for a :class:`ListParam`."""
 
     elems: list[TypeArg]
 
-    def _to_serial(self) -> stys.SequenceArg:
-        return stys.SequenceArg(elems=ser_it(self.elems))
+    def _to_serial(self) -> stys.ListArg:
+        return stys.ListArg(elems=ser_it(self.elems))
 
     def resolve(self, registry: ext.ExtensionRegistry) -> TypeArg:
-        return SequenceArg([arg.resolve(registry) for arg in self.elems])
+        return ListArg([arg.resolve(registry) for arg in self.elems])
 
     def __str__(self) -> str:
-        return f"({comma_sep_str(self.elems)})"
+        return f"[{comma_sep_str(self.elems)}]"
 
     def to_model(self) -> model.Term:
-        # TODO: We should separate lists and tuples.
-        # For now we assume that this is a list.
         return model.List([elem.to_model() for elem in self.elems])
 
 
+@dataclass(frozen=True)
+class TupleArg(TypeArg):
+    """Sequence of type arguments for a :class:`TupleParam`."""
+
+    elems: list[TypeArg]
+
+    def _to_serial(self) -> stys.TupleArg:
+        return stys.TupleArg(elems=ser_it(self.elems))
+
+    def resolve(self, registry: ext.ExtensionRegistry) -> TypeArg:
+        return TupleArg([arg.resolve(registry) for arg in self.elems])
+
+    def __str__(self) -> str:
+        return f"({comma_sep_str(self.elems)})"
+
+    def to_model(self) -> model.Term:
+        return model.Tuple([elem.to_model() for elem in self.elems])
+
+
 @dataclass(frozen=True)
 class VariableArg(TypeArg):
     """A type argument variable."""

hugr-py/tests/test_tys.py

@@ -22,7 +22,8 @@
     PolyFuncType,
     Qubit,
     RowVariable,
-    SequenceArg,
+    ListArg,
+    TupleArg,
     StringArg,
     StringParam,
     Sum,
@@ -107,7 +108,11 @@ def test_params_str(param: TypeParam, string: str):
         (BoundedNatArg(3), "3"),
         (StringArg("hello"), '"hello"'),
         (
-            SequenceArg([TypeTypeArg(Qubit), BoundedNatArg(3)]),
+            ListArg([TypeTypeArg(Qubit), BoundedNatArg(3)]),
+            "[Type(Qubit), 3]",
+        ),
+        (
+            TupleArg([TypeTypeArg(Qubit), BoundedNatArg(3)]),
             "(Type(Qubit), 3)",
         ),
         (VariableArg(2, StringParam()), "$2"),