Ported all compiled functions (untested) and fixed code generation bugs

bootstrap/semi_primitives.alc

@@ -555,6 +555,9 @@ String function spawn(function : Element, arguments : Element):
 	return taskname!
 
 Element function list_insert(a : Element, b : Element, c : Integer):
+	log("ENTER list insert")
+	log("Insert in list at location " + cast_string(c))
+	log("Length " + cast_string(list_len(a)))
 	Integer current
 	Element prev
 	Element new_prev
@@ -562,12 +565,18 @@ Element function list_insert(a : Element, b : Element, c : Integer):
 	current = c
 	prev = b
 
+	log("Before while")
 	while (current < list_len(a)):
+		log("In current " + cast_string(current) + " out of " + cast_string(list_len(a)))
 		new_prev = list_read(a, current)
 		dict_delete(a, current)
 		dict_add_fast(a, current, prev)
 		prev = new_prev
 		current = current + 1
+		log("End of while")
+	log("After while")
+
+	dict_add_fast(a, current, prev)
 	
 	return a!
 

kernel/modelverse_kernel/compiled.py

@@ -3,12 +3,12 @@ import time
 
 """
 def get_superclasses(a, b, **remainder):
-    model, name = a, b
-    model_dict, tm_dict, name_value = yield [("RD", [a, "model"]), 
-                                             ("RD", [a, "type_mapping"]),
-                                             ("RV", [b])]
+    if 'value' not in b:
+        b['value'], = yield [("RV", [b['id']])]
+    model_dict, tm_dict = yield [("RD", [a, "model"]), 
+                                 ("RD", [a, "type_mapping"])]
 
-    worklist = set([name_value])
+    worklist = set(b['value'])
     found = set([])
 
     cache_value = {}
@@ -27,9 +27,11 @@ def get_superclasses(a, b, **remainder):
             link = outgoing.pop()
 
             # If the link is typed by "Inheritance", we add its destination
-            link_name_node, = yield [("CALL_ARGS", [reverseKeyLookup, [model_dict, link]])]
-            link_name, = yield [("RV", [link_name_node])]
-            t_edge, = yield [("RD", [tm_dict, link_name])]
+            link_name_node, = yield [("CALL_ARGS", [reverseKeyLookup, [{'id': model_dict}, {'id': link}]])]
+            if "value" not in link_name_node:
+                link_name_node['id'], = yield [("CNV", [link_name_node['value']])]
+
+            t_edge, = yield [("RD", [tm_dict, link_name_node['value']])]
             t_edge, = yield [("RV", [t_edge])]
             if t_edge == "Inheritance":
                 edge, = yield [("RE", [link])]
@@ -45,17 +47,20 @@ def get_superclasses(a, b, **remainder):
     result, = yield [("CN", [])]
     yield [("CD", [result, i, result]) for i in found]
 
-    raise PrimitiveFinished(result)
+    raise PrimitiveFinished({'id': result})
 
 def reverseKeyLookupMulti(a, b, **remainder):
-    edges, b_val, result = yield [("RO", [a]), ("RV", [b]), ("CN", [])]
+    if "value" not in b:
+        b['value'], = yield [("RV", [b['id']])]
+
+    edges, result = yield [("RO", [a['id']]), ("CN", [])]
     expanded_edges = yield [("RE", [i]) for i in edges]
     values = yield [("RV", [i[1]]) for i in expanded_edges]
 
     # Keep results in a local Python set, as we want to bundle as many requests as possible
     todo = set()
     for i, edge in enumerate(values):
-        if b_val == edge:
+        if b['value'] == edge:
             todo.add(i)
 
     outgoings = yield [("RO", [edges[i]]) for i in todo]
@@ -63,13 +68,10 @@ def reverseKeyLookupMulti(a, b, **remainder):
     edges = yield [("CE", [result, result]) for value in values]
     yield [("CE", [edge, value[1]]) for edge, value in zip(edges, values)]
 
-    raise PrimitiveFinished(result)
+    raise PrimitiveFinished({'id': result})
 
 def reverseKeyLookup(a, b, **remainder):
-    if a is None or b is None:
-        result, = yield [("CNV", [""])]
-        raise PrimitiveFinished(result)
-    edges_out, edges_in = yield [("RO", [a]), ("RI", [b])]
+    edges_out, edges_in = yield [("RO", [a['id']]), ("RI", [b['id']])]
     options = set(edges_out) & set(edges_in)
     if options:
         # Select one option randomly
@@ -78,48 +80,52 @@ def reverseKeyLookup(a, b, **remainder):
         # Select one option randomly
         out_edge = out_edges.pop()
         e, = yield [("RE", [out_edge])]
-        result = e[1]
+        raise PrimitiveFinished({'id': e[1]})
     else:
-        result, = yield [("CNV", [""])]
-    raise PrimitiveFinished(result)
+        raise PrimitiveFinished({'value': ""})
 
 def instantiated_name(a, b, **remainder):
-    name_value, = yield [("RV", [b])]
-    if name_value == "":
-        b, = yield [("CNV", ["__" + str(a)])]
+    if "value" not in b:
+        b['value'], = yield [("RV", [b["id"]])]
+    if "id" not in a:
+        a['id'], = yield [("CNV", [a['value']])]
+
+    if b['value'] == "":
+        b['value'] = "__" + str(a['id'])
+
     raise PrimitiveFinished(b)
 
 def set_merge(a, b, **remainder):
-    keys, =         yield [("RDK", [b])]
-    edges =         yield [("CE", [a, a]) for key in keys]
+    keys, =         yield [("RDK", [b['id']])]
+    edges =         yield [("CE", [a['id'], a['id']]) for key in keys]
     _ =             yield [("CE", [edge, key]) for edge, key in zip(edges, keys)]
     raise PrimitiveFinished(a)
 
 def has_value(a, **remainder):
-    v, = yield [("RV", [a])]
-    if v is None:
-        result, = yield [("CNV", [False])]
+    if "value" not in a:
+        a['value'], = yield [("RV", [])]
+    if a['value'] is None:
+        raise PrimitiveFinished({'value': False})
     else:
-        result, = yield [("CNV", [True])]
-    raise PrimitiveFinished(result)
+        raise PrimitiveFinished({'value': True})
 
 def make_reverse_dictionary(a, **remainder):
     reverse, = yield [("CN", [])]
-    key_nodes, = yield [("RDK", [a])]
-    values = yield [("RDN", [a, i]) for i in key_nodes]
+    key_nodes, = yield [("RDK", [a['id']])]
+    values = yield [("RDN", [a['id'], i]) for i in key_nodes]
     yield [("CD", [reverse, str(v), k]) for k, v in zip(key_nodes, values)]
-    raise PrimitiveFinished(reverse)
+    raise PrimitiveFinished({'id': reverse})
 
 def dict_eq(a, b, **remainder):
-    key_nodes, = yield [("RDK", [a])]
+    key_nodes, = yield [("RDK", [a['id']])]
     key_values = yield [("RV", [i]) for i in key_nodes]
-    values = yield [("RD", [a, i]) for i in key_values]
+    values = yield [("RD", [a['id'], i]) for i in key_values]
     values = yield [("RV", [i]) for i in values]
     a_dict = dict(list(zip(key_values, values)))
 
-    key_nodes, = yield [("RDK", [b])]
+    key_nodes, = yield [("RDK", [b['id']])]
     key_values = yield [("RV", [i]) for i in key_nodes]
-    values = yield [("RD", [b, i]) for i in key_values]
+    values = yield [("RD", [b['id'], i]) for i in key_values]
     values = yield [("RV", [i]) for i in values]
     b_dict = dict(list(zip(key_values, values)))
 
@@ -127,180 +133,212 @@ def dict_eq(a, b, **remainder):
     raise PrimitiveFinished(result)
 
 def string_substr(a, b, c, **remainder):
-    a_val, b_val, c_val = yield [("RV", [a]),
-                                 ("RV", [b]),
-                                 ("RV", [c])]
+    if "value" not in a:
+        a['value'], = yield [("RV", [a['id']])]
+    if "value" not in b:
+        b['value'], = yield [("RV", [b['id']])]
+    if "value" not in c:
+        c['value'], = yield [("RV", [c['id']])]
+
     try:
-        new_value = a_val[b_val:c_val]
+        new_value = a['value'][b['value']:c['value']]
     except:
         new_value = ""
     
-    result, = yield [("CNV", [new_value])]
-    raise PrimitiveFinished(result)
+    raise PrimitiveFinished({'value': new_value})
 
 def integer_gt(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result, = yield [("CNV", [a_value > b_value])]
-    raise PrimitiveFinished(result)
+    if 'value' not in a:
+        a['value'], = yield [("RV", [a['id']])]
+    if 'value' not in b:
+        b['value'], = yield [("RV", [b['id']])]
+    raise PrimitiveFinished({'value': a['value'] > b['value']})
 
 def integer_neg(a, **remainder):
-    a_value, =          yield [("RV", [a])]
-    result, = yield [("CNV", [-a_value])]
-    raise PrimitiveFinished(result)
+    if 'value' not in a:
+        a['value'], = yield [("RV", [a['id']])]
+    raise PrimitiveFinished({'value': -a['value']})
 
 def float_gt(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result, = yield [("CNV", [a_value > b_value])]
-    raise PrimitiveFinished(result)
+    if 'value' not in a:
+        a['value'], = yield [("RV", [a['id']])]
+    if 'value' not in b:
+        b['value'], = yield [("RV", [b['id']])]
+    raise PrimitiveFinished({'value': a['value'] > b['value']})
 
 def float_neg(a, **remainder):
-    a_value, =          yield [("RV", [a])]
-    result, = yield [("CNV", [-a_value])]
-    raise PrimitiveFinished(result)
+    if 'value' not in a:
+        a['value'], = yield [("RV", [a['id']])]
+    raise PrimitiveFinished({'value': -a['value']})
 
 def value_neq(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result, = yield [("CNV", [a_value != b_value])]
-    raise PrimitiveFinished(result)
+    if 'value' not in a:
+        a['value'], = yield [("RV", [a['id']])]
+    if 'value' not in b:
+        b['value'], = yield [("RV", [b['id']])]
+    raise PrimitiveFinished({'value': a['value'] != b['value']})
 
 def element_neq(a, b, **remainder):
-    result, = yield [("CNV", [a != b])]
-    raise PrimitiveFinished(result)
+    if 'id' not in a or 'id' not in b:
+        raise PrimitiveFinished({'value': False})
+    else:
+        raise PrimitiveFinished({'value': a['id'] != b['id']})
 
 def list_append(a, b, **remainder):
-    a_outgoing, = yield [("RO", [a])]
-    _ = yield [("CD", [a, len(a_outgoing), b])]
+    if "id" not in b:
+        b['id'], = yield [("CNV", [b['value']])]
+    a_outgoing, = yield [("RO", [a['id']])]
+    _ = yield [("CD", [a['id'], len(a_outgoing), b['id']])]
     raise PrimitiveFinished(a)
 
 def list_read(a, b, **remainder):
-    b_value, = yield [("RV", [b])]
-    result, = yield [("RD", [a, b_value])]
+    if 'value' not in b:
+        b['value'], = yield [("RV", [b])]
+    result, = yield [("RD", [a['id'], b['value']])]
     if result is None:
-        raise Exception("List read out of bounds: %s" % b_value)
-    raise PrimitiveFinished(result)
+        raise Exception("List read out of bounds: %s" % b['value'])
+    raise PrimitiveFinished({'id': result})
 
 def list_len(a, **remainder):
-    outgoings, = yield [("RO", [a])]
+    outgoings, = yield [("RO", [a['id']])]
     result, = yield [("CNV", [len(outgoings)])]
-    raise PrimitiveFinished(result)
+    raise PrimitiveFinished({'id': result})
 
 def dict_add(a, b, c, **remainder):
-    new_edge, = yield [("CE", [a, c])]
-    yield [("CE", [new_edge, b])]
+    if 'id' not in b:
+        b['id'], = yield [("CNV", [b['value']])]
+    if 'id' not in c:
+        c['id'], = yield [("CNV", [c['value']])]
+    new_edge, = yield [("CE", [a['id'], c['id']])]
+    yield [("CE", [new_edge, b['id']])]
     raise PrimitiveFinished(a)
 
 def dict_len(a, **remainder):
-    outgoings, = yield [("RO", [a])]
-    result, = yield [("CNV", [len(outgoings)])]
-    raise PrimitiveFinished(result)
+    outgoings, = yield [("RO", [a['id']])]
+    raise PrimitiveFinished({'value': len(outgoings)})
 
 def set_add(a, b, **remainder):
-    v, =        yield [("RV", [b])]
-    is_in, =    yield [("RD", [a, v])]
+    if 'value' not in b:
+        b['value'], = yield [("RV", [b['id']])]
+    is_in, =    yield [("RD", [a['id'], b['value']])]
     if not is_in:
-        _, =    yield [("CD", [a, v, a])]
+        _, =    yield [("CD", [a['id'], b['value'], a['id']])]
     raise PrimitiveFinished(a)
 
 def set_add_node(a, b, **remainder):
-    is_in, =    yield [("RDN", [a, b])]
+    if 'id' not in b:
+        b['id'], = yield [("CNV", [b['value']])]
+    is_in, =    yield [("RDN", [a['id'], b['id']])]
     if not is_in:
-        edge, = yield [("CE", [a, a])]
-        _, =    yield [("CE", [edge, b])]
+        edge, = yield [("CE", [a['id'], a['id']])]
+        _, =    yield [("CE", [edge, b['id']])]
     raise PrimitiveFinished(a)
 
 def set_pop(a, **remainder):
-    outgoing, = yield [("RO", [a])]
+    outgoing, = yield [("RO", [a['id']])]
     if outgoing:
         outgoing = outgoing[0]
         new_outgoing, = yield [("RO", [outgoing])]
         new_outgoing = new_outgoing[0]
         edge, _ = yield [("RE", [new_outgoing]), ("DE", [outgoing])]
-        raise PrimitiveFinished(edge[1])
+        raise PrimitiveFinished({'id': edge[1]})
     else:
         raise Exception("POP from empty set")
         print("Pop from empty set!")
-        raise PrimitiveFinished(remainder["root"])
+        raise PrimitiveFinished({'id': remainder["root"]})
 
 def set_create(**remainder):
     result, = yield [("CN", [])]
-    raise PrimitiveFinished(result)
+    raise PrimitiveFinished({'id': result})
 
 def list_create(**remainder):
     result, = yield [("CN", [])]
-    raise PrimitiveFinished(result)
+    raise PrimitiveFinished({'id': result})
 
 def dict_create(**remainder):
     result, = yield [("CN", [])]
-    raise PrimitiveFinished(result)
+    raise PrimitiveFinished({'id': result})
 
 def create_tuple(a, b, **remainder):
+    if "id" not in a:
+        a['id'], = yield [("CNV", [a['value']])]
+    if "id" not in b:
+        b['id'], = yield [("CNV", [b['value']])]
+
     result, = yield [("CN", [])]
-    _, _ =    yield [("CD", [result, 0, a]),
-                     ("CD", [result, 1, b]),
+    _, _ =    yield [("CD", [result, 0, a['id']]),
+                     ("CD", [result, 1, b['id']]),
                     ]
-    raise PrimitiveFinished(result)
+    raise PrimitiveFinished({'id': result})
 
 def set_overlap(a, b, **remainder):
-    a_keys, b_keys, res = yield [("RDK", [a]), ("RDK", [b]), ("CN", [])]
+    a_keys, b_keys, res = yield [("RDK", [a['id']]), ("RDK", [b['id']]), ("CN", [])]
     a_values = yield [("RV", [i]) for i in a_keys]
     b_values = yield [("RV", [i]) for i in b_keys]
 
     result = set(a_values) & set(b_values)
     yield [("CD", [res, value, res]) for value in result]
 
-    raise PrimitiveFinished(res)
+    raise PrimitiveFinished({'id': res})
 
 def list_pop_final(a, **remainder):
-    lst, = yield [("RO", [a])]
+    lst, = yield [("RO", [a['id']])]
     length = len(lst)
-    result, result_edge = yield [("RD", [a, length - 1]),
-                                 ("RDE", [a, length -1])]
+    result, result_edge = yield [("RD", [a['id'], length - 1]),
+                                 ("RDE", [a['id'], length -1])]
     _, = yield [("DE", [result_edge])]
-    raise PrimitiveFinished(result)
+    raise PrimitiveFinished({'id': result})
 
 def instantiate_node(a, b, c, **remainder):
-    node, dict_entry, typing, name = \
+    if "value" not in c:
+        c['value'], = yield [("RV", [c['id']])]
+    node, dict_entry, typing = \
         yield [("CN", []),
-               ("RD", [a, "model"]),
-               ("RD", [a, "type_mapping"]),
-               ("RV", [c]),
+               ("RD", [a['id'], "model"]),
+               ("RD", [a['id'], "type_mapping"]),
               ]
 
-    if name == "":
+    if c['value'] == "":
         name = "__" + str(node)
-        name_node, = yield [("CNV", [name])]
+        name_node = {'value': name}
     else:
         name_node = c
 
-    yield [("CD", [dict_entry, name, node])]
-    yield [("CD", [typing, name, b])]
+    yield [("CD", [dict_entry, c['value'], node])]
+    yield [("CD", [typing, c['value'], b])]
 
     raise PrimitiveFinished(name_node)
 
 def list_insert(a, b, c, **remainder):
-    # TODO make non-primitive, though compiled
-    a_outgoing, c_value = yield [("RO", [a]), ("RV", [c])] 
-    links = yield [("RD", [a, i]) for i in range(c_value, len(a_outgoing))] + \
-                  [("RDE", [a, i]) for i in range(c_value, len(a_outgoing))]
+    if "id" not in b:
+        b["id"], = yield [("CNV", [b['value']])]
+    if "value" not in c:
+        c['value'], = yield [("RV", [c['id']])]
+
+    a_outgoing, = yield [("RO", [a['id']])]
+    links = yield [("RD", [a['id'], i]) for i in range(c['value'], len(a_outgoing))] + \
+                  [("RDE", [a['id'], i]) for i in range(c['value'], len(a_outgoing))]
 
     values = links[:len(links) // 2]
     edges = links[len(links) // 2:] 
 
-    yield [("CD", [a, c_value, b])] + \
-          [("CD", [a, c_value + 1 + index, value]) for index, value in enumerate(values)] + \
+    yield [("CD", [a['id'], c['value'], b['id']])] + \
+          [("CD", [a['id'], c['value'] + 1 + index, value]) for index, value in enumerate(values)] + \
           [("DE", [i]) for i in edges]
     raise PrimitiveFinished(a)
 
 def list_delete(a, b, **remainder):
-    # TODO make non-primitive, though compiled
-    a_outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
-    links = yield [("RD", [a, i]) for i in range(b_value, len(a_outgoing))] + \
-                  [("RDE", [a, i]) for i in range(b_value, len(a_outgoing))]
+    if "value" not in b:
+        b['value'], = yield [("RV", [b['id']])]
+
+    a_outgoing,  = yield [("RO", [a['id']])]
+    links = yield [("RD", [a['id'], i]) for i in range(b['value'], len(a_outgoing))] + \
+                  [("RDE", [a['id'], i]) for i in range(b['value'], len(a_outgoing))]
 
     values = links[:len(links) // 2]
     edges = links[len(links) // 2:]
 
-    yield [("CD", [a, b_value + index, value]) for index, value in enumerate(values[1:])] + \
+    yield [("CD", [a['id'], b['value'] + index, value]) for index, value in enumerate(values[1:])] + \
           [("DE", [i]) for i in edges]
     raise PrimitiveFinished(a)
 """

kernel/modelverse_kernel/main.py

@@ -172,7 +172,7 @@ class ModelverseKernel(object):
                 prev = "  " * nested_indent + instruction + " = {'value': " + value + "}\n"
             else:
                 # Node is None, meaning that it was not about the value, but the node itself...
-                instruction = str(node)
+                instruction = "{'id': %s}" % str(node)
 
         elif inst_type["value"] == "return":
             value, = yield [("RD", [inst, "value"])]
@@ -213,8 +213,8 @@ class ModelverseKernel(object):
             value, = yield [("RD", [inst, "value"])]
             (prev, inst), = yield [("CALL_ARGS", [self.print_instruction, (value, 0, indent)])]
             instruction = prev + \
-                          "  " * indent + "if 'value' not in %s:\n" % inst + \
-                          "  " * (indent + 1) + "%s['value'], = yield [('CNV', [%s['id']])]\n" % (inst, inst) + \
+                          "  " * indent + "if 'id' not in %s:\n" % inst + \
+                          "  " * (indent + 1) + "%s['id'], = yield [('CNV', [%s['value']])]\n" % (inst, inst) + \
                           "  " * indent + "_outputs, _outputs_e = yield [('RD', [_root, 'last_output']), ('RDE', [_root, 'last_output'])]\n" + \
                           "  " * indent + "_, _new = yield [('CD', [_outputs, 'value', %s['id']]), ('CN', [])]\n" % inst+ \
                           "  " * indent + "yield [('CD', [_outputs, 'next', _new]), ('DE', [_outputs_e]), ('CD', [_root, 'last_output', _new])]\n"
@@ -260,8 +260,10 @@ class ModelverseKernel(object):
                        "  " * (nested_indent + 1) + "_var, = yield [('CN', [])]\n" + \
                        "  " * (nested_indent + 1) + "yield [('CD', [_globs, '%s', _var])]\n" % instruction_var + \
                        "  " * nested_indent + "_old_edge, = yield [('RDE', [_var, 'value'])]\n" + \
-                       "  " * nested_indent + "yield [('CD', [_var, 'value', %s]), ('DE', [_old_edge])]\n" % instruction_var + \
-                       "  " * nested_indent + "_mvk.jit.register_global('%s', %s)\n" % (instruction_var, instruction_var)
+                       "  " * nested_indent + "if 'id' not in %s:\n" % instruction_var + \
+                       "  " * (nested_indent + 1) + "%s['id'], = yield [('CNV', [%s['value']])]\n" % (instruction_var, instruction_var) + \
+                       "  " * nested_indent + "yield [('CD', [_var, 'value', %s['id']]), ('DE', [_old_edge])]\n" % instruction_var + \
+                       "  " * nested_indent + "_mvk.jit.register_global('%s', %s['id'])\n" % (instruction_var, instruction_var)
 
         elif inst_type["value"] == "call":
             func_name, = yield [("RD", [inst, "func"])]

kernel/modelverse_kernel/primitives.py

@@ -170,17 +170,17 @@ def value_eq(a, b, **remainder):
 
 def element_eq(a, b, **remainder):
     if "id" not in a:
-        print("MATERIALIZING A element_eq")
+        #print("MATERIALIZING A element_eq")
         a['id'], = yield [("CNV", [a['value']])]
     if "id" not in b:
-        print("MATERIALIZING B element_eq")
+        #print("MATERIALIZING B element_eq")
         b['id'], = yield [("CNV", [b['value']])]
     raise PrimitiveFinished({'value': a['id'] == b['id']})
 
 def cast_string(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
-    if isinstance(a_value, dict):
+    if isinstance(a['value'], dict):
         raise PrimitiveFinished({'value': str(a['value']['value'])})
     else:
         raise PrimitiveFinished({'value': str(a['value'])})
@@ -203,14 +203,14 @@ def cast_integer(a, **remainder):
 def cast_value(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
-    if isinstance(a_value, dict):
+    if isinstance(a['value'], dict):
         raise PrimitiveFinished({'value': str(a['value']['value'])})
     else:
         raise PrimitiveFinished({'value': json.dumps(a['value'])})
 
 def cast_id(a, **remainder):
     if "id" not in a:
-        print("MATERIALIZING A cast_id")
+        #print("MATERIALIZING A cast_id")
         a['id'], = yield [("CNV", [a['value']])]
     raise PrimitiveFinished({'value': str(a['id'])})
 
@@ -219,7 +219,7 @@ def dict_add_fast(a, b, c, **remainder):
     if "value" not in b:
         b['value'], = yield [("RV", [b['id']])]
     if "id" not in c:
-        print("MATERIALIZING C dict_add_fast")
+        #print("MATERIALIZING C dict_add_fast")
         c['id'], = yield [("CNV", [c['value']])]
 
     yield [("CD", [a['id'], b['value'], c['id']])]
@@ -323,10 +323,10 @@ def create_node(**remainder):
 
 def create_edge(a, b, **remainder):
     if "id" not in a:
-        print("MATERIALIZING A create_edge")
+        #print("MATERIALIZING A create_edge")
         a['id'], = yield [("CNV", [a['value']])]
     if "id" not in b:
-        print("MATERIALIZING B create_edge")
+        #print("MATERIALIZING B create_edge")
         b['id'], = yield [("CNV", [b['value']])]
     result, = yield [("CE", [a['id'], b['id']])]
     raise PrimitiveFinished({'id': result})
@@ -415,9 +415,9 @@ def hash(a, **remainder):
     import hashlib
 
     try:
-        value = hashlib.sha512(a_value).hexdigest()
+        value = hashlib.sha512(a['value']).hexdigest()
     except TypeError:
-        value = hashlib.sha512(a_value.encode()).hexdigest()
+        value = hashlib.sha512(a['value'].encode()).hexdigest()
     raise PrimitiveFinished({'value': value})
 
 def __sleep(a, b, **remainder):

state/modelverse_state/main.py

@@ -175,6 +175,8 @@ class ModelverseState(object):
         return self.free_id - 1
 
     def create_dict(self, source, data, destination):
+        if isinstance(destination, dict):
+            print("ERROR IN CD: " + str(locals()))
         if source not in self.nodes and source not in self.edges:
             return None
         elif destination not in self.nodes and destination not in self.edges:

wrappers/modelverse_SCCD.py

@@ -1,7 +1,7 @@
 """
 Generated by Statechart compiler by Glenn De Jonghe, Joeri Exelmans, Simon Van Mierlo, and Yentl Van Tendeloo (for the inspiration)
 
-Date:   Wed Apr 25 14:33:14 2018
+Date:   Wed Apr 25 19:26:56 2018
 
 Model author: Yentl Van Tendeloo
 Model name:   MvK Server