Remove primitive functions

bootstrap/bootstrap.py

@@ -26,15 +26,11 @@ def bootstrap():
                     "integer_multiplication": ["Integer", "Integer", "Integer"],
                     "integer_division": ["Integer", "Integer", "Integer"],
                     "integer_gt": ["Boolean", "Integer", "Integer"],
-                    "integer_lt": ["Boolean", "Integer", "Integer"],
-                    "integer_neg": ["Integer", "Integer"],
                     "float_addition": ["Float", "Float", "Float"],
                     "float_subtraction": ["Float", "Float", "Float"],
                     "float_multiplication": ["Float", "Float", "Float"],
                     "float_division": ["Float", "Float", "Float"],
-                    "float_gt": ["Boolean", "Float", "Float"],
                     "float_lt": ["Boolean", "Float", "Float"],
-                    "float_neg": ["Float", "Float"],
                     "bool_and": ["Boolean", "Boolean", "Boolean"],
                     "bool_or": ["Boolean", "Boolean", "Boolean"],
                     "bool_not": ["Boolean", "Boolean"],
@@ -43,7 +39,6 @@ def bootstrap():
                     "string_len": ["Integer", "String"],
                     "string_split": ["Element", "String", "String"],
                     "value_eq":  ["Boolean", "Element", "Element"],
-                    "value_neq": ["Boolean", "Element", "Element"],
                     "cast_i2f": ["Float", "Integer"],
                     "cast_i2s": ["String", "Integer"],
                     "cast_i2b": ["Boolean", "Integer"],
@@ -60,24 +55,17 @@ def bootstrap():
                     "cast_a2s": ["String", "Action"],
                     "cast_v2s": ["String", "Element"],
                     "cast_id2s": ["String", "Element"],
-                    "list_read": ["Element", "Element", "Integer"],
-                    "list_append": ["Element", "Element", "Element"],
                     "list_insert": ["Element", "Element", "Integer", "Element"],
                     "list_delete": ["Element", "Element", "Integer"],
-                    "list_len": ["Integer", "Element"],
-                    "dict_add": ["Element", "Element", "Element", "Element"],
                     "dict_add_fast": ["Element", "Element", "Element", "Element"],
                     "dict_delete": ["Element", "Element", "Element"],
                     "dict_delete_node": ["Element", "Element", "Element"],
                     "dict_read": ["Element", "Element", "Element"],
                     "dict_read_edge": ["Element", "Element", "Element"],
                     "dict_read_node": ["Element", "Element", "Element"],
-                    "dict_len": ["Integer", "Element"],
                     "dict_in": ["Boolean", "Element", "Element"],
                     "dict_in_node": ["Boolean", "Element", "Element"],
                     "dict_keys": ["Element", "Element"],
-                    "set_add": ["Element", "Element", "Element"],
-                    "set_pop": ["Element", "Element"],
                     "set_remove": ["Element", "Element", "Element"],
                     "set_remove_node": ["Element", "Element", "Element"],
                     "set_in": ["Boolean", "Element", "Element"],
@@ -99,7 +87,6 @@ def bootstrap():
                     "read_edge_dst": ["Element", "Element"],
                     "delete_element": ["Element", "Element"],
                     "element_eq": ["Boolean", "Element", "Element"],
-                    "element_neq": ["Boolean", "Element", "Element"],
                     "read_root": ["Element"],
                     "read_taskroot": ["Element"],
                     "log": ["String", "String"],

bootstrap/semi_primitives.alc

@@ -3,6 +3,16 @@ include "primitives.alh"
 Boolean function value_neq(a : Element, b : Element):
 	return bool_not(value_eq(a, b))!
 
+Boolean function integer_gt(a : Element, b : Element):
+	return bool_or(integer_lt(a, b), value_eq(a, b))!
+
+Boolean function float_gt(a : Element, b : Element):
+	return bool_or(float_lt(a, b), value_eq(a, b))!
+
+Void function dict_add(a : Element, b : Element, c : Element):
+	create_edge(create_edge(a, c), b)
+	return a!
+
 Boolean function element_neq(a : Element, b : Element):
 	return bool_not(element_eq(a, b))!
 

kernel/modelverse_kernel/primitives.py

@@ -59,10 +59,12 @@ def integer_division(a, b, **remainder):
     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])]
     raise PrimitiveFinished(result)
+"""
 
 def integer_lt(a, b, **remainder):
     # TODO make non-primitive, though compiled
@@ -70,11 +72,13 @@ def integer_lt(a, b, **remainder):
     result, = yield [("CNV", [a_value < b_value])]
     raise PrimitiveFinished(result)
 
+"""
 def integer_neg(a, **remainder):
     # TODO make non-primitive, though compiled
     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])]
@@ -111,10 +115,12 @@ def float_division(a, b, **remainder):
     result, = yield [("CNV", [float(a_value) / float(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])]
     raise PrimitiveFinished(result)
+"""
 
 def float_lt(a, b, **remainder):
     # TODO make non-primitive, though compiled
@@ -122,11 +128,13 @@ def float_lt(a, b, **remainder):
     result, = yield [("CNV", [a_value < b_value])]
     raise PrimitiveFinished(result)
 
+"""
 def float_neg(a, **remainder):
     # TODO make non-primitive, though compiled
     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])]
@@ -157,20 +165,24 @@ def value_eq(a, b, **remainder):
     result, = yield [("CNV", [a_value == b_value])]
     raise PrimitiveFinished(result)
 
+"""
 def value_neq(a, b, **remainder):
     # TODO make non-primitive, though compiled
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
     result, = yield [("CNV", [a_value != b_value])]
     raise PrimitiveFinished(result)
+"""
 
 def element_eq(a, b, **remainder):
     result, = yield [("CNV", [a == b])]
     raise PrimitiveFinished(result)
 
+"""
 def element_neq(a, b, **remainder):
     # TODO make non-primitive, though compiled
     result, = yield [("CNV", [a != b])]
     raise PrimitiveFinished(result)
+"""
 
 def cast_a2s(a, **remainder):
     a_value, = yield [("RV", [a])]
@@ -257,11 +269,13 @@ def cast_id2s(a, **remainder):
     result, = yield [("CNV", ["%s" % (a)])]
     raise PrimitiveFinished(result)
 
+"""
 def list_append(a, b, **remainder):
     # TODO make non-primitive, though compiled
     a_outgoing, = yield [("RO", [a])]
     _ = yield [("CD", [a, len(a_outgoing), b])]
     raise PrimitiveFinished(a)
+"""
 
 def list_insert(a, b, c, **remainder):
     # TODO make non-primitive, though compiled
@@ -286,6 +300,7 @@ def list_delete(a, b, **remainder):
           [("DE", [i]) for i in edges]
     raise PrimitiveFinished(a)
 
+"""
 def list_read(a, b, **remainder):
     # TODO same as dictionary read
     b_value, = yield [("RV", [b])]
@@ -293,17 +308,22 @@ def list_read(a, b, **remainder):
     if result is None:
         raise Exception("List read out of bounds: %s" % b_value)
     raise PrimitiveFinished(result)
+"""
 
+"""
 def list_len(a, **remainder):
     # TODO same as read_nr_out
     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])]
     yield [("CE", [new_edge, b])]
     raise PrimitiveFinished(a)
+"""
 
 def dict_add_fast(a, b, c, **remainder):
     # TODO deprecate, as dict_add is now also efficient
@@ -355,31 +375,19 @@ def dict_in_node(a, b, **remainder):
     result, = yield [("CNV", [value is not None])]
     raise PrimitiveFinished(result)
 
+"""
 def dict_len(a, **remainder):
     # TODO same as read_nr_out
     outgoings, = yield [("RO", [a])]
     result, = yield [("CNV", [len(outgoings)])]
     raise PrimitiveFinished(result)
+"""
 
 def dict_keys(a, **remainder):
     keys, result = yield [("RDK", [a]), ("CN", [])]
     yield [("CE", [result, v]) for v in keys]
     raise PrimitiveFinished(result)
 
-def dict_reverse(a, b, **remainder):
-    # TODO remove as unused
-    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]])]
-            raise PrimitiveFinished(result[1])
-
-    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)])]
@@ -459,6 +467,7 @@ def delete_element(a, **remainder):
 def read_root(root, **remainder):
     raise PrimitiveFinished(root)
 
+"""
 def set_add(a, b, **remainder):
     # TODO make non-primitive, though compiled
 
@@ -479,7 +488,9 @@ def set_add(a, b, **remainder):
     else:
         yield [("CE", [a, b])]
         raise PrimitiveFinished(a)
+"""
 
+"""
 def set_pop(a, **remainder):
     # TODO make non-primitive, though compiled
     outgoing, = yield [("RO", [a])]
@@ -489,6 +500,7 @@ def set_pop(a, **remainder):
     else:
         print("Pop from empty set!")
         raise PrimitiveFinished(remainder["root"])
+"""
 
 def set_remove(a, b, **remainder):
     outgoing, b_value = yield [("RO", [a]), ("RV", [b])]