Annotations refactor alternative?

.github/workflows/python-app.yml

@@ -30,7 +30,7 @@ jobs:
         if [ -f requirements.pip ]; then pip install -r requirements.pip; fi
     - name: Lint with mypy
       run: |
-        mypy aeon
+        mypy aeon --no-strict-optional --ignore-missing-imports
     - name: Lint with flake8
       run: |
         # stop the build if there are Python syntax errors or undefined names

.vscode/settings.json

@@ -5,10 +5,13 @@
     "python.testing.unittestEnabled": false,
     "python.testing.nosetestsEnabled": false,
     "python.testing.pytestEnabled": true,
-    "python.formatting.provider": "black",
+    "python.formatting.provider": "none",
     "python.linting.mypyEnabled": true,
     "python.linting.enabled": true,
     "files.watcherExclude": {
         "**/target": true
+    },
+    "[python]": {
+        "editor.defaultFormatter": "ms-python.black-formatter"
     }
 }

aeon/__main__.py

@@ -1,19 +1,25 @@
 from __future__ import annotations
 
 import argparse
+import sys
 
-from aeon.backend.evaluator import eval
 from aeon.backend.evaluator import EvaluationContext
+from aeon.backend.evaluator import eval
 from aeon.core.types import top
+from aeon.decorators import apply_decorators
+from aeon.frontend.anf_converter import ensure_anf
 from aeon.frontend.parser import parse_term
+from aeon.logger.logger import export_log
+from aeon.logger.logger import setup_logger
 from aeon.prelude.prelude import evaluation_vars
 from aeon.prelude.prelude import typing_vars
 from aeon.sugar.desugar import desugar
 from aeon.sugar.parser import parse_program
 from aeon.sugar.program import Program
-from aeon.typechecking.typeinfer import check_and_log_type_errors
+from aeon.synthesis_grammar.identification import incomplete_functions_and_holes
+from aeon.synthesis_grammar.synthesizer import synthesize, parse_config
+from aeon.typechecking.typeinfer import check_type_errors
 from aeon.utils.ctx_helpers import build_context
-from aeon.logger.logger import setup_logger, export_log
 
 
 def parse_arguments():
@@ -25,9 +31,16 @@ def parse_arguments():
         "--log",
         nargs="+",
         default="",
-        help="set log level: \nTRACE \nDEBUG \nINFO \nTYPECHECKER \nCONSTRAINT " "\nWARNINGS \nERROR \nCRITICAL",
+        help="""set log level: \nTRACE \nDEBUG \nINFO \nWARNINGS \nTYPECHECKER \nSYNTH_TYPE \nCONSTRAINT \nSYNTHESIZER
+                \nERROR \nCRITICAL""",
     )
     parser.add_argument("-f", "--logfile", action="store_true", help="export log file")
+
+    parser.add_argument("-csv", "--csv-synth", action="store_true", help="export synthesis csv file")
+
+    parser.add_argument("-gp", "--gp-config", help="path to the GP configuration file")
+
+    parser.add_argument("-csec", "--config-section", help="section name in the GP configuration file")
     return parser.parse_args()
 
 
@@ -36,14 +49,23 @@ def read_file(filename: str) -> str:
         return file.read()
 
 
-def process_code(core: bool, code: str) -> tuple:
-    if core:
-        context = build_context(typing_vars)
-        evaluation_ctx = EvaluationContext(evaluation_vars)
-        return parse_term(code), context, evaluation_ctx
-    else:
-        prog: Program = parse_program(code)
-        return desugar(prog)
+def apply_decorators_in_program(p: Program) -> Program:
+    """We apply the decorators meta-programming code to each definition in the program."""
+    new_definitions = []
+    for definition in p.definitions:
+        new_def, other_defs = apply_decorators(definition)
+        new_definitions.append(new_def)
+        new_definitions.extend(other_defs)
+    return Program(p.imports, p.type_decls, new_definitions)
+
+
+def log_type_errors(errors: list[Exception | str]):
+    logger.log("TYPECHECKER", "-------------------------------")
+    logger.log("TYPECHECKER", "+     Type Checking Error     +")
+    for error in errors:
+        logger.log("TYPECHECKER", "-------------------------------")
+        logger.log("TYPECHECKER", error)
+    logger.log("TYPECHECKER", "-------------------------------")
 
 
 if __name__ == "__main__":
@@ -52,8 +74,46 @@ def process_code(core: bool, code: str) -> tuple:
     export_log(args.log, args.logfile, args.filename)
 
     aeon_code = read_file(args.filename)
-    p, ctx, ectx = process_code(args.core, aeon_code)
-    logger.info(p)
 
-    if not check_and_log_type_errors (ctx, p, top):
-        eval(p, ectx)
+    if args.core:
+        typing_ctx = build_context(typing_vars)
+        evaluation_ctx = EvaluationContext(evaluation_vars)
+        core_ast = parse_term(aeon_code)
+    else:
+        prog: Program = parse_program(aeon_code)
+        prog = apply_decorators_in_program(prog)
+        (
+            core_ast,
+            typing_ctx,
+            evaluation_ctx,
+        ) = desugar(prog)
+    logger.info(core_ast)
+
+    core_ast_anf = ensure_anf(core_ast)
+    type_errors = check_type_errors(typing_ctx, core_ast_anf, top)
+    if type_errors:
+        log_type_errors(type_errors)
+        sys.exit(1)
+
+    incomplete_functions: list[tuple[str, list[str]]] = incomplete_functions_and_holes(typing_ctx, core_ast_anf)
+
+    if incomplete_functions:
+        filename = args.filename if args.csv_synth else None
+        synth_config = (
+            parse_config(args.gp_config, args.config_section) if args.gp_config and args.config_section else None
+        )
+
+        synthesis_result = synthesize(
+            typing_ctx,
+            evaluation_ctx,
+            core_ast_anf,
+            incomplete_functions,
+            filename,
+            synth_config,
+        )
+        print(f"Best solution:{synthesis_result}")
+        # print()
+        # pretty_print_term(ensure_anf(synthesis_result, 200))
+        sys.exit(1)
+
+    eval(core_ast, evaluation_ctx)

aeon/backend/evaluator.py

@@ -34,6 +34,10 @@ def get(self, name: str):
         return self.variables[name]
 
 
+def is_native_var(t: Application):
+    return isinstance(t.fun, Var) and t.fun.name == "native"
+
+
 # pattern match term
 def eval(t: Term, ctx: EvaluationContext = EvaluationContext()):
     if isinstance(t, Literal):
@@ -45,7 +49,9 @@ def eval(t: Term, ctx: EvaluationContext = EvaluationContext()):
     elif isinstance(t, Application):
         f = eval(t.fun, ctx)
         arg = eval(t.arg, ctx)
-        e = f(arg)
+        # e = real_eval(arg, __globals=ctx.variables) if is_native_var(t) else f(arg)
+        e = real_eval(arg, ctx.variables) if is_native_var(t) else f(arg)
+
         if isinstance(t.fun, Var) and t.fun.name == "native_import":
             globals()[arg] = e
         return e

aeon/bindings/image.py

@@ -2,8 +2,10 @@
 
 import math
 
+import numpy as np
 from PIL import Image
 from PIL.ImageDraw import Draw
+from skimage.metrics import mean_squared_error as mse
 
 from aeon.bindings.binding_utils import curried
 
@@ -25,3 +27,10 @@ def Image_draw_rectangle(im, x, y, w, h, c):
 def Image_diff(im1, im2):
     s = sum((a - b) ** 2 for a, b in zip(im1.histogram(), im2.histogram()))
     return math.sqrt(s)
+
+
+@curried
+def Image_diff_mse(im1, im2):
+    im1 = np.array(im1)
+    im2 = np.array(im2)
+    return mse(im1, im2)

aeon/core/distance.py

@@ -42,8 +42,7 @@ def term_label_dist(s1: str, s2: str):
 
 
 def distance_terms(t1: Term, t2: Term):
-    return zss.simple_distance(t1, t2, term_children, term_label,
-                               term_label_dist)
+    return zss.simple_distance(t1, t2, term_children, term_label, term_label_dist)
 
 
 def pairwise_distance(ts: list[Term]):
@@ -66,7 +65,6 @@ def term_depth(t: Term):
     elif isinstance(t, Let):
         return 1 + max(term_depth(t.var_value), term_depth(t.body))
     elif isinstance(t, If):
-        return 1 + max(term_depth(t.cond), term_depth(t.then),
-                       term_depth(t.otherwise))
+        return 1 + max(term_depth(t.cond), term_depth(t.then), term_depth(t.otherwise))
     else:
         return 1

aeon/core/liquid.py

@@ -50,14 +50,12 @@ def __repr__(self):
         return f"{self.value}".lower()
 
     def __eq__(self, other):
-        return isinstance(other,
-                          LiquidLiteralBool) and other.value == self.value
+        return isinstance(other, LiquidLiteralBool) and other.value == self.value
 
     def __hash__(self) -> int:
         return hash(self.value)
 
 
-
 class LiquidLiteralInt(LiquidTerm):
     value: int
 
@@ -68,8 +66,7 @@ def __repr__(self):
         return f"{self.value}"
 
     def __eq__(self, other):
-        return isinstance(other,
-                          LiquidLiteralInt) and other.value == self.value
+        return isinstance(other, LiquidLiteralInt) and other.value == self.value
 
     def __hash__(self) -> int:
         return hash(self.value)
@@ -85,8 +82,7 @@ def __repr__(self):
         return f"{self.value}"
 
     def __eq__(self, other):
-        return isinstance(other,
-                          LiquidLiteralFloat) and other.value == self.value
+        return isinstance(other, LiquidLiteralFloat) and other.value == self.value
 
     def __hash__(self) -> int:
         return hash(self.value)
@@ -102,8 +98,7 @@ def __repr__(self):
         return f"{self.value}"
 
     def __eq__(self, other):
-        return isinstance(other,
-                          LiquidLiteralString) and other.value == self.value
+        return isinstance(other, LiquidLiteralString) and other.value == self.value
 
     def __hash__(self) -> int:
         return hash(self.value)

aeon/core/liquid_ops.py

@@ -19,6 +19,11 @@
     ("/", ("Int", "Int", "Int")),
     ("-", ("Int", "Int", "Int")),
     ("%", ("Int", "Int", "Int")),
+    ("*.", ("Float", "Float", "Float")),
+    ("+.", ("Float", "Float", "Float")),
+    ("/.", ("Float", "Float", "Float")),
+    ("-.", ("Float", "Float", "Float")),
+    ("%.", ("Float", "Float", "Float")),
     ("!", ("Bool", "Bool")),
 ]
 

aeon/core/pprint.py

@@ -1,12 +1,27 @@
 from __future__ import annotations
 
 from aeon.core.liquid import LiquidLiteralBool
+from aeon.core.terms import (
+    Abstraction,
+    Annotation,
+    Application,
+    Hole,
+    If,
+    Let,
+    Literal,
+    Rec,
+    Term,
+    TypeAbstraction,
+    TypeApplication,
+    Var,
+)
 from aeon.core.types import AbstractionType
 from aeon.core.types import BaseType
 from aeon.core.types import RefinedType
 from aeon.core.types import Type
-from aeon.core.types import type_free_term_vars
 from aeon.core.types import TypeVar
+from aeon.core.types import type_free_term_vars
+from aeon.synthesis_grammar.grammar import aeon_prelude_ops_to_text
 
 
 def pretty_print(t: Type) -> str:
@@ -28,3 +43,84 @@ def pretty_print(t: Type) -> str:
         else:
             return f"{{{t.name}:{it} | {t.refinement}}}"
     assert False
+
+
+def pretty_print_term(term: Term):
+    term_str: str = custom_preludes_ops_representation(term)[0]
+    print(term_str)
+
+
+ops_to_abstraction: dict[str, str] = {
+    "%": "Int) -> Int",
+    "/": "Int) -> Int",
+    "*": "Int) -> Int",
+    "-": "Int) -> Int",
+    "+": "Int) -> Int",
+    "%.": "Float) -> Float",
+    "/.": "Float) -> Float",
+    "*.": "Float) -> Float",
+    "-.": "Float) -> Float",
+    "+.": "Float) -> Float",
+    ">=": "Int) -> Bool",
+    ">": "Int) -> Bool",
+    "<=": "Int) -> Bool",
+    "<": "Int) -> Bool",
+    "!=": "Int) -> Bool",
+    "==": "Int) -> Bool",
+}
+
+
+def custom_preludes_ops_representation(term: Term, counter: int = 0) -> tuple[str, int]:
+    prelude_operations: dict[str, str] = aeon_prelude_ops_to_text
+    match term:
+        case Application(fun=Var(name=var_name), arg=arg) if var_name in prelude_operations.keys():
+            op = var_name
+            arg_str, counter = custom_preludes_ops_representation(arg, counter)
+            counter += 1
+            new_var_name = f"__{prelude_operations[op]}_{counter}__"
+            abstraction_type_str = f"({new_var_name}:{ops_to_abstraction[op]}"
+            personalized_op = f": {abstraction_type_str} = (\\{new_var_name} -> {arg_str} {op} {new_var_name})"
+            return personalized_op, counter
+
+        case Application(fun=fun, arg=arg):
+            fun_str, counter = custom_preludes_ops_representation(fun, counter)
+            arg_str, counter = custom_preludes_ops_representation(arg, counter)
+            return f"= ({fun_str} {arg_str})", counter
+
+        case Annotation(expr=expr, type=type):
+            expr_str, counter = custom_preludes_ops_representation(expr, counter)
+            return f"({expr_str} : {type})", counter
+
+        case Abstraction(var_name=var_name, body=body):
+            body_str, counter = custom_preludes_ops_representation(body, counter)
+            return f"(\\{var_name} -> {body_str})", counter
+
+        case Let(var_name=var_name, var_value=var_value, body=body):
+            var_value_prefix = "= " if not isinstance(var_value, Application) else ""
+            var_value_str, counter = custom_preludes_ops_representation(var_value, counter)
+            body_str, counter = custom_preludes_ops_representation(body, counter)
+            return f"(let {var_name} {var_value_prefix}{var_value_str} in\n {body_str})", counter
+
+        case Rec(var_name=var_name, var_type=var_type, var_value=var_value, body=body):
+            var_value_str, counter = custom_preludes_ops_representation(var_value, counter)
+            body_str, counter = custom_preludes_ops_representation(body, counter)
+            return f"(let {var_name} : {var_type} = {var_value_str} in\n {body_str})", counter
+
+        case If(cond=cond, then=then, otherwise=otherwise):
+            cond_str, counter = custom_preludes_ops_representation(cond, counter)
+            then_str, counter = custom_preludes_ops_representation(then, counter)
+            otherwise_str, counter = custom_preludes_ops_representation(otherwise, counter)
+            return f"(if {cond_str} then {then_str} else {otherwise_str})", counter
+
+        case TypeAbstraction(name=name, kind=kind, body=body):
+            body_str, counter = custom_preludes_ops_representation(body, counter)
+            return f"ƛ{name}:{kind}.({body_str})", counter
+
+        case TypeApplication(body=body, type=type):
+            body_str, counter = custom_preludes_ops_representation(body, counter)
+            return f"({body_str})[{type}]", counter
+
+        case Literal(_, _) | Var(_) | Hole(_):
+            return str(term), counter
+
+    return str(term), counter