Made yield infrastructure more transparent by not unpacking single values from the MvS

hybrid_server/classes/mvkcontroller.xml

@@ -59,8 +59,6 @@
                 if commands is None:
                     break
                 reply = [self.mvs_operations[command[0]](*(command[1]))[0] for command in commands]
-                if len(reply) == 1:
-                    reply = reply[0]
             ]]>
         </body>
     </method>

kernel/modelverse_kernel/compiled.py

@@ -1,40 +1,34 @@
 from modelverse_kernel.primitives import PrimitiveFinished
 
 def reverseKeyLookup(a, b, **remainder):
-    edges = yield [("RO", [a])]
+    edges, = yield [("RO", [a])]
     expanded_edges = yield [("RE", [i]) for i in edges]
     for i, edge in enumerate(expanded_edges):
         if b == edge[1]:
             # Found our edge: edges[i]
-            outgoing = yield [("RO", [edges[i]])]
-            result = yield [("RE", [outgoing[0]])]
+            outgoing, = yield [("RO", [edges[i]])]
+            result, = yield [("RE", [outgoing[0]])]
             raise PrimitiveFinished(result[1])
 
-    result = yield [("CNV", ["(unknown: %s)" % b])]
+    result, = yield [("CNV", ["(unknown: %s)" % b])]
     raise PrimitiveFinished(result)
 
 def read_attribute(a, b, c, **remainder):
-    def make_list(v, l):
-        return [v] if l else v
-
     model_dict, b_val, c_val, type_mapping = \
                     yield [("RD", [a, "model"]),
                            ("RV", [b]),
                            ("RV", [c]),
                            ("RD", [a, "type_mapping"]),
                            ]
-    model_instance = \
+    model_instance, = \
                     yield [("RD", [model_dict, b_val])]
-    edges =         yield [("RO", [model_instance])]
+    edges, =        yield [("RO", [model_instance])]
     edge_types =    yield [("RDN", [type_mapping, i]) for i in edges]
-    edge_types = make_list(edge_types, len(edges) == 1)
     type_edge_val = yield [("RE", [i]) for i in edge_types]
-    type_edge_val = make_list(type_edge_val, len(edges) == 1)
 
     src_nodes = set([i[0] for i in type_edge_val])
 
     found_edges =   yield [("RDE", [i, c_val]) for i in src_nodes]
-    found_edges = make_list(found_edges, len(src_nodes) == 1)
 
     for e1 in found_edges:
         if e1 is not None:
@@ -43,36 +37,36 @@ def read_attribute(a, b, c, **remainder):
                 if e1 == e2:
                     # The instance of this edge is the one we want!
                     edge = edges[i]
-                    edge_val = yield [("RE", [edge])]
+                    edge_val, = yield [("RE", [edge])]
                     result = edge_val[1]
                     raise PrimitiveFinished(result)
     else:
-        result = yield [("RR", [])]
+        result, = yield [("RR", [])]
         raise PrimitiveFinished(result)
 
     raise Exception("Error in reading edge!")
 
 def precompute_cardinalities(a, **remainder):
-    result =        yield [("CN", [])]
+    result, =       yield [("CN", [])]
 
     # Read out all edges from the metamodel
-    a =             yield [("RD", [a, "metamodel"])]
-    model_dict =    yield [("RD", [a, "model"])]
-    model_keys =    yield [("RDK", [model_dict])]
-    type_mapping =  yield [("RD", [a, "type_mapping"])]
-    elems =         yield [("RDN", [model_dict, k]) for k in model_keys]
-    model_keys_str= yield [("RV", [i]) for i in model_keys]
-    elem_to_name =  dict(zip(elems, model_keys_str))
-    edges =         yield [("RE", [i]) for i in elems]
+    a, =             yield [("RD", [a, "metamodel"])]
+    model_dict, =    yield [("RD", [a, "model"])]
+    model_keys, =    yield [("RDK", [model_dict])]
+    type_mapping, =  yield [("RD", [a, "type_mapping"])]
+    elems  =         yield [("RDN", [model_dict, k]) for k in model_keys]
+    model_keys_str = yield [("RV", [i]) for i in model_keys]
+    elem_to_name =   dict(zip(elems, model_keys_str))
+    edges =          yield [("RE", [i]) for i in elems]
     elems = [elems[i] for i, edge_val in enumerate(edges) if edge_val is not None]
     # Now we have all edges in the metamodel
 
     # Read out the type of the Association defining all cardinalities
-    metamodel =     yield [("RD", [a, "metamodel"])]
-    metametamodel = yield [("RD", [metamodel, "metamodel"])]
-    metametamodel_dict = \
+    metamodel, =     yield [("RD", [a, "metamodel"])]
+    metametamodel, = yield [("RD", [metamodel, "metamodel"])]
+    metametamodel_dict, = \
                     yield [("RD", [metametamodel, "model"])]
-    assoc =         yield [("RD", [metametamodel_dict, "Association"])]
+    assoc, =         yield [("RD", [metametamodel_dict, "Association"])]
     slc, suc, tlc, tuc = \
                     yield [("RDE", [assoc, "source_lower_cardinality"]),
                            ("RDE", [assoc, "source_upper_cardinality"]),
@@ -98,7 +92,8 @@ def precompute_cardinalities(a, **remainder):
             continue
         
         # Found a link, so add it
-        source, destination = yield [("RE", [elems[i]])]
+        srcdst, = yield [("RE", [elems[i]])]
+        source, destination = srcdst
         # The edge gives the "source" the cardinality found in "destination"
         cardinalities.setdefault(elem_to_name[source], {})[t] = destination
 
@@ -115,21 +110,19 @@ def precompute_cardinalities(a, **remainder):
     raise PrimitiveFinished(result)
 
 def set_copy(a, **remainder):
-    b =         yield [("CN", [])]
-    links =     yield [("RO", [a])]
+    b, =         yield [("CN", [])]
+    links, =     yield [("RO", [a])]
     exp_links = yield [("RE", [i]) for i in links]
-    if len(links) == 1:
-        exp_links = [exp_links]
     _ =         yield [("CE", [b, i[1]]) for i in exp_links]
     raise PrimitiveFinished(b)
 
 def allInstances(a, b, **remainder):
-    b_val =     yield [("RV", [b])]
-    model_dict= yield [("RD", [a, "model"])]
-    metamodel = yield [("RD", [a, "metamodel"])]
-    mm_dict =   yield [("RD", [metamodel, "model"])]
-    typing =    yield [("RD", [a, "type_mapping"])]
-    elem_keys = yield [("RDK", [model_dict])]
+    b_val, =     yield [("RV", [b])]
+    model_dict,= yield [("RD", [a, "model"])]
+    metamodel, = yield [("RD", [a, "metamodel"])]
+    mm_dict, =   yield [("RD", [metamodel, "model"])]
+    typing, =    yield [("RD", [a, "type_mapping"])]
+    elem_keys, = yield [("RDK", [model_dict])]
     elems =     yield [("RDN", [model_dict, i]) for i in elem_keys]
     mms =       yield [("RDN", [typing, i]) for i in elems]
 
@@ -140,14 +133,14 @@ def allInstances(a, b, **remainder):
     # And now we have the inverse mapping: for each type, we have the node containing the name
 
     # Get the inheritance link type
-    inheritance_type =  yield [("RD", [metamodel, "inheritance"])]
+    inheritance_type, =  yield [("RD", [metamodel, "inheritance"])]
 
     # Now we figure out which types are valid for the specified model
     desired_types = set()
-    mm_element =    yield [("RD", [mm_dict, b_val])]
+    mm_element, =    yield [("RD", [mm_dict, b_val])]
     work_list = []
     work_list.append(mm_element)
-    mm_typing =     yield [("RD", [metamodel, "type_mapping"])]
+    mm_typing, =     yield [("RD", [metamodel, "type_mapping"])]
 
     while work_list:
         mm_element = work_list.pop()
@@ -159,11 +152,11 @@ def allInstances(a, b, **remainder):
         desired_types.add(mm_element)
 
         # Follow all inheritance links that COME IN this node, as all these are subtypes and should also match
-        incoming =  yield [("RI", [mm_element])]
+        incoming, =  yield [("RI", [mm_element])]
         for i in incoming:
-            t =     yield [("RDN", [mm_typing, i])]
+            t, =     yield [("RDN", [mm_typing, i])]
             if t == inheritance_type:
-                e = yield [("RE", [i])]
+                e, = yield [("RE", [i])]
                 # Add the source of the inheritance link to the work list
                 work_list.append(e[0])
 
@@ -174,7 +167,7 @@ def allInstances(a, b, **remainder):
         final |= types_to_name_nodes.get(t, set())
 
     # Result is a Python set with nodes, so just make this a Mv set
-    result =    yield [("CN", [])]
+    result, =    yield [("CN", [])]
     v =         yield [("RV", [i]) for i in final]
     _ =    yield [("CE", [result, i]) for i in final]
     raise PrimitiveFinished(result)
@@ -184,15 +177,15 @@ def add_AL(a, b, **remainder):
     added = set()
     type_cache = {}
 
-    model_dict = yield [("RD", [a, "model"])]
-    metamodel = yield [("RD", [a, "metamodel"])]
-    metamodel_dict = yield [("RD", [metamodel, "model"])]
-    type_map = yield [("RD", [a, "type_mapping"])]
-    outgoing = yield [("RO", [model_dict])]
+    model_dict, = yield [("RD", [a, "model"])]
+    metamodel, = yield [("RD", [a, "metamodel"])]
+    metamodel_dict, = yield [("RD", [metamodel, "model"])]
+    type_map, = yield [("RD", [a, "type_mapping"])]
+    outgoing, = yield [("RO", [model_dict])]
     edges = yield [("RE", [i]) for i in outgoing]
     added |= set([i[1] for i in edges])
 
-    result = yield [("CNV", ["__%s" % b])]
+    result, = yield [("CNV", ["__%s" % b])]
 
     # All the action language elements and their expected output links
     type_links = {
@@ -227,7 +220,7 @@ def add_AL(a, b, **remainder):
 
         # Determine type of element
         if expected_type == "":
-            value = yield [("RV", [worknode])]
+            value, = yield [("RV", [worknode])]
             if (isinstance(value, dict)) and ("value" in value):
                 v = value["value"]
                 if v in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]:
@@ -239,14 +232,14 @@ def add_AL(a, b, **remainder):
 
         # Fill the cache
         if expected_type not in type_cache:
-            type_cache[expected_type] = yield [("RD", [metamodel_dict, expected_type])]
+            type_cache[expected_type], = yield [("RD", [metamodel_dict, expected_type])]
 
         # Need to add it now
         yield [("CD", [model_dict, "__%s" % worknode, worknode])]
         added.add(worknode)
         # NOTE can't just use CD here, as the key is a node and not a value
-        t1 = yield [("CE", [type_map, type_cache[expected_type]])]
-        t2 = yield [("CE", [t1, worknode])]
+        t1, = yield [("CE", [type_map, type_cache[expected_type]])]
+        t2, = yield [("CE", [t1, worknode])]
         if t1 is None or t2 is None:
             raise Exception("ERROR")
 
@@ -256,13 +249,13 @@ def add_AL(a, b, **remainder):
             link_name, destination_type = link
 
             # Check if the link actually exists
-            destination = yield [("RD", [worknode, link_name])]
+            destination, = yield [("RD", [worknode, link_name])]
             if destination is not None:
                 # If so, we add it and continue
-                edge = yield [("RDE", [worknode, link_name])]
-                edge_outlinks = yield [("RO", [edge])]
+                edge, = yield [("RDE", [worknode, link_name])]
+                edge_outlinks, = yield [("RO", [edge])]
                 edge_outlink = edge_outlinks[0]
-                edge_name = yield [("RE", [edge_outlink])]
+                edge_name, = yield [("RE", [edge_outlink])]
                 edge_name = edge_name[1]
                 # Now add: edge, edge_outlink, edge_name
 
@@ -271,20 +264,20 @@ def add_AL(a, b, **remainder):
                 added.add(edge)
                 link_type = "%s_%s" % (expected_type, link_name)
                 if link_type not in type_cache:
-                    type_cache[link_type] = yield [("RD", [metamodel_dict, link_type])]
-                t = yield [("CE", [type_map, type_cache[link_type]])]
+                    type_cache[link_type], = yield [("RD", [metamodel_dict, link_type])]
+                t, = yield [("CE", [type_map, type_cache[link_type]])]
                 yield [("CE", [t, edge])]
 
                 # Add 'edge_outlink'
                 yield [("CD", [model_dict, "__%s" % edge_outlink, edge_outlink])]
                 added.add(edge_outlink)
-                t = yield [("CE", [type_map, type_cache["to_str"]])]
+                t, = yield [("CE", [type_map, type_cache["to_str"]])]
                 yield [("CE", [t, edge_outlink])]
 
                 # Add 'edge_name' (if not present)
                 if edge_name not in added:
                     yield [("CD", [model_dict, "__%s" % edge_name, edge_name])]
-                    t = yield [("CE", [type_map, type_cache["String"]])]
+                    t, = yield [("CE", [type_map, type_cache["String"]])]
                     yield [("CE", [t, edge_name])]
                     added.add(edge_name)
 
@@ -294,23 +287,23 @@ def add_AL(a, b, **remainder):
     raise PrimitiveFinished(result)
 
 def get_superclasses(a, b, **remainder):
-    inheritance =   yield [("RD", [a, "inheritance"])]
-    model_dict =    yield [("RD", [a, "model"])]
-    b_v =           yield [("RV", [b])]
-    subclass =      yield [("RD", [model_dict, b_v])]
-    type_mapping =  yield [("RD", [a, "type_mapping"])]
-    names =         yield [("RDK", [model_dict])]
+    inheritance, =   yield [("RD", [a, "inheritance"])]
+    model_dict, =    yield [("RD", [a, "model"])]
+    b_v, =           yield [("RV", [b])]
+    subclass, =      yield [("RD", [model_dict, b_v])]
+    type_mapping, =  yield [("RD", [a, "type_mapping"])]
+    names, =         yield [("RDK", [model_dict])]
     elems =         yield [("RDN", [model_dict, i]) for i in names]
     elem_to_name =  dict(zip(elems, names))
 
-    result =        yield [("CN", [])]
+    result, =        yield [("CN", [])]
     worklist = [subclass]
     while worklist:
         subclass = worklist.pop()
         res = elem_to_name[subclass]
         yield [("CE", [result, res])]
 
-        outgoing =      yield [("RO", [subclass])]
+        outgoing, =      yield [("RO", [subclass])]
         types =         yield [("RDN", [type_mapping, i]) for i in outgoing]
         types = [types] if len(outgoing) == 1 else types
 
@@ -318,24 +311,21 @@ def get_superclasses(a, b, **remainder):
             if t == inheritance:
                 # Found an inheritance link!
                 elem = outgoing[i]
-                src, dst = \
-                        yield [("RE", [elem])]
+                srcdst, = yield [("RE", [elem])]
+                src, dst = srcdst
                 # Find elem in elems
                 worklist.append(dst)
 
     raise PrimitiveFinished(result)
 
 def selectPossibleIncoming(a, b, c, **remainder):
-    model_dict =    yield [("RD", [a, "model"])]
-    limit_set_links = \
+    model_dict, =    yield [("RD", [a, "model"])]
+    limit_set_links, = \
                     yield [("RO", [c])]
     limit_set =     yield [("RE", [i]) for i in limit_set_links]
-    limit_set_names = \
-                    [i[1] for i in limit_set]
-    limit_set_names = [limit_set_names] if len(limit_set) == 1 else limit_set_names
+    limit_set_names = [i[1] for i in limit_set]
     name_values =   yield [("RV", [i]) for i in limit_set_names]
     limit_set =     yield [("RD", [model_dict, i]) for i in name_values]
-    limit_set = [limit_set] if len(limit_set_names) == 1 else limit_set
 
     try:
         gen = get_superclasses(a, b)
@@ -344,56 +334,50 @@ def selectPossibleIncoming(a, b, c, **remainder):
             inp =   yield gen.send(inp)
     except PrimitiveFinished as e:
         superclasses = e.result
-        vals = yield [("RO", [superclasses])]
+        vals, = yield [("RO", [superclasses])]
         superclasses = yield [("RE", [i]) for i in vals]
-        superclasses = [superclasses] if len(vals) == 1 else superclasses
         superclasses = [i[1] for i in superclasses]
 
     superclass_names = yield [("RV", [i]) for i in superclasses]
-    superclass_names = [superclass_names] if len(superclasses) == 1 else superclass_names
     elems =         yield [("RD", [model_dict, i]) for i in superclass_names]
-    elems = [elems] if len(superclasses) == 1 else elems
 
-    result =        yield [("CN", [])]
+    result, =        yield [("CN", [])]
     for i, edge in enumerate(limit_set):
-        src, dst =  yield [("RE", [edge])]
+        srcdst, =  yield [("RE", [edge])]
+        src, dst = srcdst
         if dst in elems:
             yield [("CE", [result, limit_set_names[i]])]
 
     raise PrimitiveFinished(result)
 
 def selectPossibleOutgoing(a, b, c, **remainder):
-    model_dict =    yield [("RD", [a, "model"])]
-    limit_set_links = \
+    model_dict, =    yield [("RD", [a, "model"])]
+    limit_set_links, = \
                     yield [("RO", [c])]
     limit_set =     yield [("RE", [i]) for i in limit_set_links]
     limit_set_names = \
                     [i[1] for i in limit_set]
-    limit_set_names = [limit_set_names] if len(limit_set) == 1 else limit_set_names
     name_values =   yield [("RV", [i]) for i in limit_set_names]
     limit_set =     yield [("RD", [model_dict, i]) for i in name_values]
-    limit_set = [limit_set] if len(limit_set_names) == 1 else limit_set
 
     try:
         gen = get_superclasses(a, b)
         inp = None
         while 1:
-            inp =   yield gen.send(inp)
+            inp =  yield gen.send(inp)
     except PrimitiveFinished as e:
         superclasses = e.result
-        vals = yield [("RO", [superclasses])]
+        vals, = yield [("RO", [superclasses])]
         superclasses = yield [("RE", [i]) for i in vals]
-        superclasses = [superclasses] if len(vals) == 1 else superclasses
         superclasses = [i[1] for i in superclasses]
 
     superclass_names = yield [("RV", [i]) for i in superclasses]
-    superclass_names = [superclass_names] if len(superclasses) == 1 else superclass_names
     elems =         yield [("RD", [model_dict, i]) for i in superclass_names]
-    elems = [elems] if len(superclasses) == 1 else elems
 
-    result =        yield [("CN", [])]
+    result, =        yield [("CN", [])]
     for i, edge in enumerate(limit_set):
-        src, dst =  yield [("RE", [edge])]
+        srcdst =  yield [("RE", [edge])]
+        src, dst = srcdst
         if src in elems:
             yield [("CE", [result, limit_set_names[i]])]
 
@@ -401,28 +385,20 @@ def selectPossibleOutgoing(a, b, c, **remainder):
 
 def check_symbols(a, b, c, **remainder):
     symbols = {}
-    function_name = yield [("RV", [b])]
+    function_name, = yield [("RV", [b])]
     symbols[function_name] = False
-    object_links = yield [("RO", [c])]
+    object_links, = yield [("RO", [c])]
     set_elements = yield [("RE", [i]) for i in object_links]
-    set_elements = [set_elements] if len(object_links) == 1 else set_elements
     set_elements = [i[1] for i in set_elements]
     set_values = yield [("RV", [i]) for i in set_elements]
-    set_values = [set_values] if len(set_elements) == 1 else set_values
     set_elements = yield [("RD", [a, i]) for i in set_values]
-    set_elements = [set_elements] if len(set_values) == 1 else set_elements
     symbols_set = yield [("RD", [i, "symbols"]) for i in set_elements]
-    symbols_set = [symbols_set] if len(set_elements) == 1 else symbols_set
     all_keys = yield [("RDK", [i]) for i in symbols_set]
-    all_keys = [all_keys] if len(symbols_set) == 1 else all_keys
     for i, s in zip(all_keys, symbols_set):
         # For each object we have found
         keys = yield [("RV", [j]) for j in i]
-        keys = [keys] if len(i) == 1 else keys
         values = yield [("RD", [s, j]) for j in keys]
-        values = [values] if len(keys) == 1 else values
         values = yield [("RV", [j]) for j in values]
-        values = [values] if len(keys) == 1 else values
         for key, value in zip(keys, values):
             k = key
             v = value
@@ -438,8 +414,8 @@ def check_symbols(a, b, c, **remainder):
         if i == "input" or i == "output":
             continue
         if not j:
-            result = yield [("CNV", ["ERROR: undefined symbol " + str(i)])]
+            result, = yield [("CNV", ["ERROR: undefined symbol " + str(i)])]
             raise PrimitiveFinished(result)
 
-    result = yield [("CNV", ["OK"])]
+    result, = yield [("CNV", ["OK"])]
     raise PrimitiveFinished(result)

kernel/modelverse_kernel/main.py

@@ -42,8 +42,8 @@ class ModelverseKernel(object):
             raise
 
     def execute_rule(self, username):
-        user_root =     yield [("RD", [self.root, username])]
-        user_frame =    yield [("RD", [user_root, "frame"])]
+        user_root, =    yield [("RD", [self.root, username])]
+        user_frame, =   yield [("RD", [user_root, "frame"])]
         inst, phase =   yield [("RD", [user_frame, "IP"]),
                                ("RD", [user_frame, "phase"]),
                               ]
@@ -53,7 +53,7 @@ class ModelverseKernel(object):
                                ("RV", [inst]),
                               ]
         if self.new_debug is not None:
-            self.debug_info = yield [("RV", [self.new_debug])]
+            self.debug_info, = yield [("RV", [self.new_debug])]
 
         if phase_v == "finish":
             gen = self.helper_init(user_root)
@@ -77,7 +77,6 @@ class ModelverseKernel(object):
         try:
             inp = None
             while 1:
-                # Without checking:
                 inp = yield gen.send(inp)
         except StopIteration:
             pass
@@ -86,39 +85,28 @@ class ModelverseKernel(object):
     ### Process primitives ###
     ##########################
     def load_primitives(self, username):
-        hierarchy =     yield [("RD", [self.root, "__hierarchy"])]
-        primitives =    yield [("RD", [hierarchy, "primitives"])]
-        keys =          yield [("RDK", [primitives])]
-        function_names =yield [("RV", [f]) for f in keys]
-        signatures =    yield [("RDN", [primitives, f]) for f in keys]
-        bodies =        yield [("RD", [f, "body"]) for f in signatures]
+        hierarchy, =     yield [("RD", [self.root, "__hierarchy"])]
+        primitives, =    yield [("RD", [hierarchy, "primitives"])]
+        keys, =          yield [("RDK", [primitives])]
+        function_names = yield [("RV", [f]) for f in keys]
+        signatures  =    yield [("RDN", [primitives, f]) for f in keys]
+        bodies =         yield [("RD", [f, "body"]) for f in signatures]
         for i in range(len(keys)):
             self.primitives[bodies[i]] = getattr(primitive_functions, function_names[i])
         self.compiled.update(self.primitives)
 
     def execute_primitive(self, user_root, inst, username):
         # execute_primitive
-        user_frame =    yield [("RD", [user_root, "frame"])]
-        symbols =       yield [("RD", [user_frame, "symbols"])]
-        all_links =     yield [("RO", [symbols])]
-        if len(all_links) == 1:
-            # Single parameter, so avoid all list comprehensions
-            all_links = all_links[0]
-            containers =    yield [("RE", [all_links])]
-            outgoings =     yield [("RO", [all_links])]
-            dict_values =   yield [("RD", [containers[1], "value"])]
-            formals_1 =     yield [("RE", [outgoings[0]])]
-            dict_keys_ref = yield [("RD", [formals_1[1], "name"])]
-            dict_keys =     yield [("RV", [dict_keys_ref])]
-            parameters = {dict_keys: dict_values}
-        else:
-            containers =    yield [("RE", [v]) for v in all_links]
-            outgoings =     yield [("RO", [v]) for v in all_links]
-            dict_values =   yield [("RD", [v[1], "value"]) for v in containers]
-            formals_1 =     yield [("RE", [v[0]]) for v in outgoings]
-            dict_keys_ref = yield [("RD", [v[1], "name"]) for v in formals_1]
-            dict_keys =     yield [("RV", [v]) for v in dict_keys_ref]
-            parameters = dict(zip(dict_keys, dict_values))
+        user_frame, =    yield [("RD", [user_root, "frame"])]
+        symbols, =       yield [("RD", [user_frame, "symbols"])]
+        all_links, =     yield [("RO", [symbols])]
+        containers =    yield [("RE", [v]) for v in all_links]
+        outgoings =     yield [("RO", [v]) for v in all_links]
+        dict_values =   yield [("RD", [v[1], "value"]) for v in containers]
+        formals_1 =     yield [("RE", [v[0]]) for v in outgoings]
+        dict_keys_ref = yield [("RD", [v[1], "name"]) for v in formals_1]
+        dict_keys =     yield [("RV", [v]) for v in dict_keys_ref]
+        parameters = dict(zip(dict_keys, dict_values))
 
         parameters["root"] = self.root
         parameters["user_root"] = user_root
@@ -143,8 +131,8 @@ class ModelverseKernel(object):
             #    raise Exception("Primitive raised exception: value of None for operation %s with parameters %s" % (self.compiled[inst], str(parameters)))
 
         # Clean up the current stack, as if a return happened
-        old_frame =     yield [("RD", [user_frame, "prev"])]
-        lnk =           yield [("RDE", [old_frame, "returnvalue"])]
+        old_frame, =    yield [("RD", [user_frame, "prev"])]
+        lnk, =          yield [("RDE", [old_frame, "returnvalue"])]
         _, _, _, _ =    yield [("CD", [old_frame, "returnvalue", result]),
                                ("CD", [user_root, "frame", old_frame]),
                                ("DE", [lnk]),
@@ -155,8 +143,8 @@ class ModelverseKernel(object):
     ### Execute input and output methods ###
     ########################################
     def get_output(self, username):
-        user_root =         yield [("RD", [self.root, username])]
-        first_output =      yield [("RD", [user_root, "output"])]
+        user_root, =        yield [("RD", [self.root, username])]
+        first_output, =     yield [("RD", [user_root, "output"])]
         next_output, rv =   yield [("RD", [first_output, "next"]),
                                    ("RD", [first_output, "value"]),
                                   ]
@@ -164,18 +152,18 @@ class ModelverseKernel(object):
             self.success = False
             self.returnvalue = {"id": None, "value": ""}
         else:
-            rv_value =      yield [("RV", [rv])]
+            rv_value, =     yield [("RV", [rv])]
             _, _ =          yield [("CD", [user_root, "output", next_output]),
                                    ("DN", [first_output]),
                                   ]
             self.returnvalue = {"id": rv, "value": rv_value}
 
     def set_input(self, username, element_type, value):
-        user_root =         yield [("RD", [self.root, username])]
+        user_root, =        yield [("RD", [self.root, username])]
         old_input, link =   yield [("RD", [user_root, "last_input"]),
                                    ("RDE", [user_root, "last_input"]),
                                   ]
-        new_input =         yield [("CN", [])]
+        new_input, =        yield [("CN", [])]
         _, _ =              yield [("CD", [user_root, "last_input", new_input]),
                                    ("CD", [old_input, "next", new_input]),
                                   ]
@@ -183,7 +171,7 @@ class ModelverseKernel(object):
         if element_type == "R":
             new_value = int(value)
         elif element_type == "V":
-            new_value =     yield [("CNV", [value])]
+            new_value, =    yield [("CNV", [value])]
         _, _ =              yield [("CD", [old_input, "value", new_value]),
                                    ("DE", [link])
                                   ]
@@ -193,12 +181,12 @@ class ModelverseKernel(object):
     ### Transformation rules for instructions ###
     #############################################
     def break_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         phase_link, ip_link = \
                             yield [("RDE", [user_frame, "phase"]),
                                    ("RDE", [user_frame, "IP"])
                                   ]
-        inst =              yield [("RD", [user_frame, "IP"])]
+        inst, =             yield [("RD", [user_frame, "IP"])]
         while_inst, new_phase = \
                             yield [("RD", [inst, "while"]),
                                    ("CNV", ["finish"]),
@@ -210,17 +198,17 @@ class ModelverseKernel(object):
                                   ]
 
     def continue_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         ip_link, inst =     yield [("RDE", [user_frame, "IP"]),
                                    ("RD", [user_frame, "IP"]),
                                   ]
-        while_inst =        yield [("RD", [inst, "while"])]
+        while_inst, =       yield [("RD", [inst, "while"])]
         _, _ =              yield [("CD", [user_frame, "IP", while_inst]),
                                    ("DE", [ip_link]),
                                   ]
 
     def if_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         evalstack, evalstack_link = \
                             yield [("RD", [user_frame, "evalstack"]),
                                    ("RDE", [user_frame, "evalstack"]),
@@ -228,7 +216,7 @@ class ModelverseKernel(object):
         inst, ip_link =     yield [("RD", [user_frame, "IP"]),
                                    ("RDE", [user_frame, "IP"]),
                                   ]
-        cond =              yield [("RD", [inst, "cond"])]
+        cond, =             yield [("RD", [inst, "cond"])]
         new_evalstack, new_phase = \
                             yield [("CN", []),
                                    ("CNV", ["cond"]),
@@ -244,12 +232,12 @@ class ModelverseKernel(object):
                                   ]
 
     def if_cond(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         returnvalue, inst = yield [("RD", [user_frame, "returnvalue"]),
                                    ("RD", [user_frame, "IP"]),
                                   ]
-        returnvalue_v =     yield [("RV", [returnvalue])]
-        _else =             yield [("RD", [inst, "else"])]
+        returnvalue_v, =    yield [("RV", [returnvalue])]
+        _else, =            yield [("RD", [inst, "else"])]
 
         if returnvalue_v:
             phase_link, evalstack, evalstack_link, ip_link, _then, new_evalstack, evalstack_phase, new_phase = \
@@ -306,7 +294,7 @@ class ModelverseKernel(object):
                                   ]
 
     def while_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         evalstack, evalstack_link, ip_link, inst = \
                             yield [("RD", [user_frame, "evalstack"]),
                                    ("RDE", [user_frame, "evalstack"]),
@@ -329,9 +317,9 @@ class ModelverseKernel(object):
                                   ]
 
     def while_cond(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
-        returnvalue =       yield [("RD", [user_frame, "returnvalue"])]
-        returnvalue_v =     yield [("RV", [returnvalue])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
+        returnvalue, =      yield [("RD", [user_frame, "returnvalue"])]
+        returnvalue_v, =    yield [("RV", [returnvalue])]
 
         if returnvalue_v:
             phase_link, evalstack, evalstack_link, ip_link, inst = \
@@ -341,7 +329,7 @@ class ModelverseKernel(object):
                                    ("RDE", [user_frame, "IP"]),
                                    ("RD", [user_frame, "IP"]),
                                   ]
-            body =          yield [("RD", [inst, "body"])]
+            body, =         yield [("RD", [inst, "body"])]
             new_evalstack, new_phase, evalstack_phase = \
                             yield [("CN", []),
                                    ("CNV", ["init"]),
@@ -368,7 +356,7 @@ class ModelverseKernel(object):
                                   ]
 
     def access_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         evalstack, evalstack_link, inst, ip_link = \
                             yield [("RD", [user_frame, "evalstack"]),
                                    ("RDE", [user_frame, "evalstack"]),
@@ -391,7 +379,7 @@ class ModelverseKernel(object):
                                   ]
 
     def access_eval(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         phase_link, returnvalue_link, returnvalue = \
                             yield [("RDE", [user_frame, "phase"]),
                                    ("RDE", [user_frame, "returnvalue"]),
@@ -407,7 +395,7 @@ class ModelverseKernel(object):
                                   ]
 
     def resolve_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         symbols, evalstack, evalstack_link, ip_link, inst = \
                             yield [("RD", [user_frame, "symbols"]),
                                    ("RD", [user_frame, "evalstack"]),
@@ -415,8 +403,8 @@ class ModelverseKernel(object):
                                    ("RDE", [user_frame, "IP"]),
                                    ("RD", [user_frame, "IP"]),
                                   ]
-        var =               yield [("RD", [inst, "var"])]
-        variable =          yield [("RDN", [symbols, var])]
+        var, =              yield [("RD", [inst, "var"])]
+        variable, =         yield [("RDN", [symbols, var])]
 
         if variable is None:
             phase_link, returnvalue_link, _globals, var_name = \
@@ -441,8 +429,8 @@ class ModelverseKernel(object):
                     # We have a compiled function ready!
                     # Now we have to bind the ID to the compiled functions
                     # For this, we read out the body of the resolved data
-                    compiler_val = yield [("RD", [variable, "value"])]
-                    compiler_body = yield [("RD", [compiler_val, "body"])]
+                    compiler_val, =  yield [("RD", [variable, "value"])]
+                    compiler_body, = yield [("RD", [compiler_val, "body"])]
                     self.compiled[compiler_body] = compiled_function
 
         else:
@@ -459,7 +447,7 @@ class ModelverseKernel(object):
                                   ]
 
     def assign_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         evalstack, evalstack_link, ip_link, inst = \
                             yield [("RD", [user_frame, "evalstack"]),
                                    ("RDE", [user_frame, "evalstack"]),
@@ -482,7 +470,7 @@ class ModelverseKernel(object):
                                   ]
 
     def assign_value(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         phase_link, evalstack, returnvalue, evalstack_link, ip_link, inst = \
                             yield [("RDE", [user_frame, "phase"]),
                                    ("RD", [user_frame, "evalstack"]),
@@ -512,7 +500,7 @@ class ModelverseKernel(object):
                                   ]
 
     def assign_assign(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         phase_link, returnvalue, variable_link, variable = \
                             yield [("RDE", [user_frame, "phase"]),
                                    ("RD", [user_frame, "returnvalue"]),
@@ -531,12 +519,12 @@ class ModelverseKernel(object):
                                   ]
                     
     def return_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
-        inst =              yield [("RD", [user_frame, "IP"])]
-        value =             yield [("RD", [inst, "value"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
+        inst, =             yield [("RD", [user_frame, "IP"])]
+        value, =            yield [("RD", [inst, "value"])]
 
         if value is None:
-            prev_frame =    yield [("RD", [user_frame, "prev"])]
+            prev_frame, =   yield [("RD", [user_frame, "prev"])]
             _, _ =          yield [("CD", [user_root, "frame", prev_frame]),
                                    ("DN", [user_frame]),
                                   ]
@@ -559,8 +547,8 @@ class ModelverseKernel(object):
                                   ]
 
     def return_eval(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
-        prev_frame =        yield [("RD", [user_frame, "prev"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
+        prev_frame, =       yield [("RD", [user_frame, "prev"])]
         returnvalue, old_returnvalue_link = \
                             yield [("RD", [user_frame, "returnvalue"]),
                                    ("RDE", [prev_frame, "returnvalue"]),
@@ -572,7 +560,7 @@ class ModelverseKernel(object):
                                   ]
 
     def constant_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         phase_link, returnvalue_link, inst = \
                             yield [("RDE", [user_frame, "phase"]),
                                    ("RDE", [user_frame, "returnvalue"]),
@@ -588,9 +576,9 @@ class ModelverseKernel(object):
                                   ]
 
     def helper_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
-        inst =              yield [("RD", [user_frame, "IP"])]
-        next =              yield [("RD", [inst, "next"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
+        inst, =             yield [("RD", [user_frame, "IP"])]
+        next, =             yield [("RD", [inst, "next"])]
 
         if next is None:
             ip_link, phase_link, evalstack_top = \
@@ -598,7 +586,7 @@ class ModelverseKernel(object):
                                    ("RDE", [user_frame, "phase"]),
                                    ("RD", [user_frame, "evalstack"]),
                                   ]
-            evalstack =     yield [("RD", [evalstack_top, "prev"])]
+            evalstack, =    yield [("RD", [evalstack_top, "prev"])]
             evalstack_inst, evalstack_phase, evalstack_inst_link, evalstack_phase_link = \
                             yield [("RD", [evalstack, "inst"]),
                                    ("RD", [evalstack, "phase"]),
@@ -628,7 +616,7 @@ class ModelverseKernel(object):
                                   ]
 
     def call_init(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         symbols, evalstack, evalstack_link, ip_link, inst = \
                             yield [("RD", [user_frame, "symbols"]),
                                    ("RD", [user_frame, "evalstack"]),
@@ -655,7 +643,7 @@ class ModelverseKernel(object):
                                    ("DE", [ip_link]),
                                   ]
         else:
-            new_evalstack = yield [("CN", [])]
+            new_evalstack,= yield [("CN", [])]
             _, _, _, _, _, _, _ = \
                             yield [("CD", [user_frame, "evalstack", new_evalstack]),
                                    ("CD", [new_evalstack, "prev", evalstack]),
@@ -667,12 +655,12 @@ class ModelverseKernel(object):
                                   ]
 
     def call_call(self, user_root):
-        user_frame =        yield [("RD", [user_root, "frame"])]
-        inst =              yield [("RD", [user_frame, "IP"])]
-        param =             yield [("RD", [inst, "last_param"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
+        inst, =             yield [("RD", [user_frame, "IP"])]
+        param, =            yield [("RD", [inst, "last_param"])]
 
         if param is None:
-            returnvalue =   yield [("RD", [user_frame, "returnvalue"])]
+            returnvalue, =  yield [("RD", [user_frame, "returnvalue"])]
             body, phase_link, frame_link, prev_phase, new_phase, new_frame, new_evalstack, new_symbols, new_returnvalue = \
                             yield [("RD", [returnvalue, "body"]),
                                    ("RDE", [user_frame, "phase"]),
@@ -709,14 +697,14 @@ class ModelverseKernel(object):
                                    ("RD", [new_frame, "symbols"]),
                                    ("RD", [new_frame, "IP"]),
                                   ]
-            signature =     yield [("RRD", [new_IP, "body"])]
+            signature, =    yield [("RRD", [new_IP, "body"])]
             signature = signature[0]
             sig_params, last_param = \
                             yield [("RD", [signature, "params"]),
                                    ("RD", [inst, "last_param"]),
                                   ]
-            name =          yield [("RD", [last_param, "name"])]
-            name_value =    yield [("RV", [name])]
+            name, =         yield [("RD", [last_param, "name"])]
+            name_value, =   yield [("RV", [name])]
             returnvalue, formal_parameter, new_phase, variable = \
                             yield [("RD", [user_frame, "returnvalue"]),
                                    ("RD", [sig_params, name_value]),
@@ -745,8 +733,7 @@ class ModelverseKernel(object):
             raise Exception("%s: error: could not find any overlap" % self.debug_info)
 
     def call_param(self, user_root):
-        #TODO this code is likely very buggy!
-        user_frame =        yield [("RD", [user_root, "frame"])]
+        user_frame, =       yield [("RD", [user_root, "frame"])]
         inst, phase =       yield [("RD", [user_frame, "IP"]),
                                    ("RD", [user_frame, "phase"]),
                                   ]
@@ -754,7 +741,7 @@ class ModelverseKernel(object):
                             yield [("RD", [inst, "params"]),
                                    ("RD", [inst, "last_param"]),
                                   ]
-        next_param =        yield [("RD", [params, "next_param"])]
+        next_param, =       yield [("RD", [params, "next_param"])]
 
         if params == phase:
             phase_link, ip_link, returnvalue, param_value, evalstack, evalstack_link = \
@@ -765,7 +752,7 @@ class ModelverseKernel(object):
                                    ("RD", [user_frame, "evalstack"]),
                                    ("RDE", [user_frame, "evalstack"]),
                                   ]
-            body =          yield [("RD", [returnvalue, "body"])]
+            body, =         yield [("RD", [returnvalue, "body"])]
             new_frame, prev_evalstack, new_phase, prev_phase, new_evalstack, new_symbols, new_returnvalue = \
                             yield [("CN", []),
                                    ("CN", []),
@@ -795,7 +782,7 @@ class ModelverseKernel(object):
             if next_param is not None:
                 _ =         yield [("CD", [evalstack, "phase", next_param])]
             else:
-                evalstack_phase = \
+                evalstack_phase, = \
                             yield [("CNV", ["call"])]
                 _ =         yield [("CD", [evalstack, "phase", evalstack_phase])]
         else:
@@ -813,18 +800,18 @@ class ModelverseKernel(object):
                                    ("RD", [new_frame, "symbols"]),
                                    ("RD", [new_frame, "IP"]),
                                   ]
-            signature =     yield [("RRD", [new_IP, "body"])]
+            signature, =    yield [("RRD", [new_IP, "body"])]
             signature = signature[0]
-            sig_params =    yield [("RD", [signature, "params"])]
+            sig_params, =   yield [("RD", [signature, "params"])]
 
             if last_param == phase:
-                prev_param = \
+                prev_param, = \
                             yield [("RRD", [last_param, "next_param"])]
                 prev_param = prev_param[0]
-                name =      yield [("RD", [prev_param, "name"])]
-                name_value = \
+                name, =     yield [("RD", [prev_param, "name"])]
+                name_value, = \
                             yield [("RV", [name])]
-                evalstack_phase = \
+                evalstack_phase, = \
                             yield [("CNV", ["call"])]
                 _ =         yield [("CD", [evalstack, "phase", evalstack_phase])]
                 formal_parameter, param_value = \
@@ -832,7 +819,7 @@ class ModelverseKernel(object):
                                    ("RD", [last_param, "value"]),
                                   ]
             else:
-                param_b =   yield [("RD", [user_frame, "phase"])]
+                param_b, =  yield [("RD", [user_frame, "phase"])]
                 param_c, param_a = \
                             yield [("RD", [param_b, "next_param"]),
                                    ("RRD", [param_b, "next_param"]),
@@ -842,7 +829,7 @@ class ModelverseKernel(object):
                             yield [("RD", [param_a, "name"]),
                                    ("RD", [param_b, "value"]),
                                   ]
-                name_value = \
+                name_value, = \
                             yield [("RV", [name])]
                 formal_parameter, _ = \
                             yield [("RD", [sig_params, name_value]),
@@ -864,7 +851,7 @@ class ModelverseKernel(object):
                                ("CD", [variable, "value", returnvalue]),
                               ]
 
-            t1 =        yield [("CE", [new_symbols, variable])]
+            t1, =       yield [("CE", [new_symbols, variable])]
             _, _, _, _ = \
                         yield [("CE", [t1, formal_parameter]),
                                ("DE", [phase_link]),
@@ -873,7 +860,7 @@ class ModelverseKernel(object):
                               ]
 
     def input_init(self, user_root):
-        user_frame =    yield [("RD", [user_root, "frame"])]
+        user_frame, =   yield [("RD", [user_root, "frame"])]
         returnvalue_link, _input = \
                         yield [("RDE", [user_frame, "returnvalue"]),
                                ("RD", [user_root, "input"]),
@@ -901,7 +888,7 @@ class ModelverseKernel(object):
             self.success = False
 
     def output_init(self, user_root):
-        user_frame =    yield [("RD", [user_root, "frame"])]
+        user_frame, =   yield [("RD", [user_root, "frame"])]
         evalstack, evalstack_link, ip_link, inst = \
                         yield [("RD", [user_frame, "evalstack"]),
                                ("RDE", [user_frame, "evalstack"]),
@@ -924,7 +911,7 @@ class ModelverseKernel(object):
                               ]
 
     def output_output(self, user_root):
-        user_frame =    yield [("RD", [user_root, "frame"])]
+        user_frame, =   yield [("RD", [user_root, "frame"])]
         returnvalue_link, returnvalue, last_output, phase_link, last_output_link, new_last_output, finish = \
                         yield [("RDE", [user_frame, "returnvalue"]),
                                ("RD", [user_frame, "returnvalue"]),
@@ -944,8 +931,8 @@ class ModelverseKernel(object):
                               ]
 
     def declare_init(self, user_root):
-        user_frame =    yield [("RD", [user_root, "frame"])]
-        inst =          yield [("RD", [user_frame, "IP"])]
+        user_frame, =   yield [("RD", [user_root, "frame"])]
+        inst, =         yield [("RD", [user_frame, "IP"])]
         new_var, symbols, phase_link, empty_node, new_phase = \
                         yield [("RD", [inst, "var"]),
                                ("RD", [user_frame, "symbols"]),
@@ -954,18 +941,18 @@ class ModelverseKernel(object):
                                ("CNV", ["finish"]),
                               ]
 
-        exists = yield [("RDN", [symbols, new_var])]
+        exists, =       yield [("RDN", [symbols, new_var])]
         if exists is None:
-            new_edge =      yield [("CE", [symbols, empty_node])]
-            _ =             yield [("CE", [new_edge, new_var])]
+            new_edge, = yield [("CE", [symbols, empty_node])]
+            _ =         yield [("CE", [new_edge, new_var])]
 
-        _, _ =       yield [   ("CD", [user_frame, "phase", new_phase]),
+        _, _ =          yield [("CD", [user_frame, "phase", new_phase]),
                                ("DE", [phase_link]),
                               ]
 
     def global_init(self, user_root):
-        user_frame =    yield [("RD", [user_root, "frame"])]
-        inst =          yield [("RD", [user_frame, "IP"])]
+        user_frame, =   yield [("RD", [user_root, "frame"])]
+        inst, =         yield [("RD", [user_frame, "IP"])]
         new_var, global_symbols, phase_link, empty_node, new_phase = \
                         yield [("RD", [inst, "var"]),
                                ("RD", [user_root, "globals"]),
@@ -974,8 +961,8 @@ class ModelverseKernel(object):
                                ("CNV", ["finish"]),
                               ]
 
-        value = yield [("RV", [new_var])]
-        exists = yield [("RD", [global_symbols, value])]
+        value, =        yield [("RV", [new_var])]
+        exists, =       yield [("RD", [global_symbols, value])]
 
         if exists is None:
             yield [("CD", [global_symbols, value, empty_node])]

kernel/modelverse_kernel/primitives.py

@@ -5,92 +5,92 @@ class PrimitiveFinished(Exception):
     
 def integer_subtraction(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value - b_value])]
+    result, = yield [("CNV", [a_value - b_value])]
     raise PrimitiveFinished(result)
 
 def integer_addition(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value + b_value])]
+    result, = yield [("CNV", [a_value + b_value])]
     raise PrimitiveFinished(result)
 
 def integer_multiplication(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value * b_value])]
+    result, = yield [("CNV", [a_value * b_value])]
     raise PrimitiveFinished(result)
 
 def integer_division(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [int(a_value) / b_value])]
+    result, = yield [("CNV", [int(a_value) / b_value])]
     raise PrimitiveFinished(result)
 
 def integer_gt(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value > b_value])]
+    result, = yield [("CNV", [a_value > b_value])]
     raise PrimitiveFinished(result)
 
 def integer_lt(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value < b_value])]
+    result, = yield [("CNV", [a_value < b_value])]
     raise PrimitiveFinished(result)
 
 def integer_neg(a, **remainder):
-    a_value =           yield [("RV", [a])]
-    result = yield [("CNV", [-a_value])]
+    a_value, =          yield [("RV", [a])]
+    result, = yield [("CNV", [-a_value])]
     raise PrimitiveFinished(result)
 
 def bool_and(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value and b_value])]
+    result, = yield [("CNV", [a_value and b_value])]
     raise PrimitiveFinished(result)
 
 def bool_or(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value or b_value])]
+    result, = yield [("CNV", [a_value or b_value])]
     raise PrimitiveFinished(result)
 
 def bool_not(a, **remainder):
-    a_value =           yield [("RV", [a])]
-    result = yield [("CNV", [not a_value])]
+    a_value, =          yield [("RV", [a])]
+    result, = yield [("CNV", [not a_value])]
     raise PrimitiveFinished(result)
 
 def float_subtraction(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value - b_value])]
+    result, = yield [("CNV", [a_value - b_value])]
     raise PrimitiveFinished(result)
 
 def float_addition(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value + b_value])]
+    result, = yield [("CNV", [a_value + b_value])]
     raise PrimitiveFinished(result)
 
 def float_multiplication(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value * b_value])]
+    result, = yield [("CNV", [a_value * b_value])]
     raise PrimitiveFinished(result)
 
 def float_division(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value / b_value])]
+    result, = yield [("CNV", [a_value / b_value])]
     raise PrimitiveFinished(result)
 
 def float_gt(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value > b_value])]
+    result, = yield [("CNV", [a_value > b_value])]
     raise PrimitiveFinished(result)
 
 def float_lt(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value < b_value])]
+    result, = yield [("CNV", [a_value < b_value])]
     raise PrimitiveFinished(result)
 
 def float_neg(a, **remainder):
-    a_value =           yield [("RV", [a])]
-    result = yield [("CNV", [-a_value])]
+    a_value, =          yield [("RV", [a])]
+    result, = yield [("CNV", [-a_value])]
     raise PrimitiveFinished(result)
 
 def string_join(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [str(a_value) + str(b_value)])]
+    result, = yield [("CNV", [str(a_value) + str(b_value)])]
     raise PrimitiveFinished(result)
 
 def string_split(a, b, **remainder):
@@ -103,119 +103,119 @@ def string_split(a, b, **remainder):
 
 def string_get(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value[b_value]])]
+    result, = yield [("CNV", [a_value[b_value]])]
     raise PrimitiveFinished(result)
 
 def string_len(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [len(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [len(a_value)])]
     raise PrimitiveFinished(result)
 
 def value_eq(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value == b_value])]
+    result, = yield [("CNV", [a_value == b_value])]
     raise PrimitiveFinished(result)
 
 def value_neq(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result = yield [("CNV", [a_value != b_value])]
+    result, = yield [("CNV", [a_value != b_value])]
     raise PrimitiveFinished(result)
 
 def element_eq(a, b, **remainder):
-    result = yield [("CNV", [a == b])]
+    result, = yield [("CNV", [a == b])]
     raise PrimitiveFinished(result)
 
 def element_neq(a, b, **remainder):
-    result = yield [("CNV", [a != b])]
+    result, = yield [("CNV", [a != b])]
     raise PrimitiveFinished(result)
 
 def cast_a2s(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [str(a_value["value"])])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [str(a_value["value"])])]
     raise PrimitiveFinished(result)
 
 def cast_i2f(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [float(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [float(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_i2s(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [str(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [str(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_i2b(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [bool(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [bool(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_f2i(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [int(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [int(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_f2s(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [str(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [str(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_f2b(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [bool(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [bool(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_s2i(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [int(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [int(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_s2f(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [float(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [float(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_s2b(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [bool(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [bool(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_b2i(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [int(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [int(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_b2f(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [float(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [float(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_b2s(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [str(a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [str(a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_e2s(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", ["{ID: %s, value: %s}" % (a, a_value)])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", ["{ID: %s, value: %s}" % (a, a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_v2s(a, **remainder):
-    a_value = yield [("RV", [a])]
+    a_value, = yield [("RV", [a])]
     if isinstance(a_value, (str, unicode)):
         # String should be encoded to distinguish between 3 and "3"
         a_value = '"%s"' % a_value
     elif isinstance(a_value, dict):
         # Action or type
         a_value = a_value["value"]
-    result = yield [("CNV", ["%s" % (a_value)])]
+    result, = yield [("CNV", ["%s" % (a_value)])]
     raise PrimitiveFinished(result)
 
 def cast_id2s(a, **remainder):
-    result = yield [("CNV", ["%s" % (a)])]
+    result, = yield [("CNV", ["%s" % (a)])]
     raise PrimitiveFinished(result)
 
 def list_append(a, b, **remainder):
-    a_outgoing = yield [("RO", [a])]
+    a_outgoing, = yield [("RO", [a])]
     _ = yield [("CD", [a, len(a_outgoing), b])]
     raise PrimitiveFinished(a)
 
@@ -241,60 +241,60 @@ def list_delete(a, b, **remainder):
     raise PrimitiveFinished(a)
 
 def list_read(a, b, **remainder):
-    b_value = yield [("RV", [b])]
-    result = yield [("RD", [a, b_value])]
+    b_value, = yield [("RV", [b])]
+    result, = yield [("RD", [a, b_value])]
     if result is None:
         raise Exception("List read out of bounds: %s" % b_value)
     raise PrimitiveFinished(result)
 
 def list_len(a, **remainder):
-    outgoings = yield [("RO", [a])]
-    result = yield [("CNV", [len(outgoings)])]
+    outgoings, = yield [("RO", [a])]
+    result, = yield [("CNV", [len(outgoings)])]
     raise PrimitiveFinished(result)
 
 def dict_add(a, b, c, **remainder):
-    new_edge = yield [("CE", [a, c])]
+    new_edge, = yield [("CE", [a, c])]
     yield [("CE", [new_edge, b])]
     raise PrimitiveFinished(a)
 
 def dict_delete(a, b, **remainder):
-    edge = yield [("RDNE", [a, b])]
+    edge, = yield [("RDNE", [a, b])]
     if edge is None:
         # This exact node isn't in this dictionary, so delete everything matching the value instead
-        b_value = yield [("RV", [b])]
-        edge = yield [("RDE", [a, b_value])]
+        b_value, = yield [("RV", [b])]
+        edge, = yield [("RDE", [a, b_value])]
     yield [("DE", [edge])]
     raise PrimitiveFinished(a)
 
 def dict_read(a, b, **remainder):
-    b_value = yield [("RV", [b])]
-    result = yield [("RD", [a, b_value])]
+    b_value, = yield [("RV", [b])]
+    result, = yield [("RD", [a, b_value])]
     raise PrimitiveFinished(result)
 
 def dict_read_edge(a, b, **remainder):
-    b_value = yield [("RV", [b])]
-    result = yield [("RDE", [a, b_value])]
+    b_value, = yield [("RV", [b])]
+    result, = yield [("RDE", [a, b_value])]
     raise PrimitiveFinished(result)
 
 def dict_read_node(a, b, **remainder):
-    result = yield [("RDN", [a, b])]
+    result, = yield [("RDN", [a, b])]
     raise PrimitiveFinished(result)
 
 def dict_in(a, b, **remainder):
-    b_value = yield [("RV", [b])]
-    value = yield [("RD", [a, b_value])]
+    b_value, = yield [("RV", [b])]
+    value, = yield [("RD", [a, b_value])]
     is_in = value is not None
-    result = yield [("CNV", [is_in])]
+    result, = yield [("CNV", [is_in])]
     raise PrimitiveFinished(result)
 
 def dict_in_node(a, b, **remainder):
-    value = yield [("RDN", [a, b])]
-    result = yield [("CNV", [value is not None])]
+    value, = yield [("RDN", [a, b])]
+    result, = yield [("CNV", [value is not None])]
     raise PrimitiveFinished(result)
 
 def dict_len(a, **remainder):
-    outgoings = yield [("RO", [a])]
-    result = yield [("CNV", [len(outgoings)])]
+    outgoings, = yield [("RO", [a])]
+    result, = yield [("CNV", [len(outgoings)])]
     raise PrimitiveFinished(result)
 
 def dict_keys(a, **remainder):
@@ -303,59 +303,59 @@ def dict_keys(a, **remainder):
     raise PrimitiveFinished(result)
 
 def dict_reverse(a, b, **remainder):
-    edges = yield [("RO", [a])]
-    expanded_edges = yield [("RE", [i]) for i in edges]
+    edges, = yield [("RO", [a])]
+    expanded_edges, = yield [("RE", [i]) for i in edges]
     for i, edge in enumerate(expanded_edges):
         if b == edge[1]:
             # Found our edge: edges[i]
-            outgoing = yield [("RO", [edges[i]])]
-            result = yield [("RE", [outgoing[0]])]
+            outgoing, = yield [("RO", [edges[i]])]
+            result, = yield [("RE", [outgoing[0]])]
             raise PrimitiveFinished(result[1])
 
-    result = yield [("CNV", ["(unknown: %s)" % b])]
+    result, = yield [("CNV", ["(unknown: %s)" % b])]
     raise PrimitiveFinished(result)
 
 def is_physical_int(a, **remainder):
-    t = yield [("RV", [a])]
-    result = yield [("CNV", [isinstance(t, int) or isinstance(t, long)])]
+    t, = yield [("RV", [a])]
+    result, = yield [("CNV", [isinstance(t, int) or isinstance(t, long)])]
     raise PrimitiveFinished(result)
 
 def is_physical_string(a, **remainder):
-    t = yield [("RV", [a])]
-    result = yield [("CNV", [isinstance(t, str) or isinstance(t, unicode)])]
+    t, = yield [("RV", [a])]
+    result, = yield [("CNV", [isinstance(t, str) or isinstance(t, unicode)])]
     raise PrimitiveFinished(result)
 
 def is_physical_float(a, **remainder):
-    t = yield [("RV", [a])]
-    result = yield [("CNV", [isinstance(t, float)])]
+    t, = yield [("RV", [a])]
+    result, = yield [("CNV", [isinstance(t, float)])]
     raise PrimitiveFinished(result)
 
 def is_physical_boolean(a, **remainder):
-    t = yield [("RV", [a])]
-    result = yield [("CNV", [isinstance(t, bool)])]
+    t, = yield [("RV", [a])]
+    result, = yield [("CNV", [isinstance(t, bool)])]
     raise PrimitiveFinished(result)
 
 def is_physical_action(a, **remainder):
-    t = yield [("RV", [a])]
-    result = yield [("CNV", [isinstance(t, dict) and t["value"] in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]])]
+    t, = yield [("RV", [a])]
+    result, = yield [("CNV", [isinstance(t, dict) and t["value"] in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]])]
     raise PrimitiveFinished(result)
 
 def create_node(**remainder):
-    result = yield [("CN", [])]
+    result, = yield [("CN", [])]
     raise PrimitiveFinished(result)
 
 def create_edge(a, b, **remainder):
-    result = yield [("CE", [a, b])]
+    result, = yield [("CE", [a, b])]
     raise PrimitiveFinished(result)
 
 def create_value(a, **remainder):
-    a_value = yield [("RV", [a])]
-    result = yield [("CNV", [a_value])]
+    a_value, = yield [("RV", [a])]
+    result, = yield [("CNV", [a_value])]
     raise PrimitiveFinished(result)
 
 def read_nr_out(a, **remainder):
-    outgoing = yield [("RO", [a])]
-    result = yield [("CNV", [len(outgoing)])]
+    outgoing, = yield [("RO", [a])]
+    result, = yield [("CNV", [len(outgoing)])]
     raise PrimitiveFinished(result)
 
 def read_out(a, b, **remainder):
@@ -363,8 +363,8 @@ def read_out(a, b, **remainder):
     raise PrimitiveFinished(sorted(outgoing)[b_value])
 
 def read_nr_in(a, **remainder):
-    incoming = yield [("RI", [a])]
-    result = yield [("CNV", [len(incoming)])]
+    incoming, = yield [("RI", [a])]
+    result, = yield [("CNV", [len(incoming)])]
     raise PrimitiveFinished(result)
 
 def read_in(a, b, **remainder):
@@ -372,23 +372,23 @@ def read_in(a, b, **remainder):
     raise PrimitiveFinished(sorted(incoming)[b_value])
 
 def read_edge_src(a, **remainder):
-    result = yield [("RE", [a])]
+    result, = yield [("RE", [a])]
     raise PrimitiveFinished(result[0])
 
 def read_edge_dst(a, **remainder):
-    result = yield [("RE", [a])]
+    result, = yield [("RE", [a])]
     raise PrimitiveFinished(result[1])
 
 def delete_element(a, **remainder):
-    edge = yield [("RE", [a])]
+    edge, = yield [("RE", [a])]
     if edge[0] is None:
         # Not an edge:
         yield [("DN", [a])]
-        result = yield [("CNV", [False])]
+        result, = yield [("CNV", [False])]
         raise PrimitiveFinished(result)
     else:
         yield [("DE", [a])]
-        result = yield [("CNV", [True])]
+        result, = yield [("CNV", [True])]
         raise PrimitiveFinished(result)
 
 def read_root(root, **remainder):
@@ -399,21 +399,19 @@ def set_add(a, b, **remainder):
     raise PrimitiveFinished(a)
 
 def set_pop(a, **remainder):
-    outgoing = yield [("RO", [a])]
+    outgoing, = yield [("RO", [a])]
     v, _ = yield [("RE", [outgoing[0]]), ("DE", [outgoing[0]])]
     raise PrimitiveFinished(v[1])
 
 def set_remove(a, b, **remainder):
     outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
     elements = yield [("RE", [i]) for i in outgoing]
-    elements = [elements] if not isinstance(elements[0], list) else elements
     values = yield [("RV", [i[1]]) for i in elements]
-    values = [values] if not isinstance(values, list) else values
     yield [("DE", [identifier]) for identifier, edge in zip(outgoing, values) if edge == b_value]
     raise PrimitiveFinished(a)
 
 def set_remove_node(a, b, **remainder):
-    outgoing = yield [("RO", [a])]
+    outgoing, = yield [("RO", [a])]
     elements = yield [("RE", [i]) for i in outgoing]
     elements = [elements] if not isinstance(elements[0], list) else elements
     yield [("DE", [identifier]) for identifier, edge in zip(outgoing, elements) if edge[1] == b]
@@ -423,39 +421,36 @@ def set_in(a, b, **remainder):
     outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
     if outgoing:
         elements = yield [("RE", [i]) for i in outgoing]
-        elements = [elements] if not isinstance(elements[0], list) else elements
         values = yield [("RV", [i[1]]) for i in elements]
-        values = [values] if not isinstance(values, list) else values
         if b_value in [v for v in values]:
-            result = yield [("CNV", [True])]
+            result, = yield [("CNV", [True])]
         else:
-            result = yield [("CNV", [False])]
+            result, = yield [("CNV", [False])]
     else:
-        result = yield [("CNV", [False])]
+        result, = yield [("CNV", [False])]
     raise PrimitiveFinished(result)
 
 def set_in_node(a, b, **remainder):
-    outgoing = yield [("RO", [a])]
+    outgoing, = yield [("RO", [a])]
     if outgoing:
         elements = yield [("RE", [i]) for i in outgoing]
-        elements = [elements] if not isinstance(elements[0], list) else elements
         if b in [v[1] for v in elements]:
-            result = yield [("CNV", [True])]
+            result, = yield [("CNV", [True])]
         else:
-            result = yield [("CNV", [False])]
+            result, = yield [("CNV", [False])]
     else:
-        result = yield [("CNV", [False])]
+        result, = yield [("CNV", [False])]
     raise PrimitiveFinished(result)
 
 def is_edge(a, **remainder):
-    edge = yield [("RE", [a])]
-    result = yield [("CNV", [edge[0] is not None])]
+    edge, = yield [("RE", [a])]
+    result, = yield [("CNV", [edge[0] is not None])]
     raise PrimitiveFinished(result)
 
 #TODO deprecate
 def deserialize(a, root, **remainder):
     print("DESERIALIZE")
-    value = yield [("RV", [a])]
+    value, = yield [("RV", [a])]
     id_mappings = {}
     complex_primitives = frozenset(["if", "while", "assign", "call", "break", "continue", "return","resolve","access", "constant", "input", "output", "declare", "global"])
     for l in value.split("\n"):
@@ -465,7 +460,7 @@ def deserialize(a, root, **remainder):
             continue
         if graph_type == "N":
             # Node
-            id_mappings[constructor] = yield [("CN", [])]
+            id_mappings[constructor], = yield [("CN", [])]
         elif graph_type == "V":
             # Node with Value
             name, temp = constructor.split("(", 1)
@@ -475,16 +470,16 @@ def deserialize(a, root, **remainder):
             else:
                 #TODO this is very dangerous!
                 value = eval(string_value)
-            id_mappings[name] = yield [("CNV", [value])]
+            id_mappings[name], = yield [("CNV", [value])]
         elif graph_type == "E":
             # Edge
             name, temp = constructor.split("(", 1)
             source, target = temp[:-1].split(",", 1)
             if target[0] == "?" and target not in id_mappings:
                 hierarchy = target[1:].split("/")
-                current = yield [("RD", [root, "__hierarchy"])]
+                current, = yield [("RD", [root, "__hierarchy"])]
                 for i in hierarchy:
-                    current = yield [("RD", [current, i])]
+                    current, = yield [("RD", [current, i])]
                 id_mappings[target] = current
             try:
                 source = int(source)
@@ -495,7 +490,7 @@ def deserialize(a, root, **remainder):
             except:
                 target = id_mappings[target]
             # Both nodes will normally be already present in the matching dictionary, so can just pass them along
-            id_mappings[name] = yield [("CE", [source, target])]
+            id_mappings[name], = yield [("CE", [source, target])]
         elif graph_type == "D":
             source, value, target = constructor.split(",",3)
             if value in complex_primitives:
@@ -505,9 +500,9 @@ def deserialize(a, root, **remainder):
                 value = eval(value)
             if target[0] == "?" and target not in id_mappings:
                 hierarchy = target[1:].split("/")
-                current = yield [("RD", [root, "__hierarchy"])]
+                current, = yield [("RD", [root, "__hierarchy"])]
                 for i in hierarchy:
-                    current = yield [("RD", [current, i])]
+                    current, = yield [("RD", [current, i])]
                 id_mappings[target] = current
             try:
                 source = int(source)
@@ -523,7 +518,7 @@ def deserialize(a, root, **remainder):
     raise PrimitiveFinished(id_mappings["auto_initial_IP"])
 
 def log(a, **remainder):
-    a_value = yield [("RV", [a])]
+    a_value, = yield [("RV", [a])]
     print("== LOG == " + str(a_value))
     raise PrimitiveFinished(a)
 

kernel/test/utils.py

@@ -73,8 +73,6 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
         response = []
         for command, param in mvs_commands:
             response.append(mvs.execute(command, param)[0])
-        if len(mvs_commands) == 1:
-            response = response[0]
 
 def get_inst(root, mvs):
     user_root = mvs.execute("RD", [root, "user_1"])[0]