AeonLang 4.0.0b0__tar.gz

aeonlang-4.0.0b0/AeonLang.egg-info/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: AeonLang
+Version: 4.0.0b0
+Summary: Language with Refinement Types
+Author-email: Alcides Fonseca <me@alcidesfonseca.com>
+License: https://opensource.org/licenses/MIT
+Project-URL: homepage, https://github.com/alcides/aeon
+Project-URL: repository, https://github.com/alcides/aeon
+Project-URL: documentation, https://github.com/alcides/aeon
+Keywords: programming language, liquid types
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: ~=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: argparse
+Requires-Dist: configparser
+Requires-Dist: lark
+Requires-Dist: loguru
+Requires-Dist: geneticengine==0.8.7
+Requires-Dist: multiprocess
+Requires-Dist: numpy
+Requires-Dist: pathos
+Requires-Dist: pillow
+Requires-Dist: psb2
+Requires-Dist: pydantic==2.11.7
+Requires-Dist: pygls==1.3.1
+Requires-Dist: pytest
+Requires-Dist: requests
+Requires-Dist: types-requests
+Requires-Dist: scikit-image
+Requires-Dist: sympy
+Requires-Dist: textdistance
+Requires-Dist: z3-solver>=4
+Requires-Dist: zstandard==0.23.0
+Requires-Dist: zss
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-beartype; extra == "tests"
+
+# Aeon 4
+
+Aeon is a programming languages that features Liquid Types, developed at the University of Lisbon. Unlike [LiquidHaskell](https://ucsd-progsys.github.io/liquidhaskell/) or [LiquidJava](https://catarinagamboa.github.io/liquidjava.html), Aeon was designed from the ground up to have support for Liquid Types.
+
+Aeon is in development, so assume all your programs to break. This 4th version is implemented as a Python interpreter, giving you access to any code written in Python.
+
+## Examples
+
+
+### Hello World
+
+```
+def main (args:Int) : Unit {
+    print "Hello World"
+}
+```
+
+The documentation is available at [https://alcides.github.io/aeon](https://alcides.github.io/aeon).
+
+
+### Liquid Types
+
+In this example, you can see the refined type `{x:Int | x > 0}` that represents all integers that are greater than 0. You can also see an example of Python FFI, where a python valid expression can be written as string and passed as the argument to the `native` function.
+
+```
+def sqrt : (i: {x:Int | x > 0} ) -> Float = native "__import__('math').sqrt";
+
+def main (i:Int) : Unit {
+    print (sqrt (-25)) # This is a type-checking error!
+}
+```
+
+
+
+Authors
+----------
+Aeon has been developed at [LASIGE](https://www.lasige.pt), [University of Lisbon](https://ciencias.ulisboa.pt) by:
+
+* [Alcides Fonseca](http://alcidesfonseca.com)
+* [Paulo Santos](https://pcanelas.com/)
+* [Eduardo Madeira](https://www.lasige.pt/member/jose-eduardo-madeira)
+* [Guilherme Espada](https://espada.dev)
+* [Lishun Su](https://lasige.pt/member/su-lishun/)
+* [Paulo Silva](https://github.com/PauloHS-Silva)
+* [Diogo Sousa](https://github.com/SousaTrashBin)
+
+Acknowledgements
+----------------
+
+This work was supported by Fundação para a Ciência e Tecnologia (FCT) through:
+
+* [the LASIGE Research Unit](https://www.lasige.pt) (ref. UID/00408/2025)
+* [the FCT Exploratory project RAP](http://wiki.alcidesfonseca.com/research/projects/rap/) (EXPL/CCI-COM/1306/2021)
+* the FCT Advanced Computing projects (CPCA/A1/395424/2021, CPCA/A1/5613/2020, CPCA/A2/6009/2020)
+
+And by Lisboa2020, Compete2020 and FEDER through:
+
+* [the CMU|Portugal CAMELOT project](http://wiki.alcidesfonseca.com/research/projects/camelot/) (LISBOA-01-0247-FEDER-045915)
+
+
+Publications
+-----------------
+
+* [Comparing the expressive power of Strongly-Typed and Grammar-Guided Genetic Programming](https://www.researchgate.net/publication/370277603_Comparing_the_expressive_power_of_Strongly-Typed_and_Grammar-Guided_Genetic_Programming) at GECCO'23
+* [The Usability Argument for Refinement Typed Genetic Programming](https://link.springer.com/chapter/10.1007/978-3-030-58115-2_2) at PPSN'20
+
+Let us know if your paper uses Aeon, to list it here.
+
+Please cite as:
+
+```
+Fonseca, Alcides, Paulo Santos, and Sara Silva. "The usability argument for refinement typed genetic programming." International Conference on Parallel Problem Solving from Nature. Cham: Springer International Publishing, 2020.
+```
+
+Bibtex:
+
+```
+@inproceedings{fonseca2020usability,
+  title={The usability argument for refinement typed genetic programming},
+  author={Fonseca, Alcides and Santos, Paulo and Silva, Sara},
+  booktitle={International Conference on Parallel Problem Solving from Nature},
+  pages={18--32},
+  year={2020},
+  organization={Springer}
+}
+```

aeonlang-4.0.0b0/AeonLang.egg-info/SOURCES.txt

@@ -0,0 +1,99 @@
+Readme.md
+pyproject.toml
+AeonLang.egg-info/PKG-INFO
+AeonLang.egg-info/SOURCES.txt
+AeonLang.egg-info/dependency_links.txt
+AeonLang.egg-info/entry_points.txt
+AeonLang.egg-info/requires.txt
+AeonLang.egg-info/top_level.txt
+aeon/__init__.py
+aeon/__main__.py
+aeon/backend/__init__.py
+aeon/backend/evaluator.py
+aeon/bindings/__init__.py
+aeon/bindings/binding_utils.py
+aeon/bindings/image.py
+aeon/core/__init__.py
+aeon/core/bind.py
+aeon/core/distance.py
+aeon/core/equality.py
+aeon/core/instantiation.py
+aeon/core/liquid.py
+aeon/core/liquid_ops.py
+aeon/core/pprint.py
+aeon/core/substitutions.py
+aeon/core/terms.py
+aeon/core/types.py
+aeon/decorators/__init__.py
+aeon/decorators/api.py
+aeon/elaboration/__init__.py
+aeon/elaboration/context.py
+aeon/elaboration/instantiation.py
+aeon/facade/__init__.py
+aeon/facade/api.py
+aeon/facade/driver.py
+aeon/frontend/__init__.py
+aeon/frontend/aeon_core.lark
+aeon/frontend/anf_converter.py
+aeon/frontend/parser.py
+aeon/locations/__init__.py
+aeon/logger/__init__.py
+aeon/logger/logger.py
+aeon/lsp/__init__.py
+aeon/lsp/aeon_adapter.py
+aeon/lsp/server.py
+aeon/optimization/__init__.py
+aeon/optimization/normal_form.py
+aeon/prelude/__init__.py
+aeon/prelude/prelude.py
+aeon/sugar/__init__.py
+aeon/sugar/aeon_sugar.lark
+aeon/sugar/ast_helpers.py
+aeon/sugar/bind.py
+aeon/sugar/desugar.py
+aeon/sugar/equality.py
+aeon/sugar/lifting.py
+aeon/sugar/lowering.py
+aeon/sugar/parser.py
+aeon/sugar/program.py
+aeon/sugar/stypes.py
+aeon/sugar/substitutions.py
+aeon/synthesis/__init__.py
+aeon/synthesis/api.py
+aeon/synthesis/decorators.py
+aeon/synthesis/entrypoint.py
+aeon/synthesis/fitness.py
+aeon/synthesis/identification.py
+aeon/synthesis/grammar/bounds.py
+aeon/synthesis/grammar/ge_synthesis.py
+aeon/synthesis/grammar/grammar_generation.py
+aeon/synthesis/grammar/mangling.py
+aeon/synthesis/grammar/refinements.py
+aeon/synthesis/grammar/utils.py
+aeon/synthesis/modules/synthesizerfactory.py
+aeon/synthesis/modules/synquid/build.py
+aeon/synthesis/modules/synquid/synthesizer.py
+aeon/synthesis/uis/api.py
+aeon/synthesis/uis/terminal.py
+aeon/typechecking/__init__.py
+aeon/typechecking/context.py
+aeon/typechecking/entailment.py
+aeon/typechecking/liquid.py
+aeon/typechecking/typeinfer.py
+aeon/typechecking/well_formed.py
+aeon/utils/__init__.py
+aeon/utils/ast_helpers.py
+aeon/utils/ctx_helpers.py
+aeon/utils/location.py
+aeon/utils/name.py
+aeon/utils/pprint_helpers.py
+aeon/utils/superscripts.py
+aeon/utils/time_utils.py
+aeon/verification/__init__.py
+aeon/verification/helpers.py
+aeon/verification/horn.py
+aeon/verification/horn2.py
+aeon/verification/smt.py
+aeon/verification/sub.py
+aeon/verification/vcs.py
+aeon/verification/wellformness.py

aeonlang-4.0.0b0/AeonLang.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aeonlang-4.0.0b0/AeonLang.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aeon = aeon.__main__:main

aeonlang-4.0.0b0/AeonLang.egg-info/requires.txt

@@ -0,0 +1,25 @@
+argparse
+configparser
+lark
+loguru
+geneticengine==0.8.7
+multiprocess
+numpy
+pathos
+pillow
+psb2
+pydantic==2.11.7
+pygls==1.3.1
+pytest
+requests
+types-requests
+scikit-image
+sympy
+textdistance
+z3-solver>=4
+zstandard==0.23.0
+zss
+
+[tests]
+pytest
+pytest-beartype

aeonlang-4.0.0b0/AeonLang.egg-info/top_level.txt

@@ -0,0 +1 @@
+aeon

aeonlang-4.0.0b0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: AeonLang
+Version: 4.0.0b0
+Summary: Language with Refinement Types
+Author-email: Alcides Fonseca <me@alcidesfonseca.com>
+License: https://opensource.org/licenses/MIT
+Project-URL: homepage, https://github.com/alcides/aeon
+Project-URL: repository, https://github.com/alcides/aeon
+Project-URL: documentation, https://github.com/alcides/aeon
+Keywords: programming language, liquid types
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: ~=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: argparse
+Requires-Dist: configparser
+Requires-Dist: lark
+Requires-Dist: loguru
+Requires-Dist: geneticengine==0.8.7
+Requires-Dist: multiprocess
+Requires-Dist: numpy
+Requires-Dist: pathos
+Requires-Dist: pillow
+Requires-Dist: psb2
+Requires-Dist: pydantic==2.11.7
+Requires-Dist: pygls==1.3.1
+Requires-Dist: pytest
+Requires-Dist: requests
+Requires-Dist: types-requests
+Requires-Dist: scikit-image
+Requires-Dist: sympy
+Requires-Dist: textdistance
+Requires-Dist: z3-solver>=4
+Requires-Dist: zstandard==0.23.0
+Requires-Dist: zss
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-beartype; extra == "tests"
+
+# Aeon 4
+
+Aeon is a programming languages that features Liquid Types, developed at the University of Lisbon. Unlike [LiquidHaskell](https://ucsd-progsys.github.io/liquidhaskell/) or [LiquidJava](https://catarinagamboa.github.io/liquidjava.html), Aeon was designed from the ground up to have support for Liquid Types.
+
+Aeon is in development, so assume all your programs to break. This 4th version is implemented as a Python interpreter, giving you access to any code written in Python.
+
+## Examples
+
+
+### Hello World
+
+```
+def main (args:Int) : Unit {
+    print "Hello World"
+}
+```
+
+The documentation is available at [https://alcides.github.io/aeon](https://alcides.github.io/aeon).
+
+
+### Liquid Types
+
+In this example, you can see the refined type `{x:Int | x > 0}` that represents all integers that are greater than 0. You can also see an example of Python FFI, where a python valid expression can be written as string and passed as the argument to the `native` function.
+
+```
+def sqrt : (i: {x:Int | x > 0} ) -> Float = native "__import__('math').sqrt";
+
+def main (i:Int) : Unit {
+    print (sqrt (-25)) # This is a type-checking error!
+}
+```
+
+
+
+Authors
+----------
+Aeon has been developed at [LASIGE](https://www.lasige.pt), [University of Lisbon](https://ciencias.ulisboa.pt) by:
+
+* [Alcides Fonseca](http://alcidesfonseca.com)
+* [Paulo Santos](https://pcanelas.com/)
+* [Eduardo Madeira](https://www.lasige.pt/member/jose-eduardo-madeira)
+* [Guilherme Espada](https://espada.dev)
+* [Lishun Su](https://lasige.pt/member/su-lishun/)
+* [Paulo Silva](https://github.com/PauloHS-Silva)
+* [Diogo Sousa](https://github.com/SousaTrashBin)
+
+Acknowledgements
+----------------
+
+This work was supported by Fundação para a Ciência e Tecnologia (FCT) through:
+
+* [the LASIGE Research Unit](https://www.lasige.pt) (ref. UID/00408/2025)
+* [the FCT Exploratory project RAP](http://wiki.alcidesfonseca.com/research/projects/rap/) (EXPL/CCI-COM/1306/2021)
+* the FCT Advanced Computing projects (CPCA/A1/395424/2021, CPCA/A1/5613/2020, CPCA/A2/6009/2020)
+
+And by Lisboa2020, Compete2020 and FEDER through:
+
+* [the CMU|Portugal CAMELOT project](http://wiki.alcidesfonseca.com/research/projects/camelot/) (LISBOA-01-0247-FEDER-045915)
+
+
+Publications
+-----------------
+
+* [Comparing the expressive power of Strongly-Typed and Grammar-Guided Genetic Programming](https://www.researchgate.net/publication/370277603_Comparing_the_expressive_power_of_Strongly-Typed_and_Grammar-Guided_Genetic_Programming) at GECCO'23
+* [The Usability Argument for Refinement Typed Genetic Programming](https://link.springer.com/chapter/10.1007/978-3-030-58115-2_2) at PPSN'20
+
+Let us know if your paper uses Aeon, to list it here.
+
+Please cite as:
+
+```
+Fonseca, Alcides, Paulo Santos, and Sara Silva. "The usability argument for refinement typed genetic programming." International Conference on Parallel Problem Solving from Nature. Cham: Springer International Publishing, 2020.
+```
+
+Bibtex:
+
+```
+@inproceedings{fonseca2020usability,
+  title={The usability argument for refinement typed genetic programming},
+  author={Fonseca, Alcides and Santos, Paulo and Silva, Sara},
+  booktitle={International Conference on Parallel Problem Solving from Nature},
+  pages={18--32},
+  year={2020},
+  organization={Springer}
+}
+```

aeonlang-4.0.0b0/Readme.md

@@ -0,0 +1,86 @@
+# Aeon 4
+
+Aeon is a programming languages that features Liquid Types, developed at the University of Lisbon. Unlike [LiquidHaskell](https://ucsd-progsys.github.io/liquidhaskell/) or [LiquidJava](https://catarinagamboa.github.io/liquidjava.html), Aeon was designed from the ground up to have support for Liquid Types.
+
+Aeon is in development, so assume all your programs to break. This 4th version is implemented as a Python interpreter, giving you access to any code written in Python.
+
+## Examples
+
+
+### Hello World
+
+```
+def main (args:Int) : Unit {
+    print "Hello World"
+}
+```
+
+The documentation is available at [https://alcides.github.io/aeon](https://alcides.github.io/aeon).
+
+
+### Liquid Types
+
+In this example, you can see the refined type `{x:Int | x > 0}` that represents all integers that are greater than 0. You can also see an example of Python FFI, where a python valid expression can be written as string and passed as the argument to the `native` function.
+
+```
+def sqrt : (i: {x:Int | x > 0} ) -> Float = native "__import__('math').sqrt";
+
+def main (i:Int) : Unit {
+    print (sqrt (-25)) # This is a type-checking error!
+}
+```
+
+
+
+Authors
+----------
+Aeon has been developed at [LASIGE](https://www.lasige.pt), [University of Lisbon](https://ciencias.ulisboa.pt) by:
+
+* [Alcides Fonseca](http://alcidesfonseca.com)
+* [Paulo Santos](https://pcanelas.com/)
+* [Eduardo Madeira](https://www.lasige.pt/member/jose-eduardo-madeira)
+* [Guilherme Espada](https://espada.dev)
+* [Lishun Su](https://lasige.pt/member/su-lishun/)
+* [Paulo Silva](https://github.com/PauloHS-Silva)
+* [Diogo Sousa](https://github.com/SousaTrashBin)
+
+Acknowledgements
+----------------
+
+This work was supported by Fundação para a Ciência e Tecnologia (FCT) through:
+
+* [the LASIGE Research Unit](https://www.lasige.pt) (ref. UID/00408/2025)
+* [the FCT Exploratory project RAP](http://wiki.alcidesfonseca.com/research/projects/rap/) (EXPL/CCI-COM/1306/2021)
+* the FCT Advanced Computing projects (CPCA/A1/395424/2021, CPCA/A1/5613/2020, CPCA/A2/6009/2020)
+
+And by Lisboa2020, Compete2020 and FEDER through:
+
+* [the CMU|Portugal CAMELOT project](http://wiki.alcidesfonseca.com/research/projects/camelot/) (LISBOA-01-0247-FEDER-045915)
+
+
+Publications
+-----------------
+
+* [Comparing the expressive power of Strongly-Typed and Grammar-Guided Genetic Programming](https://www.researchgate.net/publication/370277603_Comparing_the_expressive_power_of_Strongly-Typed_and_Grammar-Guided_Genetic_Programming) at GECCO'23
+* [The Usability Argument for Refinement Typed Genetic Programming](https://link.springer.com/chapter/10.1007/978-3-030-58115-2_2) at PPSN'20
+
+Let us know if your paper uses Aeon, to list it here.
+
+Please cite as:
+
+```
+Fonseca, Alcides, Paulo Santos, and Sara Silva. "The usability argument for refinement typed genetic programming." International Conference on Parallel Problem Solving from Nature. Cham: Springer International Publishing, 2020.
+```
+
+Bibtex:
+
+```
+@inproceedings{fonseca2020usability,
+  title={The usability argument for refinement typed genetic programming},
+  author={Fonseca, Alcides and Santos, Paulo and Silva, Sara},
+  booktitle={International Conference on Parallel Problem Solving from Nature},
+  pages={18--32},
+  year={2020},
+  organization={Springer}
+}
+```

aeonlang-4.0.0b0/aeon/__main__.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from argparse import ArgumentParser
+
+from aeon.facade.api import AeonError
+from aeon.facade.driver import AeonConfig, AeonDriver
+from aeon.logger.logger import export_log
+from aeon.logger.logger import setup_logger
+from aeon.lsp.server import AeonLanguageServer
+from aeon.synthesis.uis.api import SynthesisUI, SynthesisFormat
+from aeon.synthesis.uis.terminal import TerminalUI
+from aeon.utils.pprint_helpers import pretty_print
+
+sys.setrecursionlimit(10000)
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser()
+
+    if "-lsp" in sys.argv or "--language-server-mode" in sys.argv:
+        parser.add_argument(
+            "-lsp",
+            "--language-server-mode",
+            action="store_true",
+            help="run language server mode",
+        )
+        parser.add_argument(
+            "--tcp",
+            help="listen on tcp port or hostname:port on IPv4.",
+            type=str,
+        )
+
+    else:
+        parser.add_argument("filename", help="name of the aeon files to be synthesized")
+
+    _parse_common_arguments(parser)
+    return parser.parse_args()
+
+
+def _parse_common_arguments(parser: ArgumentParser):
+    parser.add_argument("--core", action="store_true", help="synthesize a aeon core file")
+    parser.add_argument("--budget", type=int, default=60, help="Time for synthesis (in seconds).")
+    parser.add_argument(
+        "-l",
+        "--log",
+        nargs="+",
+        default="",
+        help="""set log level: \nTRACE \nDEBUG \nINFO \nWARNINGS \nCONSTRAINT \nTYPECHECKER \nSYNTH_TYPE \nCONSTRAINT \nSYNTHESIZER
+                        \nERROR \nCRITICAL\n TIME""",
+    )
+    parser.add_argument(
+        "-f",
+        "--logfile",
+        action="store_true",
+        help="export log file",
+    )
+    parser.add_argument(
+        "-d",
+        "--debug",
+        action="store_true",
+        help="Show debug information",
+    )
+
+    parser.add_argument(
+        "-t",
+        "--timings",
+        action="store_true",
+        help="Show timing information",
+    )
+
+    parser.add_argument("-n", "--no-main", action="store_true", help="Disables introducing hole in main")
+
+    parser.add_argument(
+        "-s",
+        "--synthesizer",
+        type=str,
+        default="gp",
+        help="Select a synthesizer for synthesis(gp for Genetic programming(Defaut), synquid for Synquid, random_search for Random Search, enumerative for Enumerative Search, hc for Hill Climbing, and 1p1 for One Plus One)",
+    )
+
+    parser.add_argument(
+        "--format",
+        type=str,
+        choices=["default", "json"],
+        default="default",
+        help="Select the synthesised holes format results: default or json",
+    )
+
+    return parser.parse_args()
+
+
+def select_synthesis_ui() -> SynthesisUI:
+    return TerminalUI()
+
+
+def handle_error(err: AeonError):
+    # TODO: handle each error with proper printing
+    match err:
+        case _:
+            print(f">>> Error at {err.position()}:")
+            print(err)
+
+
+def main() -> None:
+    args = parse_arguments()
+
+    logger = setup_logger()
+    logfile_name = None
+    if hasattr(args, "filename"):
+        logfile_name = args.filename
+    elif hasattr(args, "language_server_mode"):
+        logfile_name = "lsp"
+    export_log(args.log, args.logfile, logfile_name)
+
+    if args.debug:
+        logger.add(sys.stderr)
+    if args.timings:
+        logger.add(sys.stderr, level="TIME")
+
+    cfg = AeonConfig(
+        synthesizer=args.synthesizer,
+        synthesis_ui=select_synthesis_ui(),
+        synthesis_budget=args.budget,
+        timings=args.timings,
+        no_main=args.no_main,
+        synthesis_format=SynthesisFormat.from_string(args.format),
+    )
+    driver = AeonDriver(cfg)
+
+    if hasattr(args, "language_server_mode"):
+        aeon_lsp = AeonLanguageServer(driver)
+        aeon_lsp.start(args.tcp)
+        sys.exit(0)
+
+    if args.core:
+        errors = driver.parse_core(args.filename)
+    else:
+        errors = driver.parse(args.filename)
+
+    if errors:
+        for err in errors:
+            handle_error(err)
+    elif driver.has_synth():
+        term = driver.synth()
+        print("Synthesized:")
+        print(str(term))
+        print(pretty_print(term))
+    else:
+        driver.run()
+
+
+if __name__ == "__main__":
+    main()