lambda-repl 1.1.0__tar.gz → 1.2.1__tar.gz

lambda_repl-1.2.1/.flake8

@@ -0,0 +1,3 @@
+[flake8]
+max-line-length = 100
+extend-ignore = E221,E501

lambda_repl-1.2.1/.gitignore

@@ -0,0 +1,164 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+.direnv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# VSCode
+.vscode/

{lambda_repl-1.1.0 → lambda_repl-1.2.1}/PKG-INFO

@@ -1,10 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: lambda_repl
-Version: 1.1.0
+Version: 1.2.1
 Summary: REPL for the lambda calculus
-Author-email: Eric Niklas Wolf <eric_niklas.wolf@mailbox.tu-dresden.de>
 Project-URL: Repository, https://github.com/Deric-W/lambda_repl
 Project-URL: Bugtracker, https://github.com/Deric-W/lambda_repl/issues
+Author-email: Eric Niklas Wolf <eric_niklas.wolf@mailbox.tu-dresden.de>
+License-File: LICENSE
 Classifier: Intended Audience :: Education
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
@@ -13,21 +14,25 @@ Classifier: Topic :: Education
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
+Requires-Dist: lambda-calculus~=3.0
+Requires-Dist: lark~=1.0
 Description-Content-Type: text/markdown
-License-File: LICENSE
 
 # lambda_repl
 
+[![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
 ![Tests](https://github.com/Deric-W/lambda_repl/actions/workflows/Tests.yaml/badge.svg)
 [![codecov](https://codecov.io/gh/Deric-W/lambda_repl/branch/main/graph/badge.svg?token=SU3982mC17)](https://codecov.io/gh/Deric-W/lambda_repl)
 
-The `lambda_repl` package contains a [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) for the [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus).
+The `lambda_repl` package contains a [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop)
+for the [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus).
 
 To use it, execute `lambda-repl` or `python3 -m lambda_repl` and enter commands.
 
 ## Requirements
 
-Python >= 3.10 and the `lambda_calculus` package are required to use this package.
+Python >= 3.10 and the packages [`lambda_calculus`](https://github.com/Deric-W/lambda_calculus)
+and [`lark`](https://github.com/lark-parser/lark) are required to use this package.
 
 ## Installation
 
@@ -42,9 +47,11 @@ python3 -m lambda_repl
 Welcome to the the Lambda REPL, type 'help' for help
 λ alias I = \x.x
 λ alias K = λx.λy.x
+λ import SUCC = lambda_calculus.terms.arithmetic.SUCCESSOR
 λ aliases
 I = (λx.x)
 K = (λx.(λy.x))
+SUCC = (λn.(λf.(λx.(f ((n f) x)))))
 λ trace K a b
 β ((λy.a) b)
 β a

{lambda_repl-1.1.0 → lambda_repl-1.2.1}/README.md

@@ -1,15 +1,18 @@
 # lambda_repl
 
+[![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
 ![Tests](https://github.com/Deric-W/lambda_repl/actions/workflows/Tests.yaml/badge.svg)
 [![codecov](https://codecov.io/gh/Deric-W/lambda_repl/branch/main/graph/badge.svg?token=SU3982mC17)](https://codecov.io/gh/Deric-W/lambda_repl)
 
-The `lambda_repl` package contains a [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) for the [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus).
+The `lambda_repl` package contains a [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop)
+for the [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus).
 
 To use it, execute `lambda-repl` or `python3 -m lambda_repl` and enter commands.
 
 ## Requirements
 
-Python >= 3.10 and the `lambda_calculus` package are required to use this package.
+Python >= 3.10 and the packages [`lambda_calculus`](https://github.com/Deric-W/lambda_calculus)
+and [`lark`](https://github.com/lark-parser/lark) are required to use this package.
 
 ## Installation
 
@@ -24,12 +27,14 @@ python3 -m lambda_repl
 Welcome to the the Lambda REPL, type 'help' for help
 λ alias I = \x.x
 λ alias K = λx.λy.x
+λ import SUCC = lambda_calculus.terms.arithmetic.SUCCESSOR
 λ aliases
 I = (λx.x)
 K = (λx.(λy.x))
+SUCC = (λn.(λf.(λx.(f ((n f) x)))))
 λ trace K a b
 β ((λy.a) b)
 β a
 λ exit
 Exiting REPL...
-```
+```

lambda_repl-1.2.1/codecov.SHA256SUM

@@ -0,0 +1 @@
+8930c4bb30254a42f3d8c340706b1be340885e20c0df5160a24efa2e030e662b  codecov

lambda_repl-1.2.1/codecov.SHA256SUM.sig

@@ -0,0 +1,16 @@
+-----BEGIN PGP SIGNATURE-----
+
+iQIzBAABCgAdFiEEJwNOf9uFDgu8LGL/gGuyiu13mGkFAmnnz8MACgkQgGuyiu13
+mGnysA/7Byxt7YmTKIwMRW8+VOoUCp0mKosnlZMvDyc/lVS1K2xpMxXOl/mIMzPD
+OZT7ApPZ70A2hDrsz631yMMxM9/xDAFPEmWfM3aepoQNsrZjyW8Qh9SSQQPvu+sh
+v6cnZhLBwWty1fvdZTS9RWWBaqheCYSXmrLocLXgrh4TzlHeXxA2dAjNKWXZb5H6
+M6FXnSTuQ5+kckijzzuaZJ7sA9IWQI4CtVXc+n850YPAOpg35xc7aR3vLOL5dlmW
+jICLk0T2DX0PDE7Nw9mQhnRXZsGHifQUPrNsDu2CqRmHMaiP/9dL2LcD8A4bIR46
+R48LTqDu75BueDIGerQya5SH38JZk3E2YAQb7tZMdviDp0yOGeYhNMfxUd8mxs8Q
+oxLhZW73CFOjapQnRxyYaGi27f9ldCQ4w5KrxwM9YaFBr335cFYG183jDDFUYjr2
+gzRi+jwKowr6h0Edx+teoB5B7FO0Gvx5gWhyI8xuoeklIu3iLaDYAyHxmUjHRfMx
+D3ioTVwm+vkq+eIXJfDe0sAlJjTHMo/udsc4aKYmxtgj7Um0Xe8IUmPkopn09F+5
+E5X0yncFG5CPLFHY5xZklEW2pZI2WdkXp/fXwfKUxgME4ntr1C1/y9x2j71bbRtu
+neus07LhjRdYfDb3/9opafzxSJ8sTvkGnMaSfDshYo15dfTU+1g=
+=SKRh
+-----END PGP SIGNATURE-----

{lambda_repl-1.1.0 → lambda_repl-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda_repl"
-version = "1.1.0"
+version = "1.2.1"
 description = "REPL for the lambda calculus"
 requires-python = ">=3.10"
 keywords = []
@@ -14,7 +14,7 @@ classifiers = [
     "Typing :: Typed"
 ]
 dependencies = [
-    "lambda-calculus ~= 2.0",
+    "lambda-calculus ~= 3.0",
     "lark ~= 1.0"
 ]
 
@@ -34,15 +34,36 @@ Bugtracker = "https://github.com/Deric-W/lambda_repl/issues"
 lambda-repl = "lambda_repl.main:main_cli"
 
 [build-system]
-requires = ["setuptools >= 61.0.0"]
-build-backend = "setuptools.build_meta"
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
-[tool.setuptools.package-data]
-lambda_repl = [
-    "py.typed",
-    "grammar.lark"
+[tool.hatch.envs.hatch-test]
+installer = "pip"
+
+[[tool.hatch.envs.hatch-test.matrix]]
+python = ["3.10", "3.11", "3.12", "3.13", "3.14"]
+
+[tool.hatch.envs.lint]
+dependencies = [
+    "mypy >= 1.0.0",
+    "pylint >= 2.12.2",
+    "flake8 >= 5.0.0",
+    "isort >= 5.10.1"
 ]
 
+[tool.hatch.envs.lint.scripts]
+lint = [
+    "- flake8 src/lambda_repl",
+    "- pylint src/lambda_repl"
+]
+typecheck = "mypy -p lambda_repl"
+release = [
+    "typecheck"
+]
+
+[tool.hatch.build.targets.sdist]
+exclude = ["/.github"]
+
 [tool.mypy]
 disallow_any_unimported = true
 disallow_any_generics = true
@@ -52,4 +73,12 @@ strict_optional = true
 warn_redundant_casts = true
 warn_unused_ignores = true
 warn_return_any = true
-warn_unreachable = true
+warn_unreachable = true
+
+[tool.pylint]
+max-line-length = 100
+
+[tool.coverage.run]
+source_pkgs = ["lambda_repl"]
+branch = true
+parallel = true

{lambda_repl-1.1.0 → lambda_repl-1.2.1/src}/lambda_repl/__init__.py

@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 from cmd import Cmd
+from importlib import import_module
 from typing import Any
 from lambda_calculus.terms import Term
 from lambda_calculus.visitors.normalisation import (
@@ -14,7 +15,7 @@ from lark.exceptions import UnexpectedInput
 from .parsing import LambdaTransformer
 from .aliases import Aliases
 
-__version__ = "1.1.0"
+__version__ = "1.2.1"
 __author__  = "Eric Niklas Wolf"
 __email__   = "eric_niklas.wolf@mailbox.tu-dresden.de"
 __all__ = (
@@ -51,6 +52,19 @@ class LambdaREPL(Cmd):
             self.stdout.write(error.get_context(term))
         return None
 
+    def import_term(self, location: str) -> Term[str] | None:
+        """import a term and handle error display"""
+        module, _, name = location.strip().rpartition(".")
+        try:
+            term = getattr(import_module(module), name)
+        except Exception as error:  # pylint: disable=W0718
+            self.stdout.write(f"Error while importing: {error}\n")
+            return None
+        if not isinstance(term, Term):
+            self.stdout.write(f"Error: object {term} is not a lambda term\n")
+            return None
+        return term
+
     def emptyline(self) -> bool:
         """ignore empty lines"""
         return False
@@ -95,6 +109,17 @@ class LambdaREPL(Cmd):
                 self.stdout.write("invalid Command: missing alias value\n")
         return False
 
+    def do_import(self, arg: str) -> bool:
+        """import an alias from a module with name = module.name"""
+        match arg.partition("="):
+            case (alias, "=", location):
+                term = self.import_term(location)
+                if term is not None:
+                    self.aliases[alias.strip()] = term
+            case _:
+                self.stdout.write("invalid Command: missing import location\n")
+        return False
+
     def do_aliases(self, _: object) -> bool:
         """list defined aliases"""
         for alias, term in self.aliases.items():

lambda_repl-1.2.1/src/lambda_repl/grammar.lark

@@ -0,0 +1,13 @@
+_WHITESPACE: /\s+/
+
+VARIABLE: /[^\s().λ\\]+/
+
+abstraction: ("\\" | "λ") VARIABLE "." term
+
+application: _application_term _WHITESPACE (abstraction | _simple_term)
+
+?term: abstraction | _application_term
+
+_application_term: application | _simple_term
+
+_simple_term: VARIABLE | "(" term ")"

{lambda_repl-1.1.0 → lambda_repl-1.2.1/src}/lambda_repl/parsing.py

@@ -4,7 +4,7 @@
 
 from __future__ import annotations
 from collections import deque
-from collections.abc import Iterator, Sequence
+from collections.abc import Iterator
 from itertools import chain
 from lambda_calculus.terms import Abstraction, Application, Term, Variable
 from lark import Lark, Token
@@ -52,10 +52,10 @@ class LambdaTransformer(Transformer[Token, Term[str]]):
         """parse a string and return the transformed lambda term"""
         # the parser sometimes return tokens directly instead of a tree
         match PARSER.parse(string):
-            case Token(type="VARIABLE") as name:    # type: ignore
-                return self.VARIABLE(name)          # type: ignore
-            case Token() as token:                  # type: ignore
-                raise UnexpectedToken(token, {"VARIABLE",})
+            case Token(type="VARIABLE") as name:
+                return self.VARIABLE(name)
+            case Token() as token:
+                raise UnexpectedToken(token, {"VARIABLE", })
             case tree:
                 return self.transform(tree)
 
@@ -63,6 +63,10 @@ class LambdaTransformer(Transformer[Token, Term[str]]):
         """handle unknown nodes"""
         raise UnexpectedInput(f"unknown node: {data}")
 
+    def __default_token__(self, token: Token) -> Token:
+        """handle unknown tokens"""
+        raise UnexpectedInput(f"unknown token: {token}")
+
     def VARIABLE(self, name: Token) -> Variable[str]:
         """transform a variable node"""
         return Variable(name.value)
@@ -72,9 +76,10 @@ class LambdaTransformer(Transformer[Token, Term[str]]):
         """transform an abstraction"""
         return Abstraction(variable.name, body)
 
-    def application(self, children: Sequence[Term[str]]) -> Application[str]:
+    @v_args(inline=True)
+    def application(self, abstraction: Term[str], argument: Term[str]) -> Application[str]:
         """transform an application"""
-        return Application.with_arguments(children[0], children[1:])
+        return Application(abstraction, argument)
 
 
 PARSER = Lark.open_from_package(

lambda_repl-1.2.1/tests/test_aliases.py

@@ -0,0 +1,68 @@
+#!/usr/bin/python3
+
+"""Tests for alias implementations"""
+
+from unittest import TestCase
+from lambda_calculus.terms import Variable
+from lambda_calculus.visitors.substitution.renaming import CountingSubstitution
+from lambda_repl import aliases
+
+
+class LetAliasesTest(TestCase):
+    """Test for alias implementation without self reference"""
+
+    aliases: aliases.LetAliases[str]
+
+    def setUp(self) -> None:
+        """create empty aliases"""
+        self.aliases = aliases.LetAliases(CountingSubstitution)
+
+    def test_set(self) -> None:
+        """test setting new aliases"""
+        self.aliases["a"] = Variable("1")
+        self.aliases["b"] = Variable("a").apply_to(Variable("c"))
+        self.aliases["c"] = Variable("2")
+        self.assertEqual(
+            list(self.aliases.items()),
+            [
+                ("a", Variable("1")),
+                ("b", Variable("1").apply_to(Variable("c"))),
+                ("c", Variable("2"))
+            ]
+        )
+
+    def test_override(self) -> None:
+        """test overriding aliases"""
+        self.aliases["a"] = Variable("1")
+        self.aliases["b"] = Variable("a").apply_to(Variable("c"))
+        self.aliases["a"] = Variable("2")
+        self.assertEqual(
+            list(self.aliases.items()),
+            [
+                ("b", Variable("1").apply_to(Variable("c"))),
+                ("a", Variable("2"))
+            ]
+        )
+
+    def test_apply(self) -> None:
+        """test applying aliases"""
+        self.aliases["a"] = Variable("1")
+        self.aliases["b"] = Variable("a").apply_to(Variable("c"))
+        self.aliases["a"] = Variable("2")
+        self.aliases["c"] = Variable("3")
+        self.assertEqual(
+            self.aliases.apply(
+                Variable("a").apply_to(Variable("b"), Variable("c"))
+            ),
+            Variable("2").apply_to(
+                Variable("1").apply_to(Variable("c")), Variable("3")
+            )
+        )
+
+    def test_self_reference(self) -> None:
+        """test handling of self references"""
+        self.aliases["a"] = Variable("a").apply_to(Variable("b"))
+        self.assertEqual(
+            self.aliases["a"],
+            Variable("a").apply_to(Variable("b"))
+        )

lambda_repl-1.2.1/tests/test_parsing.py

@@ -0,0 +1,242 @@
+#!/usr/bin/python3
+
+"""Tests for lambda term parsing"""
+
+from unittest import TestCase
+from lambda_calculus.terms import Variable, Abstraction, Application
+from lark import Token
+from lambda_repl import parsing
+
+
+class ParsingTest(TestCase):
+    """Test for the term parser and transformer"""
+
+    transformer: parsing.LambdaTransformer
+
+    def setUp(self) -> None:
+        """create a transformer"""
+        self.transformer = parsing.LambdaTransformer()
+
+    def test_example(self) -> None:
+        """test lambda_calculus example"""
+        x = Variable("x")
+        y = Variable("y")
+        term = Variable("+") \
+            .apply_to(x, y) \
+            .abstract("x", "y") \
+            .apply_to(y, Variable("3")) \
+            .abstract("y") \
+            .apply_to(Variable("4"))
+        self.assertEqual(
+            self.transformer.transform_string("(λy.(λx.(λy. + x y)) y 3) 4"),
+            term
+        )
+
+    def test_whitespace(self) -> None:
+        """test allowed whitespace"""
+        self.assertEqual(
+            self.transformer.transform_string("a      \t  b"),
+            Application(Variable("a"), Variable("b"))
+        )
+        self.assertEqual(
+            self.transformer.transform_string("λ   a    \t. \t    b"),
+            Abstraction("a", Variable("b"))
+        )
+        self.assertEqual(
+            self.transformer.transform_string("a (   λ  a  . b ) c"),
+            Application.with_arguments(
+                Variable("a"),
+                (Abstraction("a", Variable("b")), Variable("c"))
+            )
+        )
+
+    def test_variables(self) -> None:
+        """test valid variable names"""
+        for name in ("x", "1", "1x", "hi!", "ähm-hi?"):
+            self.assertEqual(
+                self.transformer.transform_string(f"λ{name}.{name}"),
+                Abstraction(name, Variable(name))
+            )
+
+    def test_application(self) -> None:
+        """test application order"""
+        self.assertEqual(
+            self.transformer.transform_string("a b c"),
+            Variable("a").apply_to(Variable("b"), Variable("c"))
+        )
+
+    def test_abstraction(self) -> None:
+        """test abstraction parsing"""
+        self.assertEqual(
+            self.transformer.transform_string("λa.λb.a b c"),
+            Variable("a")
+                .apply_to(Variable("b"), Variable("c"))
+                .abstract("a", "b")
+        )
+        self.assertEqual(
+            self.transformer.transform_string("a λa.a b c"),
+            Variable("a").apply_to(Variable("a").apply_to(Variable("b"), Variable("c")).abstract("a"))
+        )
+
+    def test_brackets(self) -> None:
+        """test bracket parsing"""
+        self.assertEqual(
+            self.transformer.transform_string("(a)"),
+            Variable("a")
+        )
+        self.assertEqual(
+            self.transformer.transform_string("(a b) (c d)"),
+            Application(
+                Application(
+                    Variable("a"),
+                    Variable("b")
+                ),
+                Application(
+                    Variable("c"),
+                    Variable("d")
+                )
+            )
+        )
+        self.assertEqual(
+            self.transformer.transform_string("λa.(λb.a) b c"),
+            Abstraction("b", Variable("a"))
+                .apply_to(Variable("b"), Variable("c"))
+                .abstract("a")
+        )
+        self.assertEqual(
+            self.transformer.transform_string("(λa.a) λb.b"),
+            Application(
+                Abstraction("a", Variable("a")),
+                Abstraction("b", Variable("b"))
+            )
+        )
+
+    def test_backslash(self) -> None:
+        """test lambda alternative"""
+        self.assertEqual(
+            self.transformer.transform_string(r"\a.a"),
+            Abstraction("a", Variable("a"))
+        )
+
+
+class PostLexTest(TestCase):
+    """Tests for WhitespacePostLex"""
+
+    postlex: parsing.WhitespacePostLex
+
+    def setUp(self) -> None:
+        """create a PostLex"""
+        self.postlex = parsing.WhitespacePostLex()
+
+    def test_no_whitespace(self) -> None:
+        """test handling of tokens other than whitespace"""
+        tokens = (
+            Token("BACKLASH", "\\"),
+            Token("VARIABLE", "a"),
+            Token("DOT", "."),
+            Token("LPAR", "("),
+            Token("VARIABLE", "a"),
+            Token("RPAR", ")")
+        )
+        self.assertEqual(
+            tuple(self.postlex.process(iter(tokens))),
+            tokens
+        )
+
+    def test_abstraction_unnecessary(self) -> None:
+        """test handling of unnecessary whitespace in abstractions"""
+        tokens = (
+            Token("BACKLASH", "λ"),
+            Token("_WHITESPACE", " "),
+            Token("VARIABLE", "a"),
+            Token("_WHITESPACE", "\t"),
+            Token("DOT", "."),
+            Token("_WHITESPACE", "  "),
+            Token("LPAR", "("),
+            Token("VARIABLE", "a"),
+            Token("RPAR", ")")
+        )
+        self.assertEqual(
+            tuple(self.postlex.process(iter(tokens))),
+            (
+                Token("BACKLASH", "λ"),
+                Token("VARIABLE", "a"),
+                Token("DOT", "."),
+                Token("LPAR", "("),
+                Token("VARIABLE", "a"),
+                Token("RPAR", ")")
+            )
+        )
+
+    def test_backslash_unnecessary(self) -> None:
+        """test handling of unnecessary whitespace in abstractions with a backslash"""
+        tokens = (
+            Token("BACKLASH", "\\"),
+            Token("_WHITESPACE", " "),
+            Token("VARIABLE", "a"),
+            Token("_WHITESPACE", "\t"),
+            Token("DOT", "."),
+            Token("_WHITESPACE", "  "),
+            Token("LPAR", "("),
+            Token("VARIABLE", "a"),
+            Token("RPAR", ")")
+        )
+        self.assertEqual(
+            tuple(self.postlex.process(iter(tokens))),
+            (
+                Token("BACKLASH", "\\"),
+                Token("VARIABLE", "a"),
+                Token("DOT", "."),
+                Token("LPAR", "("),
+                Token("VARIABLE", "a"),
+                Token("RPAR", ")")
+            )
+        )
+
+    def test_brackets_unnecessary(self) -> None:
+        """test handling of unnecessary whitespace in brackets"""
+        tokens = (
+            Token("BACKLASH", "\\"),
+            Token("VARIABLE", "a"),
+            Token("DOT", "."),
+            Token("LPAR", "("),
+            Token("_WHITESPACE", "\t"),
+            Token("VARIABLE", "a"),
+            Token("_WHITESPACE", "  "),
+            Token("RPAR", ")")
+        )
+        self.assertEqual(
+            tuple(self.postlex.process(iter(tokens))),
+            (
+                Token("BACKLASH", "\\"),
+                Token("VARIABLE", "a"),
+                Token("DOT", "."),
+                Token("LPAR", "("),
+                Token("VARIABLE", "a"),
+                Token("RPAR", ")")
+            )
+        )
+
+    def test_ends_unnecessary(self) -> None:
+        """test handling of unnecessary whitespace at the start and end"""
+        tokens = (
+            Token("_WHITESPACE", "\t"),
+            Token("VARIABLE", "a"),
+            Token("_WHITESPACE", " ")
+        )
+        self.assertEqual(
+            tuple(self.postlex.process(iter(tokens))),
+            (tokens[1],)
+        )
+
+    def test_necessary(self) -> None:
+        """test handling of necessary whitespace"""
+        tokens = (
+            Token("VARIABLE", "a"),
+            Token("_WHITESPACE", "\t"),
+            Token("VARIABLE", "a")
+        )
+        self.assertEqual(
+            tuple(self.postlex.process(iter(tokens))),
+            tokens
+        )

lambda_repl-1.2.1/tests/test_repl.py

@@ -0,0 +1,176 @@
+#!/usr/bin/python3
+
+"""Tests for the REPL"""
+
+from io import StringIO
+from unittest import TestCase
+from lambda_calculus.terms import Variable
+from lambda_calculus.terms.arithmetic import SUCCESSOR
+from lambda_calculus.visitors.substitution.renaming import CountingSubstitution
+from lambda_calculus.visitors.normalisation import BetaNormalisingVisitor
+from lambda_repl import LambdaREPL
+from lambda_repl.aliases import LetAliases
+from lambda_repl.parsing import LambdaTransformer
+
+
+class REPLTest(TestCase):
+    """Test for the REPL"""
+
+    repl: LambdaREPL
+
+    stdin: StringIO
+
+    stdout: StringIO
+
+    def setUp(self) -> None:
+        """create a REPL"""
+        self.stdin = StringIO()
+        self.stdout = StringIO()
+        self.repl = LambdaREPL(
+            LetAliases(CountingSubstitution),
+            LambdaTransformer(),
+            BetaNormalisingVisitor(),
+            stdin=self.stdin,
+            stdout=self.stdout
+        )
+        self.repl.use_rawinput = False
+
+    def test_empty(self) -> None:
+        """test handling of empty lines"""
+        self.assertFalse(self.repl.onecmd(""))
+        self.assertEqual(self.stdout.getvalue(), "")
+
+    def test_evaluate(self) -> None:
+        """test evaluating terms"""
+        self.assertFalse(self.repl.onecmd(r"evaluate (\x.\y.x) a b"))
+        self.assertEqual(
+            self.stdout.getvalue(),
+            "a\n"
+        )
+
+    def test_eval(self) -> None:
+        """test eval alias"""
+        self.assertFalse(self.repl.onecmd(r"eval (\x.\y.x) a b"))
+        self.assertEqual(
+            self.stdout.getvalue(),
+            "a\n"
+        )
+
+    def test_trace(self) -> None:
+        """test tracing term evaluation"""
+        self.assertFalse(self.repl.onecmd(r"trace (\x.\y.x) a b"))
+        self.assertEqual(
+            self.stdout.getvalue(),
+            "β ((λy.a) b)\nβ a\n"
+        )
+
+    def test_syntax_error(self) -> None:
+        """test handling of syntax errors while parsing"""
+        self.assertFalse(self.repl.onecmd(r"eval (\x.\y.x) a b."))
+        self.assertTrue(self.stdout.getvalue().startswith("Error while parsing: "))
+        self.assertTrue(self.stdout.getvalue().endswith("\n"))
+
+    def test_alias(self) -> None:
+        """test setting aliases"""
+        self.assertFalse(self.repl.onecmd("alias a = b c"))
+        self.assertEqual(
+            self.repl.aliases,
+            {
+                "a": Variable("b").apply_to(Variable("c"))
+            }
+        )
+
+    def test_invalid_alias(self) -> None:
+        """test handling invalid aliases"""
+        self.assertFalse(self.repl.onecmd("alias a = b c."))
+        self.assertEqual(self.repl.aliases, {})
+        self.assertTrue(self.stdout.getvalue().startswith("Error while parsing: "))
+        self.assertTrue(self.stdout.getvalue().endswith("\n"))
+
+    def test_no_alias_value(self) -> None:
+        """test handling missing alias values"""
+        self.assertFalse(self.repl.onecmd("alias a"))
+        self.assertEqual(self.repl.aliases, {})
+        self.assertTrue(self.stdout.getvalue().startswith("invalid Command: "))
+        self.assertTrue(self.stdout.getvalue().endswith("\n"))
+
+    def test_import(self) -> None:
+        """test importing aliases"""
+        self.assertFalse(self.repl.onecmd(
+            "import SUCC = lambda_calculus.terms.arithmetic.SUCCESSOR"
+        ))
+        self.assertEqual(
+            self.repl.aliases,
+            {
+                "SUCC": SUCCESSOR
+            }
+        )
+
+    def test_invalid_import(self) -> None:
+        """test handling of invalid imports"""
+        for location in (
+            "lambda_calculus.terms.arithmetic.SUCCESSORX",
+            "lambda_calculus.terms.arithmeticX.SUCCESSOR"
+        ):
+            self.assertFalse(self.repl.onecmd(f"import SUCC = {location}"))
+            self.assertEqual(self.repl.aliases, {})
+            self.assertTrue(self.stdout.getvalue().startswith("Error while importing: "))
+            self.assertTrue(self.stdout.getvalue().endswith("\n"))
+            self.stdout.seek(0)
+            self.stdout.truncate(0)
+        self.assertFalse(self.repl.onecmd("import SUCC = lambda_calculus.terms.arithmetic.number"))
+        self.assertEqual(self.repl.aliases, {})
+        self.assertTrue(self.stdout.getvalue().startswith("Error"))
+        self.assertTrue(self.stdout.getvalue().endswith("\n"))
+
+    def test_no_import_value(self) -> None:
+        """test handling missing import values"""
+        self.assertFalse(self.repl.onecmd("import a"))
+        self.assertEqual(self.repl.aliases, {})
+        self.assertTrue(self.stdout.getvalue().startswith("invalid Command: "))
+        self.assertTrue(self.stdout.getvalue().endswith("\n"))
+
+    def test_aliases(self) -> None:
+        """test listing aliases"""
+        self.assertFalse(self.repl.onecmd("alias x = 1"))
+        self.assertFalse(self.repl.onecmd("alias a = x b"))
+        self.assertFalse(self.repl.onecmd("alias b = b c"))
+        self.assertFalse(self.repl.onecmd("aliases"))
+        self.assertEqual(
+            self.stdout.getvalue(),
+            "x = 1\na = (1 b)\nb = (b c)\n"
+        )
+
+    def test_clear(self) -> None:
+        """test clearing aliases"""
+        self.assertFalse(self.repl.onecmd("alias x = 1"))
+        self.assertFalse(self.repl.onecmd("alias a = x b"))
+        self.assertFalse(self.repl.onecmd("alias b = b c"))
+        self.assertFalse(self.repl.onecmd("clear x"))
+        self.assertEqual(
+            self.repl.aliases,
+            {
+                "a": Variable("1").apply_to(Variable("b")),
+                "b": Variable("b").apply_to(Variable("c"))
+            }
+        )
+        self.assertEqual(self.stdout.getvalue(), "")
+
+    def test_clear_all(self) -> None:
+        """test clearing all aliases"""
+        self.assertFalse(self.repl.onecmd("alias x = 1"))
+        self.assertFalse(self.repl.onecmd("alias a = x b"))
+        self.assertFalse(self.repl.onecmd("alias b = b c"))
+        self.assertFalse(self.repl.onecmd("clear"))
+        self.assertEqual(self.repl.aliases, {})
+        self.assertEqual(self.stdout.getvalue(), "")
+
+    def test_exit(self) -> None:
+        """test exiting the REPL"""
+        self.assertTrue(self.repl.onecmd("exit"))
+        self.assertTrue(self.stdout.getvalue().startswith("Exiting "))
+
+    def test_eof(self) -> None:
+        """test handling EOF"""
+        self.assertTrue(self.repl.onecmd("EOF"))
+        self.assertTrue(self.stdout.getvalue().startswith("Exiting "))

lambda_repl-1.1.0/lambda_repl/grammar.lark

@@ -1,11 +0,0 @@
-_WHITESPACE: /\s+/
-
-VARIABLE: /[^\s().λ\\]+/
-
-abstraction: ("\\" | "λ") VARIABLE "." term
-
-application: ( abstraction | VARIABLE | brackets ) ( _WHITESPACE ( abstraction | VARIABLE | brackets ) )+
-
-?brackets: "(" term ")"
-
-?term: abstraction | application | VARIABLE | brackets

lambda_repl-1.1.0/lambda_repl.egg-info/PKG-INFO

@@ -1,53 +0,0 @@
-Metadata-Version: 2.1
-Name: lambda-repl
-Version: 1.1.0
-Summary: REPL for the lambda calculus
-Author-email: Eric Niklas Wolf <eric_niklas.wolf@mailbox.tu-dresden.de>
-Project-URL: Repository, https://github.com/Deric-W/lambda_repl
-Project-URL: Bugtracker, https://github.com/Deric-W/lambda_repl/issues
-Classifier: Intended Audience :: Education
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Topic :: Education
-Classifier: Topic :: Utilities
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# lambda_repl
-
-![Tests](https://github.com/Deric-W/lambda_repl/actions/workflows/Tests.yaml/badge.svg)
-[![codecov](https://codecov.io/gh/Deric-W/lambda_repl/branch/main/graph/badge.svg?token=SU3982mC17)](https://codecov.io/gh/Deric-W/lambda_repl)
-
-The `lambda_repl` package contains a [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) for the [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus).
-
-To use it, execute `lambda-repl` or `python3 -m lambda_repl` and enter commands.
-
-## Requirements
-
-Python >= 3.10 and the `lambda_calculus` package are required to use this package.
-
-## Installation
-
-```sh
-python3 -m pip install lambda-repl
-```
-
-## Examples
-
-```
-python3 -m lambda_repl
-Welcome to the the Lambda REPL, type 'help' for help
-λ alias I = \x.x
-λ alias K = λx.λy.x
-λ aliases
-I = (λx.x)
-K = (λx.(λy.x))
-λ trace K a b
-β ((λy.a) b)
-β a
-λ exit
-Exiting REPL...
-```

lambda_repl-1.1.0/lambda_repl.egg-info/SOURCES.txt

@@ -1,16 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-lambda_repl/__init__.py
-lambda_repl/__main__.py
-lambda_repl/aliases.py
-lambda_repl/grammar.lark
-lambda_repl/main.py
-lambda_repl/parsing.py
-lambda_repl/py.typed
-lambda_repl.egg-info/PKG-INFO
-lambda_repl.egg-info/SOURCES.txt
-lambda_repl.egg-info/dependency_links.txt
-lambda_repl.egg-info/entry_points.txt
-lambda_repl.egg-info/requires.txt
-lambda_repl.egg-info/top_level.txt

lambda_repl-1.1.0/lambda_repl.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

lambda_repl-1.1.0/lambda_repl.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-lambda-repl = lambda_repl.main:main_cli

lambda_repl-1.1.0/lambda_repl.egg-info/requires.txt

@@ -1,2 +0,0 @@
-lambda-calculus~=2.0
-lark~=1.0

lambda_repl-1.1.0/lambda_repl.egg-info/top_level.txt

@@ -1 +0,0 @@
-lambda_repl

lambda_repl-1.1.0/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-