guppylang-internals 0.24.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

guppylang_internals/tys/param.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, TypeAlias
 
 from hugr import tys as ht
@@ -17,9 +17,9 @@ from guppylang_internals.tys.errors import WrongNumberOfTypeArgsError
 from guppylang_internals.tys.var import ExistentialVar
 
 if TYPE_CHECKING:
+    from guppylang_internals.tys.subst import PartialInst
     from guppylang_internals.tys.ty import Type
 
-
 # We define the `Parameter` type as a union of all `ParameterBase` subclasses defined
 # below. This models an algebraic data type and enables exhaustiveness checking in
 # pattern matches etc.
@@ -74,6 +74,10 @@ class ParameterBase(ToHugr[ht.TypeParam], ABC):
         parameter.
         """
 
+    @abstractmethod
+    def instantiate_bounds(self, inst: "PartialInst") -> Self:
+        """Instantiates bound variables mentioned in parameter bounds"""
+
 
 @dataclass(frozen=True)
 class TypeParam(ParameterBase):
@@ -142,10 +146,17 @@ class TypeParam(ParameterBase):
             BoundTypeVar(self.name, idx, self.must_be_copyable, self.must_be_droppable)
         )
 
+    def instantiate_bounds(self, inst: "PartialInst") -> "TypeParam":
+        """Instantiates bound variables mentioned in parameter bounds"""
+        # For now, type parameters don't have any bounds that could be instantiated
+        return self
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeParam:
         """Computes the Hugr representation of the parameter."""
         return ht.TypeTypeParam(
-            bound=ht.TypeBound.Linear if self.can_be_linear else ht.TypeBound.Copyable
+            bound=ht.TypeBound.Copyable
+            if self.must_be_copyable
+            else ht.TypeBound.Linear
         )
 
     def __str__(self) -> str:
@@ -157,18 +168,12 @@ class TypeParam(ParameterBase):
 class ConstParam(ParameterBase):
     """A parameter of kind constant. Used to define fixed-size arrays etc."""
 
-    ty: "Type"
+    ty: "Type" = field(hash=False)
 
     #: Marker to annotate if this parameter was implicitly generated by a `@comptime`
     #: annotated argument in a function signature.
     from_comptime_arg: bool = field(default=False, kw_only=True)
 
-    def __post_init__(self) -> None:
-        if self.ty.unsolved_vars:
-            raise InternalGuppyError(
-                "Attempted to create constant param with unsolved type"
-            )
-
     def with_idx(self, idx: int) -> "ConstParam":
         """Returns a copy of the parameter with a new index."""
         return ConstParam(idx, self.name, self.ty)
@@ -178,13 +183,16 @@ class ConstParam(ParameterBase):
 
         Raises a user error if the argument is not valid.
         """
+        from guppylang_internals.tys.ty import unify
+
         match arg:
             case ConstArg(const):
-                if const.ty != self.ty:
+                subst = unify(const.ty, self.ty, {})
+                if subst is None:
                     raise GuppyTypeError(
                         TypeMismatchError(loc, self.ty, const.ty, kind="argument")
                     )
-                return arg
+                return ConstArg(replace(const, ty=const.ty.substitute(subst)))
             case TypeArg(ty=ty):
                 err = ExpectedError(
                     loc, f"expression of type `{self.ty}`", got=f"type `{ty}`"
@@ -208,6 +216,13 @@ class ConstParam(ParameterBase):
             idx = self.idx
         return ConstArg(BoundConstVar(self.ty, self.name, idx))
 
+    def instantiate_bounds(self, inst: "PartialInst") -> "ConstParam":
+        """Instantiates bound variables mentioned in parameter bounds"""
+        from guppylang_internals.tys.subst import Instantiator
+
+        instantiator = Instantiator(inst)
+        return replace(self, ty=self.ty.transform(instantiator))
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeParam:
         """Computes the Hugr representation of the parameter."""
         from guppylang_internals.tys.ty import NumericType
@@ -231,6 +246,7 @@ def check_all_args(
     args: Sequence[Argument],
     type_name: str,
     loc: AstNode | None = None,
+    arg_locs: Sequence[AstNode] | None = None,
 ) -> None:
     """Checks a list of arguments against the given parameters.
 
@@ -245,7 +261,6 @@ def check_all_args(
         raise GuppyError(WrongNumberOfTypeArgsError(loc, exp, act, type_name))
 
     # Now check that the kinds match up
-    for param, arg in zip(params, args, strict=True):
-        # TODO: The error location is bad. We want the location of `arg`, not of the
-        #  whole thing.
-        param.check_arg(arg, loc)
+    for i, (param, arg) in enumerate(zip(params, args, strict=True)):
+        arg_loc = arg_locs[i] if arg_locs else loc
+        param.instantiate_bounds(args).check_arg(arg, arg_loc)

guppylang_internals/tys/parsing.py

@@ -39,7 +39,6 @@ from guppylang_internals.tys.errors import (
     WrongNumberOfTypeArgsError,
 )
 from guppylang_internals.tys.param import ConstParam, Parameter, TypeParam
-from guppylang_internals.tys.subst import BoundVarFinder
 from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
@@ -108,7 +107,7 @@ def arg_from_ast(node: AstNode, ctx: TypeParsingCtx) -> Argument:
                 return ConstArg(ConstValue(bool_type(), v))
             # Integer literals are turned into nat args.
             # TODO: To support int args, we need proper inference logic here
-            #   See https://github.com/CQCL/guppylang/issues/1030
+            #   See https://github.com/quantinuum/guppylang/issues/1030
             case int(v) if v >= 0:
                 nat_ty = NumericType(NumericType.Kind.Nat)
                 return ConstArg(ConstValue(nat_ty, v))
@@ -118,7 +117,7 @@ def arg_from_ast(node: AstNode, ctx: TypeParsingCtx) -> Argument:
             # String literals are ignored for now since they could also be stringified
             # types.
             # TODO: To support string args, we need proper inference logic here
-            #   See https://github.com/CQCL/guppylang/issues/1030
+            #   See https://github.com/quantinuum/guppylang/issues/1030
             case str(_):
                 pass
 
@@ -290,12 +289,18 @@ def check_function_arg(
         ctx.param_var_mapping[name] = ConstParam(
             len(ctx.param_var_mapping), name, ty, from_comptime_arg=True
         )
-    return FuncInput(ty, flags)
+    return FuncInput(ty, flags, name)
 
 
 if sys.version_info >= (3, 12):
 
-    def parse_parameter(node: ast.type_param, idx: int, globals: Globals) -> Parameter:
+    def parse_parameter(
+        node: ast.type_param,
+        idx: int,
+        globals: Globals,
+        param_var_mapping: dict[str, Parameter],
+        allow_free_vars: bool = False,
+    ) -> Parameter:
         """Parses a `Variable: Bound` generic type parameter declaration."""
         if isinstance(node, ast.TypeVarTuple | ast.ParamSpec):
             raise GuppyError(UnsupportedError(node, "Variadic generic parameters"))
@@ -331,18 +336,10 @@ if sys.version_info >= (3, 12):
                 # parameters, so we pass an empty dict as the `param_var_mapping`.
                 # TODO: In the future we might want to allow stuff like
                 #   `def foo[T, XS: array[T, 42]]` and so on
-                ctx = TypeParsingCtx(globals, param_var_mapping={})
+                ctx = TypeParsingCtx(globals, param_var_mapping, allow_free_vars)
                 ty = type_from_ast(bound, ctx)
                 if not ty.copyable or not ty.droppable:
                     raise GuppyError(LinearConstParamError(bound, ty))
-
-                # TODO: For now we can only do `nat` const args since they lower to
-                #  Hugr bounded nats. Extend to arbitrary types via monomorphization.
-                #  See https://github.com/CQCL/guppylang/issues/1008
-                if ty != NumericType(NumericType.Kind.Nat):
-                    raise GuppyError(
-                        UnsupportedError(bound, f"`{ty}` generic parameters")
-                    )
                 return ConstParam(idx, node.name, ty)
 
 
@@ -363,16 +360,6 @@ def type_with_flags_from_ast(
                 flags |= InputFlags.Comptime
                 if not ty.copyable or not ty.droppable:
                     raise GuppyError(LinearComptimeError(node.right, ty))
-                # For now, we don't allow comptime annotations on generic inputs
-                # TODO: In the future we might want to allow stuff like
-                #  `def foo[T: (Copy, Discard](x: T @comptime)`.
-                #   Also see the todo in `parse_parameter`.
-                var_finder = BoundVarFinder()
-                ty.visit(var_finder)
-                if var_finder.bound_vars:
-                    raise GuppyError(
-                        UnsupportedError(node.left, "Generic comptime arguments")
-                    )
             case _:
                 raise GuppyError(InvalidFlagError(node.right))
         return ty, flags

guppylang_internals/tys/printing.py

@@ -11,7 +11,6 @@ from guppylang_internals.tys.ty import (
     NumericType,
     OpaqueType,
     StructType,
-    SumType,
     TupleType,
     Type,
 )
@@ -122,11 +121,6 @@ class TypePrinter:
         args = ", ".join(self._visit(arg, True) for arg in ty.args)
         return f"({args})"
 
-    @_visit.register
-    def _visit_SumType(self, ty: SumType, inside_row: bool) -> str:
-        args = ", ".join(self._visit(arg, True) for arg in ty.args)
-        return f"Sum[{args}]"
-
     @_visit.register
     def _visit_NoneType(self, ty: NoneType, inside_row: bool) -> str:
         return "None"
@@ -168,7 +162,7 @@ def signature_to_str(name: str, sig: FunctionType) -> str:
     assert sig.input_names is not None
     s = f"def {name}("
     s += ", ".join(
-        f"{name}: {inp.ty}{TypePrinter._print_flags(inp.flags)}"
-        for name, inp in zip(sig.input_names, sig.inputs, strict=True)
+        f"{inp.name}: {inp.ty}{TypePrinter._print_flags(inp.flags)}"
+        for inp in sig.inputs
     )
     return s + ") -> " + str(sig.output)

guppylang_internals/tys/qubit.py

@@ -0,0 +1,62 @@
+import functools
+from typing import Any, cast
+
+from guppylang_internals.definition.ty import TypeDef
+from guppylang_internals.tys.arg import TypeArg
+from guppylang_internals.tys.common import Visitor
+from guppylang_internals.tys.ty import OpaqueType, Type
+
+
+@functools.cache
+def qubit_ty() -> Type:
+    """Returns the qubit type. Beware that this function imports guppylang definitions,
+    so, if called before the definitions are registered,
+    it might result in circular imports.
+    """
+    from guppylang.defs import GuppyDefinition
+    from guppylang.std.quantum import qubit
+
+    assert isinstance(qubit, GuppyDefinition)
+    qubit_ty = cast(TypeDef, qubit.wrapped).check_instantiate([])
+    return qubit_ty
+
+
+def is_qubit_ty(ty: Type) -> bool:
+    """Checks if the given type is the qubit type.
+    This function results in circular imports if called
+    before qubit types are registered.
+    """
+    return ty == qubit_ty()
+
+
+class QubitFinder(Visitor):
+    """Type visitor that checks if a type contains the qubit type."""
+
+    class FoundFlag(Exception):
+        pass
+
+    @functools.singledispatchmethod
+    def visit(self, ty: Any) -> bool:  # type: ignore[override]
+        return False
+
+    @visit.register
+    def _visit_OpaqueType(self, ty: OpaqueType) -> bool:
+        if is_qubit_ty(ty):
+            raise self.FoundFlag
+        return False
+
+    @visit.register
+    def _visit_TypeArg(self, arg: TypeArg) -> bool:
+        arg.ty.visit(self)
+        return True
+
+
+def contain_qubit_ty(ty: Type) -> bool:
+    """Checks if the given type contains the qubit type."""
+    finder = QubitFinder()
+    try:
+        ty.visit(finder)
+    except QubitFinder.FoundFlag:
+        return True
+    else:
+        return False

guppylang_internals/tys/subst.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from guppylang_internals.error import InternalGuppyError
 from guppylang_internals.tys.arg import Argument, ConstArg, TypeArg
-from guppylang_internals.tys.common import Transformer, Visitor
+from guppylang_internals.tys.common import Transformer
 from guppylang_internals.tys.const import (
     BoundConstVar,
     Const,
@@ -18,7 +18,7 @@ from guppylang_internals.tys.ty import (
     Type,
     TypeBase,
 )
-from guppylang_internals.tys.var import BoundVar, ExistentialVar
+from guppylang_internals.tys.var import ExistentialVar
 
 Subst = dict[ExistentialVar, Type | Const]
 Inst = Sequence[Argument]
@@ -51,7 +51,8 @@ class Substituter(Transformer):
 class Instantiator(Transformer):
     """Type transformer that instantiates bound variables."""
 
-    def __init__(self, inst: Inst) -> None:
+    def __init__(self, inst: PartialInst, allow_partial: bool = False) -> None:
+        self.allow_partial = allow_partial
         self.inst = inst
 
     @functools.singledispatchmethod
@@ -63,6 +64,8 @@ class Instantiator(Transformer):
         # Instantiate if type for the index is available
         if ty.idx < len(self.inst):
             arg = self.inst[ty.idx]
+            if arg is None and self.allow_partial:
+                return None
             assert isinstance(arg, TypeArg)
             return arg.ty
 
@@ -76,6 +79,8 @@ class Instantiator(Transformer):
         # Instantiate if const value for the index is available
         if c.idx < len(self.inst):
             arg = self.inst[c.idx]
+            if arg is None and self.allow_partial:
+                return None
             assert isinstance(arg, ConstArg)
             return arg.const
 
@@ -87,26 +92,3 @@ class Instantiator(Transformer):
         if ty.parametrized:
             raise InternalGuppyError("Tried to instantiate under binder")
         return None
-
-
-class BoundVarFinder(Visitor):
-    """Type visitor that looks for occurrences of bound variables."""
-
-    bound_vars: set[BoundVar]
-
-    def __init__(self) -> None:
-        self.bound_vars = set()
-
-    @functools.singledispatchmethod
-    def visit(self, ty: Any) -> bool:  # type: ignore[override]
-        return False
-
-    @visit.register
-    def _transform_BoundTypeVar(self, ty: BoundTypeVar) -> bool:
-        self.bound_vars.add(ty)
-        return False
-
-    @visit.register
-    def _transform_BoundConstVar(self, c: BoundConstVar) -> bool:
-        self.bound_vars.add(c)
-        return False

guppylang_internals/tys/ty.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from enum import Enum, Flag, auto
 from functools import cached_property, total_ordering
 from typing import TYPE_CHECKING, ClassVar, TypeAlias, cast
@@ -57,14 +57,11 @@ class TypeBase(ToHugr[ht.Type], Transformable["Type"], ABC):
         return not self.copyable and self.droppable
 
     @cached_property
-    @abstractmethod
     def hugr_bound(self) -> ht.TypeBound:
-        """The Hugr bound of this type, i.e. `Any`, `Copyable`, or `Equatable`.
-
-        This needs to be specified explicitly, since opaque nonlinear types in a Hugr
-        extension could be either declared as copyable or equatable. If we don't get the
-        bound exactly right during serialisation, the Hugr validator will complain.
-        """
+        """The Hugr bound of this type, i.e. `Any` or `Copyable`."""
+        if self.linear or self.affine:
+            return ht.TypeBound.Linear
+        return ht.TypeBound.Copyable
 
     @abstractmethod
     def cast(self) -> "Type":
@@ -79,6 +76,11 @@ class TypeBase(ToHugr[ht.Type], Transformable["Type"], ABC):
         """The existential type variables contained in this type."""
         return set()
 
+    @cached_property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        return set()
+
     def substitute(self, subst: "Subst") -> "Type":
         """Substitutes existential variables in this type."""
         from guppylang_internals.tys.subst import Substituter
@@ -158,13 +160,17 @@ class ParametrizedTypeBase(TypeBase, ABC):
         """The existential type variables contained in this type."""
         return set().union(*(arg.unsolved_vars for arg in self.args))
 
+    @cached_property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        return set().union(*(arg.bound_vars for arg in self.args))
+
     @cached_property
     def hugr_bound(self) -> ht.TypeBound:
-        """The Hugr bound of this type, i.e. `Any`, `Copyable`, or `Equatable`."""
-        if self.linear:
-            return ht.TypeBound.Linear
+        """The Hugr bound of this type, i.e. `Any` or `Copyable`."""
         return ht.TypeBound.join(
-            *(arg.ty.hugr_bound for arg in self.args if isinstance(arg, TypeArg))
+            super().hugr_bound,
+            *(arg.ty.hugr_bound for arg in self.args if isinstance(arg, TypeArg)),
         )
 
     def visit(self, visitor: Visitor) -> None:
@@ -187,14 +193,10 @@ class BoundTypeVar(TypeBase, BoundVar):
     copyable: bool
     droppable: bool
 
-    @cached_property
-    def hugr_bound(self) -> ht.TypeBound:
-        """The Hugr bound of this type, i.e. `Any`, `Copyable`, or `Equatable`."""
-        if self.linear:
-            return ht.TypeBound.Linear
-        # We're conservative and don't require equatability for non-linear variables.
-        # This is fine since Guppy doesn't use the equatable feature anyways.
-        return ht.TypeBound.Copyable
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        return {self}
 
     def cast(self) -> "Type":
         """Casts an implementor of `TypeBase` into a `Type`."""
@@ -367,6 +369,21 @@ class InputFlags(Flag):
     Comptime = auto()
 
 
+class UnitaryFlags(Flag):
+    """Flags that can be set on functions to indicate their unitary properties.
+
+    The flags indicate under which conditions a function can be used
+    in a unitary context.
+    """
+
+    NoFlags = 0
+    Control = auto()
+    Dagger = auto()
+    Power = auto()
+
+    Unitary = Control | Dagger | Power
+
+
 @dataclass(frozen=True)
 class FuncInput:
     """A single input of a function type."""
@@ -374,6 +391,10 @@ class FuncInput:
     ty: "Type"
     flags: InputFlags
 
+    #: Name of this input, or `None` if it is an unnamed argument (e.g. inside a
+    #: `Callable`). We use `compare=False` because names are not visible to the caller.
+    name: str | None = field(default=None, compare=False)
+
 
 @dataclass(frozen=True, init=False)
 class FunctionType(ParametrizedTypeBase):
@@ -382,7 +403,6 @@ class FunctionType(ParametrizedTypeBase):
     inputs: Sequence[FuncInput]
     output: "Type"
     params: Sequence[Parameter]
-    input_names: Sequence[str] | None
     comptime_args: Sequence[ConstArg]
 
     args: Sequence[Argument] = field(init=False)
@@ -392,13 +412,15 @@ class FunctionType(ParametrizedTypeBase):
     intrinsically_droppable: bool = field(default=True, init=True)
     hugr_bound: ht.TypeBound = field(default=ht.TypeBound.Copyable, init=False)
 
+    unitary_flags: UnitaryFlags = field(default=UnitaryFlags.NoFlags, init=True)
+
     def __init__(
         self,
         inputs: Sequence[FuncInput],
         output: "Type",
-        input_names: Sequence[str] | None = None,
         params: Sequence[Parameter] | None = None,
         comptime_args: Sequence[ConstArg] | None = None,
+        unitary_flags: UnitaryFlags = UnitaryFlags.NoFlags,
     ) -> None:
         # We need a custom __init__ to set the args
         args: list[Argument] = [TypeArg(inp.ty) for inp in inputs]
@@ -414,18 +436,43 @@ class FunctionType(ParametrizedTypeBase):
             ]
         args += comptime_args
 
+        # Either all inputs must have unique names, or none of them have names
+        names = {inp.name for inp in inputs if inp.name is not None}
+        if len(names) not in (0, len(inputs)):
+            raise InternalGuppyError(
+                "Tried to construct FunctionType with invalid input names"
+            )
+
         object.__setattr__(self, "args", args)
         object.__setattr__(self, "comptime_args", comptime_args)
         object.__setattr__(self, "inputs", inputs)
         object.__setattr__(self, "output", output)
-        object.__setattr__(self, "input_names", input_names or [])
         object.__setattr__(self, "params", params)
+        object.__setattr__(self, "unitary_flags", unitary_flags)
 
     @property
     def parametrized(self) -> bool:
         """Whether the function is parametrized."""
         return len(self.params) > 0
 
+    @cached_property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        if self.parametrized:
+            # Ensures that we don't look inside quantifiers
+            return set()
+        return super().bound_vars
+
+    @cached_property
+    def input_names(self) -> Sequence[str] | None:
+        """Names of all inputs or `None` if there are unnamed inputs."""
+        names: list[str] = []
+        for inp in self.inputs:
+            if inp.name is None:
+                return None
+            names.append(inp.name)
+        return names
+
     def cast(self) -> "Type":
         """Casts an implementor of `TypeBase` into a `Type`."""
         return self
@@ -484,12 +531,8 @@ class FunctionType(ParametrizedTypeBase):
     def transform(self, transformer: Transformer) -> "Type":
         """Accepts a transformer on this type."""
         return transformer.transform(self) or FunctionType(
-            [
-                FuncInput(inp.ty.transform(transformer), inp.flags)
-                for inp in self.inputs
-            ],
+            [replace(inp, ty=inp.ty.transform(transformer)) for inp in self.inputs],
             self.output.transform(transformer),
-            self.input_names,
             self.params,
         )
 
@@ -506,7 +549,7 @@ class FunctionType(ParametrizedTypeBase):
             # However, we have to down-shift the de Bruijn index.
             if arg is None:
                 param = param.with_idx(len(remaining_params))
-                remaining_params.append(param)
+                remaining_params.append(param.instantiate_bounds(full_inst))
                 arg = param.to_bound()
 
             # Set the `preserve` flag for instantiated tuples and None
@@ -519,9 +562,8 @@ class FunctionType(ParametrizedTypeBase):
 
         inst = Instantiator(full_inst)
         return FunctionType(
-            [FuncInput(inp.ty.transform(inst), inp.flags) for inp in self.inputs],
+            [replace(inp, ty=inp.ty.transform(inst)) for inp in self.inputs],
             self.output.transform(inst),
-            self.input_names,
             remaining_params,
             # Comptime type arguments also need to be instantiated
             comptime_args=[
@@ -538,6 +580,18 @@ class FunctionType(ParametrizedTypeBase):
         exs = [param.to_existential() for param in self.params]
         return self.instantiate([arg for arg, _ in exs]), [var for _, var in exs]
 
+    def with_unitary_flags(self, flags: UnitaryFlags) -> "FunctionType":
+        """Returns a copy of this function type with the specified unitary flags."""
+        # N.B. we can't use `dataclasses.replace` here since `FunctionType` has a custom
+        # constructor
+        return FunctionType(
+            self.inputs,
+            self.output,
+            self.params,
+            self.comptime_args,
+            flags,
+        )
+
 
 @dataclass(frozen=True, init=False)
 class TupleType(ParametrizedTypeBase):
@@ -582,53 +636,6 @@ class TupleType(ParametrizedTypeBase):
         )
 
 
-@dataclass(frozen=True, init=False)
-class SumType(ParametrizedTypeBase):
-    """Type of sums.
-
-    Note that this type is only used internally when constructing the Hugr. Users cannot
-    write down this type.
-    """
-
-    element_types: Sequence["Type"]
-
-    def __init__(self, element_types: Sequence["Type"]) -> None:
-        # We need a custom __init__ to set the args
-        args = [TypeArg(ty) for ty in element_types]
-        object.__setattr__(self, "args", args)
-        object.__setattr__(self, "element_types", element_types)
-
-    @property
-    def intrinsically_copyable(self) -> bool:
-        """Whether objects of this type can be implicitly copied."""
-        return True
-
-    @property
-    def intrinsically_droppable(self) -> bool:
-        """Whether objects of this type can be dropped."""
-        return True
-
-    def cast(self) -> "Type":
-        """Casts an implementor of `TypeBase` into a `Type`."""
-        return self
-
-    def to_hugr(self, ctx: ToHugrContext) -> ht.Sum:
-        """Computes the Hugr representation of the type."""
-        rows = [type_to_row(ty) for ty in self.element_types]
-        if all(len(row) == 0 for row in rows):
-            return ht.UnitSum(size=len(rows))
-        elif len(rows) == 1:
-            return ht.Tuple(*row_to_hugr(rows[0], ctx))
-        else:
-            return ht.Sum(variant_rows=rows_to_hugr(rows, ctx))
-
-    def transform(self, transformer: Transformer) -> "Type":
-        """Accepts a transformer on this type."""
-        return transformer.transform(self) or SumType(
-            [ty.transform(transformer) for ty in self.element_types]
-        )
-
-
 @dataclass(frozen=True)
 class OpaqueType(ParametrizedTypeBase):
     """Type that is directly backed by a Hugr opaque type.
@@ -651,7 +658,7 @@ class OpaqueType(ParametrizedTypeBase):
 
     @property
     def hugr_bound(self) -> ht.TypeBound:
-        """The Hugr bound of this type, i.e. `Any`, `Copyable`, or `Equatable`."""
+        """The Hugr bound of this type, i.e. `Any` or `Copyable`."""
         if self.defn.bound is not None:
             return self.defn.bound
         return super().hugr_bound
@@ -717,9 +724,8 @@ class StructType(ParametrizedTypeBase):
 
 
 #: The type of parametrized Guppy types.
-ParametrizedType: TypeAlias = (
-    FunctionType | TupleType | SumType | OpaqueType | StructType
-)
+ParametrizedType: TypeAlias = FunctionType | TupleType | OpaqueType | StructType
+
 
 #: The type of Guppy types.
 #:
@@ -801,8 +807,6 @@ def unify(s: Type | Const, t: Type | Const, subst: "Subst | None") -> "Subst | N
             return _unify_args(s, t, subst)
         case TupleType() as s, TupleType() as t:
             return _unify_args(s, t, subst)
-        case SumType() as s, SumType() as t:
-            return _unify_args(s, t, subst)
         case OpaqueType() as s, OpaqueType() as t if s.defn == t.defn:
             return _unify_args(s, t, subst)
         case StructType() as s, StructType() as t if s.defn == t.defn:
@@ -871,6 +875,8 @@ def function_tensor_signature(tys: list[FunctionType]) -> FunctionType:
     outputs: list[Type] = []
     for fun_ty in tys:
         assert not fun_ty.parametrized
-        inputs.extend(fun_ty.inputs)
+        # Forget the function input names since they might be non-unique across the
+        # tensored functions
+        inputs.extend([replace(inp, name=None) for inp in fun_ty.inputs])
         outputs.extend(type_to_row(fun_ty.output))
     return FunctionType(inputs, row_to_type(outputs))