libqasm 0.5.2__cp38-cp38-win_amd64.whl → 0.6.1__cp38-cp38-win_amd64.whl

cqasm/v3x/values.py

@@ -589,9 +589,7 @@ def _cloned(obj):
     return obj
 
 
-class Constant(Node):
-    """Constant value"""
-
+class ValueBase(Node):
     __slots__ = []
 
     def __init__(self):
@@ -610,22 +608,16 @@ class Constant(Node):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ == 'ConstAxis':
-            return ConstAxis._deserialize(cbor, seq_to_ob, links)
         if typ == 'ConstBool':
             return ConstBool._deserialize(cbor, seq_to_ob, links)
         if typ == 'ConstInt':
             return ConstInt._deserialize(cbor, seq_to_ob, links)
-        if typ == 'ConstReal':
-            return ConstReal._deserialize(cbor, seq_to_ob, links)
-        if typ == 'ConstComplex':
-            return ConstComplex._deserialize(cbor, seq_to_ob, links)
-        if typ == 'ConstBoolArray':
-            return ConstBoolArray._deserialize(cbor, seq_to_ob, links)
-        if typ == 'ConstIntArray':
-            return ConstIntArray._deserialize(cbor, seq_to_ob, links)
-        if typ == 'ConstRealArray':
-            return ConstRealArray._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ConstFloat':
+            return ConstFloat._deserialize(cbor, seq_to_ob, links)
+        if typ == 'IndexRef':
+            return IndexRef._deserialize(cbor, seq_to_ob, links)
+        if typ == 'VariableRef':
+            return VariableRef._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -633,7 +625,7 @@ class Constant(Node):
         CBOR serialization. The tree that the node belongs to must be
         well-formed. id_map must match Python id() calls for all nodes to unique
         integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'Constant'}
+        cbor = {'@i': id_map[id(self)], '@t': 'ValueBase'}
 
         # Serialize annotations.
         for key, val in self._annot.items():
@@ -642,116 +634,21 @@ class Constant(Node):
         return cbor
 
 
-class MultiConstant(_Multiple):
-    """Wrapper for an edge with multiple Constant objects."""
+class MultiValueBase(_Multiple):
+    """Wrapper for an edge with multiple ValueBase objects."""
 
-    _T = Constant
+    _T = ValueBase
 
 
-_typemap['Constant'] = Constant
+_typemap['ValueBase'] = ValueBase
 
-class ConstAxis(Constant):
-    """Represents an axis value (x, y, and z vectors)."""
+class Constant(ValueBase):
+    """Constant value"""
 
-    __slots__ = [
-        '_attr_value',
-    ]
+    __slots__ = []
 
-    def __init__(
-        self,
-        value=None,
-    ):
+    def __init__(self):
         super().__init__()
-        self.value = value
-
-    @property
-    def value(self):
-        return self._attr_value
-
-    @value.setter
-    def value(self, val):
-        if val is None:
-            del self.value
-            return
-        if not isinstance(val, cqasm.v3x.primitives.Axis):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('value must be of type cqasm.v3x.primitives.Axis')
-            val = cqasm.v3x.primitives.Axis(val)
-        self._attr_value = val
-
-    @value.deleter
-    def value(self):
-        self._attr_value = cqasm.v3x.primitives.Axis()
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, ConstAxis):
-            return False
-        if self.value != other.value:
-            return False
-        return True
-
-    def dump(self, indent=0, annotations=None, links=1):
-        """Returns a debug representation of this tree as a multiline string.
-        indent is the number of double spaces prefixed before every line.
-        annotations, if specified, must be a set-like object containing the key
-        strings of the annotations that are to be printed. links specifies the
-        maximum link recursion depth."""
-        s = ['  '*indent]
-        s.append('ConstAxis(')
-        if annotations is None:
-            annotations = []
-        for key in annotations:
-            if key in self:
-                s.append(' # {}: {}'.format(key, self[key]))
-        s.append('\n')
-        indent += 1
-        s.append('  '*indent)
-        s.append('value: ')
-        s.append(str(self.value) + '\n')
-        indent -= 1
-        s.append('  '*indent)
-        s.append(')')
-        return ''.join(s)
-
-    __str__ = dump
-    __repr__ = dump
-
-    def find_reachable(self, id_map=None):
-        """Returns a dictionary mapping Python id() values to stable sequence
-        numbers for all nodes in the tree rooted at this node. If id_map is
-        specified, found nodes are appended to it."""
-        if id_map is None:
-            id_map = {}
-        if id(self) in id_map:
-            raise NotWellFormed('node {!r} with id {} occurs more than once'.format(self, id(self)))
-        id_map[id(self)] = len(id_map)
-        return id_map
-
-    def check_complete(self, id_map=None):
-        """Raises NotWellFormed if the tree rooted at this node is not
-        well-formed. If id_map is specified, this tree is only a subtree in the
-        context of a larger tree, and id_map must be a dict mapping from Python
-        id() codes to tree indices for all reachable nodes."""
-        if id_map is None:
-            id_map = self.find_reachable()
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return ConstAxis(
-            value=self._attr_value
-        )
-
-    def clone(self):
-        """Returns a deep copy of this node. This mimics the C++ interface,
-        deficiencies with links included; that is, links always point to the
-        original tree. If you're not cloning a subtree in a context where this
-        is the desired behavior, you may want to use the copy.deepcopy() from
-        the stdlib instead, which should copy links correctly."""
-        return ConstAxis(
-            value=_cloned(self._attr_value)
-        )
 
     @staticmethod
     def _deserialize(cbor, seq_to_ob, links):
@@ -766,50 +663,20 @@ class ConstAxis(Constant):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'ConstAxis':
-            raise ValueError('found node serialization for ' + typ + ', but expected ConstAxis')
-
-        # Deserialize the value field.
-        field = cbor.get('value', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field value')
-        if hasattr(cqasm.v3x.primitives.Axis, 'deserialize_cbor'):
-            f_value = cqasm.v3x.primitives.Axis.deserialize_cbor(field)
-        else:
-            f_value = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Axis, field)
-
-        # Construct the ConstAxis node.
-        node = ConstAxis(f_value)
-
-        # Deserialize annotations.
-        for key, val in cbor.items():
-            if not (key.startswith('{') and key.endswith('}')):
-                continue
-            key = key[1:-1]
-            node[key] = cqasm.v3x.primitives.deserialize(key, val)
-
-        # Register node in sequence number lookup.
-        seq = cbor.get('@i', None)
-        if not isinstance(seq, int):
-            raise ValueError('sequence number field (@i) is not an integer or missing from node serialization')
-        if seq in seq_to_ob:
-            raise ValueError('duplicate sequence number %d' % seq)
-        seq_to_ob[seq] = node
-
-        return node
+        if typ == 'ConstBool':
+            return ConstBool._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ConstInt':
+            return ConstInt._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ConstFloat':
+            return ConstFloat._deserialize(cbor, seq_to_ob, links)
+        raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
         """Serializes this node to the Python primitive representation of its
         CBOR serialization. The tree that the node belongs to must be
         well-formed. id_map must match Python id() calls for all nodes to unique
         integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'ConstAxis'}
-
-        # Serialize the value field.
-        if hasattr(self._attr_value, 'serialize_cbor'):
-            cbor['value'] = self._attr_value.serialize_cbor()
-        else:
-            cbor['value'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Axis, self._attr_value)
+        cbor = {'@i': id_map[id(self)], '@t': 'Constant'}
 
         # Serialize annotations.
         for key, val in self._annot.items():
@@ -818,13 +685,13 @@ class ConstAxis(Constant):
         return cbor
 
 
-class MultiConstAxis(_Multiple):
-    """Wrapper for an edge with multiple ConstAxis objects."""
+class MultiConstant(_Multiple):
+    """Wrapper for an edge with multiple Constant objects."""
 
-    _T = ConstAxis
+    _T = Constant
 
 
-_typemap['ConstAxis'] = ConstAxis
+_typemap['Constant'] = Constant
 
 class ConstBool(Constant):
     __slots__ = [
@@ -1000,7 +867,7 @@ class MultiConstBool(_Multiple):
 
 _typemap['ConstBool'] = ConstBool
 
-class ConstBoolArray(Constant):
+class ConstFloat(Constant):
     __slots__ = [
         '_attr_value',
     ]
@@ -1021,20 +888,20 @@ class ConstBoolArray(Constant):
         if val is None:
             del self.value
             return
-        if not isinstance(val, MultiConstBool):
+        if not isinstance(val, cqasm.v3x.primitives.Float):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('value must be of type MultiConstBool')
-            val = MultiConstBool(val)
+                raise TypeError('value must be of type cqasm.v3x.primitives.Float')
+            val = cqasm.v3x.primitives.Float(val)
         self._attr_value = val
 
     @value.deleter
     def value(self):
-        self._attr_value = MultiConstBool()
+        self._attr_value = cqasm.v3x.primitives.Float()
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, ConstBoolArray):
+        if not isinstance(other, ConstFloat):
             return False
         if self.value != other.value:
             return False
@@ -1047,7 +914,7 @@ class ConstBoolArray(Constant):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('ConstBoolArray(')
+        s.append('ConstFloat(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -1057,13 +924,7 @@ class ConstBoolArray(Constant):
         indent += 1
         s.append('  '*indent)
         s.append('value: ')
-        if not self.value:
-            s.append('!MISSING\n')
-        else:
-            s.append('[\n')
-            for child in self.value:
-                s.append(child.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + ']\n')
+        s.append(str(self.value) + '\n')
         indent -= 1
         s.append('  '*indent)
         s.append(')')
@@ -1081,8 +942,6 @@ class ConstBoolArray(Constant):
         if id(self) in id_map:
             raise NotWellFormed('node {!r} with id {} occurs more than once'.format(self, id(self)))
         id_map[id(self)] = len(id_map)
-        for el in self._attr_value:
-            el.find_reachable(id_map)
         return id_map
 
     def check_complete(self, id_map=None):
@@ -1092,15 +951,11 @@ class ConstBoolArray(Constant):
         id() codes to tree indices for all reachable nodes."""
         if id_map is None:
             id_map = self.find_reachable()
-        if not self._attr_value:
-            raise NotWellFormed('value needs at least one node but has zero')
-        for child in self._attr_value:
-            child.check_complete(id_map)
 
     def copy(self):
         """Returns a shallow copy of this node."""
-        return ConstBoolArray(
-            value=self._attr_value.copy()
+        return ConstFloat(
+            value=self._attr_value
         )
 
     def clone(self):
@@ -1109,7 +964,7 @@ class ConstBoolArray(Constant):
         original tree. If you're not cloning a subtree in a context where this
         is the desired behavior, you may want to use the copy.deepcopy() from
         the stdlib instead, which should copy links correctly."""
-        return ConstBoolArray(
+        return ConstFloat(
             value=_cloned(self._attr_value)
         )
 
@@ -1126,26 +981,20 @@ class ConstBoolArray(Constant):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'ConstBoolArray':
-            raise ValueError('found node serialization for ' + typ + ', but expected ConstBoolArray')
+        if typ != 'ConstFloat':
+            raise ValueError('found node serialization for ' + typ + ', but expected ConstFloat')
 
         # Deserialize the value field.
         field = cbor.get('value', None)
         if not isinstance(field, dict):
             raise ValueError('missing or invalid serialization of field value')
-        if field.get('@T') != '+':
-            raise ValueError('unexpected edge type for field value')
-        data = field.get('@d', None)
-        if not isinstance(data, list):
-            raise ValueError('missing serialization of Any/Many contents')
-        f_value = MultiConstBool()
-        for element in data:
-            if element.get('@T') != '1':
-                raise ValueError('unexpected edge type for Any/Many element')
-            f_value.append(ConstBool._deserialize(element, seq_to_ob, links))
+        if hasattr(cqasm.v3x.primitives.Float, 'deserialize_cbor'):
+            f_value = cqasm.v3x.primitives.Float.deserialize_cbor(field)
+        else:
+            f_value = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Float, field)
 
-        # Construct the ConstBoolArray node.
-        node = ConstBoolArray(f_value)
+        # Construct the ConstFloat node.
+        node = ConstFloat(f_value)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1169,17 +1018,13 @@ class ConstBoolArray(Constant):
         CBOR serialization. The tree that the node belongs to must be
         well-formed. id_map must match Python id() calls for all nodes to unique
         integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'ConstBoolArray'}
+        cbor = {'@i': id_map[id(self)], '@t': 'ConstFloat'}
 
         # Serialize the value field.
-        field = {'@T': '+'}
-        lst = []
-        for el in self._attr_value:
-            el = el._serialize(id_map)
-            el['@T'] = '1'
-            lst.append(el)
-        field['@d'] = lst
-        cbor['value'] = field
+        if hasattr(self._attr_value, 'serialize_cbor'):
+            cbor['value'] = self._attr_value.serialize_cbor()
+        else:
+            cbor['value'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Float, self._attr_value)
 
         # Serialize annotations.
         for key, val in self._annot.items():
@@ -1188,15 +1033,15 @@ class ConstBoolArray(Constant):
         return cbor
 
 
-class MultiConstBoolArray(_Multiple):
-    """Wrapper for an edge with multiple ConstBoolArray objects."""
+class MultiConstFloat(_Multiple):
+    """Wrapper for an edge with multiple ConstFloat objects."""
 
-    _T = ConstBoolArray
+    _T = ConstFloat
 
 
-_typemap['ConstBoolArray'] = ConstBoolArray
+_typemap['ConstFloat'] = ConstFloat
 
-class ConstComplex(Constant):
+class ConstInt(Constant):
     __slots__ = [
         '_attr_value',
     ]
@@ -1217,20 +1062,20 @@ class ConstComplex(Constant):
         if val is None:
             del self.value
             return
-        if not isinstance(val, cqasm.v3x.primitives.Complex):
+        if not isinstance(val, cqasm.v3x.primitives.Int):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('value must be of type cqasm.v3x.primitives.Complex')
-            val = cqasm.v3x.primitives.Complex(val)
+                raise TypeError('value must be of type cqasm.v3x.primitives.Int')
+            val = cqasm.v3x.primitives.Int(val)
         self._attr_value = val
 
     @value.deleter
     def value(self):
-        self._attr_value = cqasm.v3x.primitives.Complex()
+        self._attr_value = cqasm.v3x.primitives.Int()
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, ConstComplex):
+        if not isinstance(other, ConstInt):
             return False
         if self.value != other.value:
             return False
@@ -1243,7 +1088,7 @@ class ConstComplex(Constant):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('ConstComplex(')
+        s.append('ConstInt(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -1283,7 +1128,7 @@ class ConstComplex(Constant):
 
     def copy(self):
         """Returns a shallow copy of this node."""
-        return ConstComplex(
+        return ConstInt(
             value=self._attr_value
         )
 
@@ -1293,7 +1138,7 @@ class ConstComplex(Constant):
         original tree. If you're not cloning a subtree in a context where this
         is the desired behavior, you may want to use the copy.deepcopy() from
         the stdlib instead, which should copy links correctly."""
-        return ConstComplex(
+        return ConstInt(
             value=_cloned(self._attr_value)
         )
 
@@ -1310,20 +1155,20 @@ class ConstComplex(Constant):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'ConstComplex':
-            raise ValueError('found node serialization for ' + typ + ', but expected ConstComplex')
+        if typ != 'ConstInt':
+            raise ValueError('found node serialization for ' + typ + ', but expected ConstInt')
 
         # Deserialize the value field.
         field = cbor.get('value', None)
         if not isinstance(field, dict):
             raise ValueError('missing or invalid serialization of field value')
-        if hasattr(cqasm.v3x.primitives.Complex, 'deserialize_cbor'):
-            f_value = cqasm.v3x.primitives.Complex.deserialize_cbor(field)
+        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
+            f_value = cqasm.v3x.primitives.Int.deserialize_cbor(field)
         else:
-            f_value = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Complex, field)
+            f_value = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
 
-        # Construct the ConstComplex node.
-        node = ConstComplex(f_value)
+        # Construct the ConstInt node.
+        node = ConstInt(f_value)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1347,13 +1192,13 @@ class ConstComplex(Constant):
         CBOR serialization. The tree that the node belongs to must be
         well-formed. id_map must match Python id() calls for all nodes to unique
         integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'ConstComplex'}
+        cbor = {'@i': id_map[id(self)], '@t': 'ConstInt'}
 
         # Serialize the value field.
         if hasattr(self._attr_value, 'serialize_cbor'):
             cbor['value'] = self._attr_value.serialize_cbor()
         else:
-            cbor['value'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Complex, self._attr_value)
+            cbor['value'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_value)
 
         # Serialize annotations.
         for key, val in self._annot.items():
@@ -1362,755 +1207,15 @@ class ConstComplex(Constant):
         return cbor
 
 
-class MultiConstComplex(_Multiple):
-    """Wrapper for an edge with multiple ConstComplex objects."""
-
-    _T = ConstComplex
-
-
-_typemap['ConstComplex'] = ConstComplex
-
-class ConstInt(Constant):
-    __slots__ = [
-        '_attr_value',
-    ]
-
-    def __init__(
-        self,
-        value=None,
-    ):
-        super().__init__()
-        self.value = value
-
-    @property
-    def value(self):
-        return self._attr_value
-
-    @value.setter
-    def value(self, val):
-        if val is None:
-            del self.value
-            return
-        if not isinstance(val, cqasm.v3x.primitives.Int):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('value must be of type cqasm.v3x.primitives.Int')
-            val = cqasm.v3x.primitives.Int(val)
-        self._attr_value = val
-
-    @value.deleter
-    def value(self):
-        self._attr_value = cqasm.v3x.primitives.Int()
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, ConstInt):
-            return False
-        if self.value != other.value:
-            return False
-        return True
+class MultiConstInt(_Multiple):
+    """Wrapper for an edge with multiple ConstInt objects."""
 
-    def dump(self, indent=0, annotations=None, links=1):
-        """Returns a debug representation of this tree as a multiline string.
-        indent is the number of double spaces prefixed before every line.
-        annotations, if specified, must be a set-like object containing the key
-        strings of the annotations that are to be printed. links specifies the
-        maximum link recursion depth."""
-        s = ['  '*indent]
-        s.append('ConstInt(')
-        if annotations is None:
-            annotations = []
-        for key in annotations:
-            if key in self:
-                s.append(' # {}: {}'.format(key, self[key]))
-        s.append('\n')
-        indent += 1
-        s.append('  '*indent)
-        s.append('value: ')
-        s.append(str(self.value) + '\n')
-        indent -= 1
-        s.append('  '*indent)
-        s.append(')')
-        return ''.join(s)
-
-    __str__ = dump
-    __repr__ = dump
-
-    def find_reachable(self, id_map=None):
-        """Returns a dictionary mapping Python id() values to stable sequence
-        numbers for all nodes in the tree rooted at this node. If id_map is
-        specified, found nodes are appended to it."""
-        if id_map is None:
-            id_map = {}
-        if id(self) in id_map:
-            raise NotWellFormed('node {!r} with id {} occurs more than once'.format(self, id(self)))
-        id_map[id(self)] = len(id_map)
-        return id_map
-
-    def check_complete(self, id_map=None):
-        """Raises NotWellFormed if the tree rooted at this node is not
-        well-formed. If id_map is specified, this tree is only a subtree in the
-        context of a larger tree, and id_map must be a dict mapping from Python
-        id() codes to tree indices for all reachable nodes."""
-        if id_map is None:
-            id_map = self.find_reachable()
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return ConstInt(
-            value=self._attr_value
-        )
-
-    def clone(self):
-        """Returns a deep copy of this node. This mimics the C++ interface,
-        deficiencies with links included; that is, links always point to the
-        original tree. If you're not cloning a subtree in a context where this
-        is the desired behavior, you may want to use the copy.deepcopy() from
-        the stdlib instead, which should copy links correctly."""
-        return ConstInt(
-            value=_cloned(self._attr_value)
-        )
-
-    @staticmethod
-    def _deserialize(cbor, seq_to_ob, links):
-        """Attempts to deserialize the given cbor object (in Python primitive
-        representation) into a node of this type. All (sub)nodes are added to
-        the seq_to_ob dict, indexed by their cbor sequence number. All links are
-        registered in the links list by means of a two-tuple of the setter
-        function for the link field and the sequence number of the target node.
-        """
-        if not isinstance(cbor, dict):
-            raise TypeError('node description object must be a dict')
-        typ = cbor.get('@t', None)
-        if typ is None:
-            raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'ConstInt':
-            raise ValueError('found node serialization for ' + typ + ', but expected ConstInt')
-
-        # Deserialize the value field.
-        field = cbor.get('value', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field value')
-        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
-            f_value = cqasm.v3x.primitives.Int.deserialize_cbor(field)
-        else:
-            f_value = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
-
-        # Construct the ConstInt node.
-        node = ConstInt(f_value)
-
-        # Deserialize annotations.
-        for key, val in cbor.items():
-            if not (key.startswith('{') and key.endswith('}')):
-                continue
-            key = key[1:-1]
-            node[key] = cqasm.v3x.primitives.deserialize(key, val)
-
-        # Register node in sequence number lookup.
-        seq = cbor.get('@i', None)
-        if not isinstance(seq, int):
-            raise ValueError('sequence number field (@i) is not an integer or missing from node serialization')
-        if seq in seq_to_ob:
-            raise ValueError('duplicate sequence number %d' % seq)
-        seq_to_ob[seq] = node
-
-        return node
-
-    def _serialize(self, id_map):
-        """Serializes this node to the Python primitive representation of its
-        CBOR serialization. The tree that the node belongs to must be
-        well-formed. id_map must match Python id() calls for all nodes to unique
-        integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'ConstInt'}
-
-        # Serialize the value field.
-        if hasattr(self._attr_value, 'serialize_cbor'):
-            cbor['value'] = self._attr_value.serialize_cbor()
-        else:
-            cbor['value'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_value)
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiConstInt(_Multiple):
-    """Wrapper for an edge with multiple ConstInt objects."""
-
-    _T = ConstInt
+    _T = ConstInt
 
 
 _typemap['ConstInt'] = ConstInt
 
-class ConstIntArray(Constant):
-    __slots__ = [
-        '_attr_value',
-    ]
-
-    def __init__(
-        self,
-        value=None,
-    ):
-        super().__init__()
-        self.value = value
-
-    @property
-    def value(self):
-        return self._attr_value
-
-    @value.setter
-    def value(self, val):
-        if val is None:
-            del self.value
-            return
-        if not isinstance(val, MultiConstInt):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('value must be of type MultiConstInt')
-            val = MultiConstInt(val)
-        self._attr_value = val
-
-    @value.deleter
-    def value(self):
-        self._attr_value = MultiConstInt()
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, ConstIntArray):
-            return False
-        if self.value != other.value:
-            return False
-        return True
-
-    def dump(self, indent=0, annotations=None, links=1):
-        """Returns a debug representation of this tree as a multiline string.
-        indent is the number of double spaces prefixed before every line.
-        annotations, if specified, must be a set-like object containing the key
-        strings of the annotations that are to be printed. links specifies the
-        maximum link recursion depth."""
-        s = ['  '*indent]
-        s.append('ConstIntArray(')
-        if annotations is None:
-            annotations = []
-        for key in annotations:
-            if key in self:
-                s.append(' # {}: {}'.format(key, self[key]))
-        s.append('\n')
-        indent += 1
-        s.append('  '*indent)
-        s.append('value: ')
-        if not self.value:
-            s.append('!MISSING\n')
-        else:
-            s.append('[\n')
-            for child in self.value:
-                s.append(child.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + ']\n')
-        indent -= 1
-        s.append('  '*indent)
-        s.append(')')
-        return ''.join(s)
-
-    __str__ = dump
-    __repr__ = dump
-
-    def find_reachable(self, id_map=None):
-        """Returns a dictionary mapping Python id() values to stable sequence
-        numbers for all nodes in the tree rooted at this node. If id_map is
-        specified, found nodes are appended to it."""
-        if id_map is None:
-            id_map = {}
-        if id(self) in id_map:
-            raise NotWellFormed('node {!r} with id {} occurs more than once'.format(self, id(self)))
-        id_map[id(self)] = len(id_map)
-        for el in self._attr_value:
-            el.find_reachable(id_map)
-        return id_map
-
-    def check_complete(self, id_map=None):
-        """Raises NotWellFormed if the tree rooted at this node is not
-        well-formed. If id_map is specified, this tree is only a subtree in the
-        context of a larger tree, and id_map must be a dict mapping from Python
-        id() codes to tree indices for all reachable nodes."""
-        if id_map is None:
-            id_map = self.find_reachable()
-        if not self._attr_value:
-            raise NotWellFormed('value needs at least one node but has zero')
-        for child in self._attr_value:
-            child.check_complete(id_map)
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return ConstIntArray(
-            value=self._attr_value.copy()
-        )
-
-    def clone(self):
-        """Returns a deep copy of this node. This mimics the C++ interface,
-        deficiencies with links included; that is, links always point to the
-        original tree. If you're not cloning a subtree in a context where this
-        is the desired behavior, you may want to use the copy.deepcopy() from
-        the stdlib instead, which should copy links correctly."""
-        return ConstIntArray(
-            value=_cloned(self._attr_value)
-        )
-
-    @staticmethod
-    def _deserialize(cbor, seq_to_ob, links):
-        """Attempts to deserialize the given cbor object (in Python primitive
-        representation) into a node of this type. All (sub)nodes are added to
-        the seq_to_ob dict, indexed by their cbor sequence number. All links are
-        registered in the links list by means of a two-tuple of the setter
-        function for the link field and the sequence number of the target node.
-        """
-        if not isinstance(cbor, dict):
-            raise TypeError('node description object must be a dict')
-        typ = cbor.get('@t', None)
-        if typ is None:
-            raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'ConstIntArray':
-            raise ValueError('found node serialization for ' + typ + ', but expected ConstIntArray')
-
-        # Deserialize the value field.
-        field = cbor.get('value', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field value')
-        if field.get('@T') != '+':
-            raise ValueError('unexpected edge type for field value')
-        data = field.get('@d', None)
-        if not isinstance(data, list):
-            raise ValueError('missing serialization of Any/Many contents')
-        f_value = MultiConstInt()
-        for element in data:
-            if element.get('@T') != '1':
-                raise ValueError('unexpected edge type for Any/Many element')
-            f_value.append(ConstInt._deserialize(element, seq_to_ob, links))
-
-        # Construct the ConstIntArray node.
-        node = ConstIntArray(f_value)
-
-        # Deserialize annotations.
-        for key, val in cbor.items():
-            if not (key.startswith('{') and key.endswith('}')):
-                continue
-            key = key[1:-1]
-            node[key] = cqasm.v3x.primitives.deserialize(key, val)
-
-        # Register node in sequence number lookup.
-        seq = cbor.get('@i', None)
-        if not isinstance(seq, int):
-            raise ValueError('sequence number field (@i) is not an integer or missing from node serialization')
-        if seq in seq_to_ob:
-            raise ValueError('duplicate sequence number %d' % seq)
-        seq_to_ob[seq] = node
-
-        return node
-
-    def _serialize(self, id_map):
-        """Serializes this node to the Python primitive representation of its
-        CBOR serialization. The tree that the node belongs to must be
-        well-formed. id_map must match Python id() calls for all nodes to unique
-        integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'ConstIntArray'}
-
-        # Serialize the value field.
-        field = {'@T': '+'}
-        lst = []
-        for el in self._attr_value:
-            el = el._serialize(id_map)
-            el['@T'] = '1'
-            lst.append(el)
-        field['@d'] = lst
-        cbor['value'] = field
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiConstIntArray(_Multiple):
-    """Wrapper for an edge with multiple ConstIntArray objects."""
-
-    _T = ConstIntArray
-
-
-_typemap['ConstIntArray'] = ConstIntArray
-
-class ConstReal(Constant):
-    __slots__ = [
-        '_attr_value',
-    ]
-
-    def __init__(
-        self,
-        value=None,
-    ):
-        super().__init__()
-        self.value = value
-
-    @property
-    def value(self):
-        return self._attr_value
-
-    @value.setter
-    def value(self, val):
-        if val is None:
-            del self.value
-            return
-        if not isinstance(val, cqasm.v3x.primitives.Real):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('value must be of type cqasm.v3x.primitives.Real')
-            val = cqasm.v3x.primitives.Real(val)
-        self._attr_value = val
-
-    @value.deleter
-    def value(self):
-        self._attr_value = cqasm.v3x.primitives.Real()
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, ConstReal):
-            return False
-        if self.value != other.value:
-            return False
-        return True
-
-    def dump(self, indent=0, annotations=None, links=1):
-        """Returns a debug representation of this tree as a multiline string.
-        indent is the number of double spaces prefixed before every line.
-        annotations, if specified, must be a set-like object containing the key
-        strings of the annotations that are to be printed. links specifies the
-        maximum link recursion depth."""
-        s = ['  '*indent]
-        s.append('ConstReal(')
-        if annotations is None:
-            annotations = []
-        for key in annotations:
-            if key in self:
-                s.append(' # {}: {}'.format(key, self[key]))
-        s.append('\n')
-        indent += 1
-        s.append('  '*indent)
-        s.append('value: ')
-        s.append(str(self.value) + '\n')
-        indent -= 1
-        s.append('  '*indent)
-        s.append(')')
-        return ''.join(s)
-
-    __str__ = dump
-    __repr__ = dump
-
-    def find_reachable(self, id_map=None):
-        """Returns a dictionary mapping Python id() values to stable sequence
-        numbers for all nodes in the tree rooted at this node. If id_map is
-        specified, found nodes are appended to it."""
-        if id_map is None:
-            id_map = {}
-        if id(self) in id_map:
-            raise NotWellFormed('node {!r} with id {} occurs more than once'.format(self, id(self)))
-        id_map[id(self)] = len(id_map)
-        return id_map
-
-    def check_complete(self, id_map=None):
-        """Raises NotWellFormed if the tree rooted at this node is not
-        well-formed. If id_map is specified, this tree is only a subtree in the
-        context of a larger tree, and id_map must be a dict mapping from Python
-        id() codes to tree indices for all reachable nodes."""
-        if id_map is None:
-            id_map = self.find_reachable()
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return ConstReal(
-            value=self._attr_value
-        )
-
-    def clone(self):
-        """Returns a deep copy of this node. This mimics the C++ interface,
-        deficiencies with links included; that is, links always point to the
-        original tree. If you're not cloning a subtree in a context where this
-        is the desired behavior, you may want to use the copy.deepcopy() from
-        the stdlib instead, which should copy links correctly."""
-        return ConstReal(
-            value=_cloned(self._attr_value)
-        )
-
-    @staticmethod
-    def _deserialize(cbor, seq_to_ob, links):
-        """Attempts to deserialize the given cbor object (in Python primitive
-        representation) into a node of this type. All (sub)nodes are added to
-        the seq_to_ob dict, indexed by their cbor sequence number. All links are
-        registered in the links list by means of a two-tuple of the setter
-        function for the link field and the sequence number of the target node.
-        """
-        if not isinstance(cbor, dict):
-            raise TypeError('node description object must be a dict')
-        typ = cbor.get('@t', None)
-        if typ is None:
-            raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'ConstReal':
-            raise ValueError('found node serialization for ' + typ + ', but expected ConstReal')
-
-        # Deserialize the value field.
-        field = cbor.get('value', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field value')
-        if hasattr(cqasm.v3x.primitives.Real, 'deserialize_cbor'):
-            f_value = cqasm.v3x.primitives.Real.deserialize_cbor(field)
-        else:
-            f_value = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Real, field)
-
-        # Construct the ConstReal node.
-        node = ConstReal(f_value)
-
-        # Deserialize annotations.
-        for key, val in cbor.items():
-            if not (key.startswith('{') and key.endswith('}')):
-                continue
-            key = key[1:-1]
-            node[key] = cqasm.v3x.primitives.deserialize(key, val)
-
-        # Register node in sequence number lookup.
-        seq = cbor.get('@i', None)
-        if not isinstance(seq, int):
-            raise ValueError('sequence number field (@i) is not an integer or missing from node serialization')
-        if seq in seq_to_ob:
-            raise ValueError('duplicate sequence number %d' % seq)
-        seq_to_ob[seq] = node
-
-        return node
-
-    def _serialize(self, id_map):
-        """Serializes this node to the Python primitive representation of its
-        CBOR serialization. The tree that the node belongs to must be
-        well-formed. id_map must match Python id() calls for all nodes to unique
-        integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'ConstReal'}
-
-        # Serialize the value field.
-        if hasattr(self._attr_value, 'serialize_cbor'):
-            cbor['value'] = self._attr_value.serialize_cbor()
-        else:
-            cbor['value'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Real, self._attr_value)
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiConstReal(_Multiple):
-    """Wrapper for an edge with multiple ConstReal objects."""
-
-    _T = ConstReal
-
-
-_typemap['ConstReal'] = ConstReal
-
-class ConstRealArray(Constant):
-    __slots__ = [
-        '_attr_value',
-    ]
-
-    def __init__(
-        self,
-        value=None,
-    ):
-        super().__init__()
-        self.value = value
-
-    @property
-    def value(self):
-        return self._attr_value
-
-    @value.setter
-    def value(self, val):
-        if val is None:
-            del self.value
-            return
-        if not isinstance(val, MultiConstReal):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('value must be of type MultiConstReal')
-            val = MultiConstReal(val)
-        self._attr_value = val
-
-    @value.deleter
-    def value(self):
-        self._attr_value = MultiConstReal()
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, ConstRealArray):
-            return False
-        if self.value != other.value:
-            return False
-        return True
-
-    def dump(self, indent=0, annotations=None, links=1):
-        """Returns a debug representation of this tree as a multiline string.
-        indent is the number of double spaces prefixed before every line.
-        annotations, if specified, must be a set-like object containing the key
-        strings of the annotations that are to be printed. links specifies the
-        maximum link recursion depth."""
-        s = ['  '*indent]
-        s.append('ConstRealArray(')
-        if annotations is None:
-            annotations = []
-        for key in annotations:
-            if key in self:
-                s.append(' # {}: {}'.format(key, self[key]))
-        s.append('\n')
-        indent += 1
-        s.append('  '*indent)
-        s.append('value: ')
-        if not self.value:
-            s.append('!MISSING\n')
-        else:
-            s.append('[\n')
-            for child in self.value:
-                s.append(child.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + ']\n')
-        indent -= 1
-        s.append('  '*indent)
-        s.append(')')
-        return ''.join(s)
-
-    __str__ = dump
-    __repr__ = dump
-
-    def find_reachable(self, id_map=None):
-        """Returns a dictionary mapping Python id() values to stable sequence
-        numbers for all nodes in the tree rooted at this node. If id_map is
-        specified, found nodes are appended to it."""
-        if id_map is None:
-            id_map = {}
-        if id(self) in id_map:
-            raise NotWellFormed('node {!r} with id {} occurs more than once'.format(self, id(self)))
-        id_map[id(self)] = len(id_map)
-        for el in self._attr_value:
-            el.find_reachable(id_map)
-        return id_map
-
-    def check_complete(self, id_map=None):
-        """Raises NotWellFormed if the tree rooted at this node is not
-        well-formed. If id_map is specified, this tree is only a subtree in the
-        context of a larger tree, and id_map must be a dict mapping from Python
-        id() codes to tree indices for all reachable nodes."""
-        if id_map is None:
-            id_map = self.find_reachable()
-        if not self._attr_value:
-            raise NotWellFormed('value needs at least one node but has zero')
-        for child in self._attr_value:
-            child.check_complete(id_map)
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return ConstRealArray(
-            value=self._attr_value.copy()
-        )
-
-    def clone(self):
-        """Returns a deep copy of this node. This mimics the C++ interface,
-        deficiencies with links included; that is, links always point to the
-        original tree. If you're not cloning a subtree in a context where this
-        is the desired behavior, you may want to use the copy.deepcopy() from
-        the stdlib instead, which should copy links correctly."""
-        return ConstRealArray(
-            value=_cloned(self._attr_value)
-        )
-
-    @staticmethod
-    def _deserialize(cbor, seq_to_ob, links):
-        """Attempts to deserialize the given cbor object (in Python primitive
-        representation) into a node of this type. All (sub)nodes are added to
-        the seq_to_ob dict, indexed by their cbor sequence number. All links are
-        registered in the links list by means of a two-tuple of the setter
-        function for the link field and the sequence number of the target node.
-        """
-        if not isinstance(cbor, dict):
-            raise TypeError('node description object must be a dict')
-        typ = cbor.get('@t', None)
-        if typ is None:
-            raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'ConstRealArray':
-            raise ValueError('found node serialization for ' + typ + ', but expected ConstRealArray')
-
-        # Deserialize the value field.
-        field = cbor.get('value', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field value')
-        if field.get('@T') != '+':
-            raise ValueError('unexpected edge type for field value')
-        data = field.get('@d', None)
-        if not isinstance(data, list):
-            raise ValueError('missing serialization of Any/Many contents')
-        f_value = MultiConstReal()
-        for element in data:
-            if element.get('@T') != '1':
-                raise ValueError('unexpected edge type for Any/Many element')
-            f_value.append(ConstReal._deserialize(element, seq_to_ob, links))
-
-        # Construct the ConstRealArray node.
-        node = ConstRealArray(f_value)
-
-        # Deserialize annotations.
-        for key, val in cbor.items():
-            if not (key.startswith('{') and key.endswith('}')):
-                continue
-            key = key[1:-1]
-            node[key] = cqasm.v3x.primitives.deserialize(key, val)
-
-        # Register node in sequence number lookup.
-        seq = cbor.get('@i', None)
-        if not isinstance(seq, int):
-            raise ValueError('sequence number field (@i) is not an integer or missing from node serialization')
-        if seq in seq_to_ob:
-            raise ValueError('duplicate sequence number %d' % seq)
-        seq_to_ob[seq] = node
-
-        return node
-
-    def _serialize(self, id_map):
-        """Serializes this node to the Python primitive representation of its
-        CBOR serialization. The tree that the node belongs to must be
-        well-formed. id_map must match Python id() calls for all nodes to unique
-        integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'ConstRealArray'}
-
-        # Serialize the value field.
-        field = {'@T': '+'}
-        lst = []
-        for el in self._attr_value:
-            el = el._serialize(id_map)
-            el['@T'] = '1'
-            lst.append(el)
-        field['@d'] = lst
-        cbor['value'] = field
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiConstRealArray(_Multiple):
-    """Wrapper for an edge with multiple ConstRealArray objects."""
-
-    _T = ConstRealArray
-
-
-_typemap['ConstRealArray'] = ConstRealArray
-
-class Reference(Node):
+class Reference(ValueBase):
     """Reference to some storage location"""
 
     __slots__ = []