Add a sink operation to avoid dangling nodes

Closes #132 (closed)

Adds a sink operation

No tests were added because I didn't think there was a nice way to test something that does "nothing".

b_asic/core_operations.py

@@ -73,7 +73,6 @@ class Constant(AbstractOperation):
     def __str__(self) -> str:
         return f"{self.value}"
 
-
 class Addition(AbstractOperation):
     """
     Binary addition operation.
@@ -1263,3 +1262,46 @@ class Shift(AbstractOperation):
         if not isinstance(value, int):
             raise TypeError("value must be an int")
         self.set_param("value", value)
+
+class Sink(AbstractOperation):
+    r"""
+    Sink operation.
+
+    Used for ignoring the output from another operation to avoid dangling output nodes.
+
+    Parameters
+    ==========
+
+    name : Name, optional
+        Operation name.
+    """
+
+    _execution_time = 0
+    is_linear = True
+    is_constant = True
+
+    def __init__(self, name: Name = ""):
+        """Construct a Sink operation."""
+        super().__init__(
+            input_count=1,
+            output_count=0,
+            name=name,
+            latency_offsets={"in0": 0},
+        )
+
+    @classmethod
+    def type_name(cls) -> TypeName:
+        return TypeName("sink")
+
+    def evaluate(self):
+        return self.param("value")
+
+    @property
+    def latency(self) -> int:
+        return self.latency_offsets["in0"]
+
+    def __repr__(self) -> str:
+        return "Sink()"
+
+    def __str__(self) -> str:
+        return "sink"

[Oscar Gustafsson]

This will error? Not sure what the correct thing to do is though... Maybe raise a more explicit error? (As I do not think that this will ever be evaluated.)

[Hugo Winbladh]

Right. I suppose just throwing a NotImplementedError would be easiest

[Oscar Gustafsson]

Probably this can be hardcoded to a suitable value (like 0).

[Hugo Winbladh]

The latency is kind of hard-coded to 0 already since the constructor sets the latency_offsets to {'in0': 0}. However the code may be more readable if the latency function explicitly always returns 0.