Removed unused code

Author: Theomat

examples/pbe/calculator/convert_calculator.py

@@ -1,36 +1,19 @@
 import json
-from typing import Any, Callable, Dict, Tuple, List as TList
+from typing import Any, Callable, Dict, List as TList
 
 import tqdm
 
 from synth import Task, Dataset, PBE, Example
 from synth.syntax import (
-    INT,
     FunctionType,
-    List,
-    Type,
-    Arrow,
-    Function,
-    Primitive,
     Program,
-    Variable,
     UnknownType,
     guess_type,
 )
 
 from calculator import dsl, evaluator, FLOAT
 
-# this dictionary contains the primitives as defined in the dsl
-name2type: Dict[str, Type] = {p.primitive: p.type for p in dsl.list_primitives}
-# this dictionary contains the instantiated primitives, that is to say after removal of polymorphic type
-name2fulltype = {}
 dsl.instantiate_polymorphic_types(5)
-for p in dsl.list_primitives:
-    if isinstance(p.type, Arrow):
-        name = str(p) + str(p.type.arguments()[0])
-    else:
-        name = p.primitive
-    name2fulltype[name] = p.type
 
 
 def __convert__(load: Callable[[], Dataset[PBE]], name: str) -> None:
@@ -41,7 +24,10 @@ def __convert__(load: Callable[[], Dataset[PBE]], name: str) -> None:
     # Integrity check
     for task in tqdm.tqdm(tasks, desc="integrity check"):
         for ex in task.specification.examples:
-            assert evaluator.eval(task.solution, ex.inputs) == ex.output
+            obt = evaluator.eval(task.solution, ex.inputs)
+            assert (
+                obt == ex.output
+            ), f"failed on {task.solution} inputs:{ex.inputs} got:{obt} target:{ex.output}"
 
 
 def convert_calculator(
@@ -60,13 +46,13 @@ def load() -> Dataset[PBE]:
                 args_types = [guess_type(arg) for arg in inputs[0]] + [
                     guess_type(outputs[0])
                 ]
-                # guess_type doesn't recognise FLOAT but since it is the only type not recognised we know that Unknown TYpe is acutally FLOAT
+                # guess_type doesn't recognise FLOAT but since it is the only type not recognised we know that Unknown Type is acutally FLOAT
                 args_types = [
                     at if not isinstance(at, UnknownType) else FLOAT
                     for at in args_types
                 ]
                 type_request = FunctionType(*args_types)
-                prog = dsl.parse_program(name, type_request)
+                prog: Program = dsl.parse_program(name, type_request)
                 examples = [
                     Example(inp, out)
                     for inp, out in zip(inputs, outputs)
@@ -82,47 +68,6 @@ def load() -> Dataset[PBE]:
     __convert__(load, output_file)
 
 
-"""
-Parser of program stored in the json file, for a given task.
-s: program attribute represented as a string
-returns: Tuple[Program, Type] where program is the solution of type Type to the task
-"""
-
-
-def __calculator_str2prog(s: str) -> Tuple[Program, Type]:
-    parts = s.split("|")
-    stack: TList[Program] = []
-    var: int = 0
-    type_stack: TList[Type] = []
-    for part in parts:
-        subparts = part.split(",")
-        name = subparts.pop(0)
-        # possible inputs, int or float in our case
-        if name == "INT":
-            stack.append(Variable(var, INT))
-            var += 1
-            type_stack.append(INT)
-            continue
-        if name == "FLOAT":
-            stack.append(Variable(var, FLOAT))
-            var += 1
-            type_stack.append(FLOAT)
-            continue
-        # primitives that serve as constants
-        if name in ["1", "2", "3"]:
-            primitive = Primitive(name, name2fulltype[name])
-            stack.append(primitive)
-        else:  # other primitives are functions, we want to add their type
-            targets = [int(x) for x in subparts]
-            arguments = [stack[x] for x in targets]
-            longname = name + str(arguments[-1].type)
-            primitive = Primitive(name, name2fulltype[longname])
-            stack.append(Function(primitive, arguments))
-    type_stack.append(stack[-1].type)
-    type_request = FunctionType(*type_stack)
-    return stack[-1], type_request
-
-
 if __name__ == "__main__":
     import argparse