Try multiple singletons, new one for const.

Author: kevinhartman

qiskit/circuit/classical/types/types.py

@@ -31,11 +31,11 @@
 
 
 class _Singleton(type):
-    """Metaclass to make the child, which should take zero initialization arguments, a singleton
+    """Metaclass to make the child, which should take a single "const" argument, a singleton
     object."""
 
-    def _get_singleton_instance(cls):
-        return cls._INSTANCE
+    def _get_singleton_instance(cls, const=False):
+        return cls._CONST_INSTANCE if const else cls._INSTANCE
 
     @classmethod
     def __prepare__(mcs, name, bases):  # pylint: disable=unused-argument
@@ -45,6 +45,7 @@ def __prepare__(mcs, name, bases):  # pylint: disable=unused-argument
     def __new__(cls, name, bases, namespace):
         out = super().__new__(cls, name, bases, namespace)
         out._INSTANCE = object.__new__(out)  # pylint: disable=invalid-name
+        out._CONST_INSTANCE = object.__new__(out)  # pylint: disable=invalid-name
         return out
 
 
@@ -88,13 +89,18 @@ def __setstate__(self, state):
 
 
 @typing.final
-class Bool(Type):
+class Bool(Type, metaclass=_Singleton):
     """The Boolean type.  This has exactly two values: ``True`` and ``False``."""
 
-    __slots__ = ("const",)
+    __slots__ = ()
 
-    def __init__(self, *, const: bool = False):
-        super(Type, self).__setattr__("const", const)
+    def __new__(cls, *, const=False):
+        return cls._get_singleton_instance(const)
+
+    @property
+    def const(self):
+        # Check if this instance is the const singleton.
+        return self is self.__class__._CONST_INSTANCE
 
     def __repr__(self):
         return f"Bool(const={self.const})"

test/python/circuit/classical/test_expr_properties.py

@@ -33,6 +33,21 @@ def test_bool_type_is_singleton(self):
         self.assertIs(types.Bool(), copy.deepcopy(types.Bool()))
         self.assertIs(types.Bool(), pickle.loads(pickle.dumps(types.Bool())))
 
+    def test_const_bool_type_is_singleton(self):
+        """The `Bool` type is meant (and used) as a Python singleton object for efficiency.  It must
+        always be referentially equal to all other references to it."""
+        self.assertIs(types.Bool(const=True), types.Bool(const=True))
+        self.assertIs(types.Bool(const=True), copy.copy(types.Bool(const=True)))
+        self.assertIs(types.Bool(const=True), copy.deepcopy(types.Bool(const=True)))
+        self.assertIs(types.Bool(const=True), pickle.loads(pickle.dumps(types.Bool(const=True))))
+
+    def test_bool_type_singleton_is_not_const_bool_type_singleton(self):
+        """The const `Bool` and non-const `Bool` should not share the same singleton."""
+        self.assertIsNot(types.Bool(const=True), types.Bool())
+        self.assertIsNot(types.Bool(const=True), copy.copy(types.Bool()))
+        self.assertIsNot(types.Bool(const=True), copy.deepcopy(types.Bool()))
+        self.assertIsNot(types.Bool(const=True), pickle.loads(pickle.dumps(types.Bool())))
+
     @ddt.data(types.Bool(), types.Uint(8))
     def test_types_can_be_cloned(self, obj):
         """Test that various ways of cloning a `Type` object are valid and produce equal output."""