lambda-calculus 3.1.0__py3-none-any.whl → 3.1.2__py3-none-any.whl

lambda_calculus/__init__.py

@@ -1,17 +1,8 @@
-#!/usr/bin/python3
-
 """Implementation of the Lambda calculus"""
 
-from .terms import Variable, Abstraction, Application
+from ._version import version as __version__  # noqa: F401
+from .terms import Abstraction, Application, Variable
 
-__version__ = "3.1.0"
-__author__  = "Eric Niklas Wolf"
-__email__   = "eric_niklas.wolf@mailbox.tu-dresden.de"
-__all__ = (
-    "Variable",
-    "Abstraction",
-    "Application",
-    "terms",
-    "visitors",
-    "errors"
-)
+__author__ = "Eric Niklas Wolf"
+__email__ = "eric_niklas.wolf@mailbox.tu-dresden.de"
+__all__ = ("Abstraction", "Application", "Variable", "errors", "terms", "visitors")

lambda_calculus/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '3.1.2'
+__version_tuple__ = version_tuple = (3, 1, 2)
+
+__commit_id__ = commit_id = None

lambda_calculus/errors.py

@@ -1,14 +1,11 @@
-#!/usr/bin/python3
-
 """Errors raised by Term operations"""
 
 from __future__ import annotations
+
 from collections.abc import Collection
-from typing import TypeVar, Generic
+from typing import Generic, TypeVar
 
-__all__ = (
-    "CollisionError",
-)
+__all__ = ("CollisionError",)
 
 V = TypeVar("V")
 

lambda_calculus/terms/__init__.py

@@ -1,27 +1,27 @@
-#!/usr/bin/python3
-
 """Lambda Terms"""
 
 from __future__ import annotations
+
 from abc import abstractmethod
-from collections.abc import Sequence, Set, Iterable, Iterator
+from collections.abc import Iterable, Iterator, Sequence
+from collections.abc import Set as AbstractSet
 from dataclasses import dataclass
-from typing import TypeVar, final
-from .. import visitors
+from typing import Self, TypeVar, final
+
 from ..errors import CollisionError
-from ..visitors import walking
+from ..visitors import Visitor, walking
 from ..visitors.substitution import checked
 
 __all__ = (
-    "Term",
-    "Variable",
     "Abstraction",
     "Application",
+    "Term",
+    "Variable",
     "abc",
     "arithmetic",
+    "combinators",
     "logic",
     "pairs",
-    "combinators"
 )
 
 T = TypeVar("T")
@@ -52,25 +52,25 @@ class Term(Iterable["Term[V]"]):
 
         :return: lambda term string
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @abstractmethod
-    def free_variables(self) -> Set[V]:
+    def free_variables(self) -> AbstractSet[V]:
         """
         Calculate the free variables of this Term.
 
         :return: variables not bound by an abstraction
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @abstractmethod
-    def bound_variables(self) -> Set[V]:
+    def bound_variables(self) -> AbstractSet[V]:
         """
         Calculate the bound variables of this Term.
 
         :return: variables bound by an abstraction
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @abstractmethod
     def is_beta_normal_form(self) -> bool:
@@ -79,17 +79,17 @@ class Term(Iterable["Term[V]"]):
 
         :return: if no beta reductions can be performed
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @abstractmethod
-    def accept(self, visitor: visitors.Visitor[T, V]) -> T:
+    def accept(self, visitor: Visitor[T, V]) -> T:
         """
         Accept a visitor by calling his corresponding method.
 
         :param visitor: Visitor to accept
         :return: value returned by the visitors corresponding method
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def abstract(self, *variables: V) -> Abstraction[V]:
         """
@@ -141,7 +141,7 @@ class Variable(Term[V]):
     name: V
 
     @classmethod
-    def with_valid_name(cls, name: V) -> Variable[V]:
+    def with_valid_name(cls, name: V) -> Self:
         """
         Create an instance with a valid name.
 
@@ -151,10 +151,12 @@ class Variable(Term[V]):
         """
         string = str(name)
         if not string:
-            raise ValueError("empty string representation")
+            msg = "empty string representation"
+            raise ValueError(msg)
         for character in string:
             if character in "().λ" or character.isspace():
-                raise ValueError(f"invalid character: '{character}'")
+                msg = f"invalid character: '{character}'"
+                raise ValueError(msg)
         return cls(name)
 
     def __str__(self) -> str:
@@ -165,7 +167,7 @@ class Variable(Term[V]):
         """
         return str(self.name)
 
-    def free_variables(self) -> Set[V]:
+    def free_variables(self) -> AbstractSet[V]:
         """
         Calculate the free variables of this Term.
 
@@ -173,7 +175,7 @@ class Variable(Term[V]):
         """
         return {self.name}
 
-    def bound_variables(self) -> Set[V]:
+    def bound_variables(self) -> AbstractSet[V]:
         """
         Calculate the bound variables of this Term.
 
@@ -189,7 +191,7 @@ class Variable(Term[V]):
         """
         return True
 
-    def accept(self, visitor: visitors.Visitor[T, V]) -> T:
+    def accept(self, visitor: Visitor[T, V]) -> T:
         """
         Accept a visitor by calling visitors.Visitor.visit_variable.
 
@@ -214,7 +216,7 @@ class Abstraction(Term[V]):
     body: Term[V]
 
     @classmethod
-    def curried(cls, variables: Sequence[V], body: Term[V]) -> Abstraction[V]:
+    def curried(cls, variables: Sequence[V], body: Term[V]) -> Self:
         """
         Create an Abstraction binding multiple variables.
 
@@ -230,7 +232,8 @@ class Abstraction(Term[V]):
                     term = cls(variable, term)
                 return term
             case _:
-                raise ValueError("no variables to bind")
+                msg = "no variables to bind"
+                raise ValueError(msg)
 
     def __str__(self) -> str:
         """
@@ -240,7 +243,7 @@ class Abstraction(Term[V]):
         """
         return f"(λ{self.bound}.{self.body})"
 
-    def free_variables(self) -> Set[V]:
+    def free_variables(self) -> AbstractSet[V]:
         """
         Calculate the free variables of this Term.
 
@@ -248,7 +251,7 @@ class Abstraction(Term[V]):
         """
         return self.body.free_variables() - {self.bound}
 
-    def bound_variables(self) -> Set[V]:
+    def bound_variables(self) -> AbstractSet[V]:
         """
         Calculate the free variables of this Term.
 
@@ -274,12 +277,10 @@ class Abstraction(Term[V]):
         """
         if new == self.bound:
             return self
-        elif new not in self.body.free_variables():
-            return Abstraction(
-                new,
-                self.body.substitute(self.bound, Variable(new))
-            )
-        raise CollisionError("new variable would bind free variable in body", (new,))
+        if new not in self.body.free_variables():
+            return Abstraction(new, self.body.substitute(self.bound, Variable(new)))
+        msg = "new variable would bind free variable in body"
+        raise CollisionError(msg, (new,))
 
     def eta_reduction(self) -> Term[V]:
         """
@@ -292,9 +293,10 @@ class Abstraction(Term[V]):
             case Application(f, Variable(x)) if x == self.bound and x not in f.free_variables():
                 return f
             case _:
-                raise ValueError("abstraction is not useless")
+                msg = "abstraction is not useless"
+                raise ValueError(msg)
 
-    def accept(self, visitor: visitors.Visitor[T, V]) -> T:
+    def accept(self, visitor: Visitor[T, V]) -> T:
         """
         Accept a visitor by calling visitors.Visitor.visit_abstraction.
 
@@ -312,8 +314,7 @@ class Abstraction(Term[V]):
         :return: new term
         """
         return Abstraction(
-            self.bound if bound is None else bound,
-            self.body if body is None else body
+            self.bound if bound is None else bound, self.body if body is None else body
         )
 
 
@@ -332,7 +333,7 @@ class Application(Term[V]):
     argument: Term[V]
 
     @classmethod
-    def with_arguments(cls, abstraction: Term[V], arguments: Sequence[Term[V]]) -> Application[V]:
+    def with_arguments(cls, abstraction: Term[V], arguments: Sequence[Term[V]]) -> Self:
         """
         Create an Application applying the abstraction to multiple arguments.
 
@@ -348,7 +349,8 @@ class Application(Term[V]):
                     term = cls(term, argument)
                 return term
             case _:
-                raise ValueError("no arguments to apply abstraction to")
+                msg = "no arguments to apply abstraction to"
+                raise ValueError(msg)
 
     def __str__(self) -> str:
         """
@@ -358,7 +360,7 @@ class Application(Term[V]):
         """
         return f"({self.abstraction} {self.argument})"
 
-    def free_variables(self) -> Set[V]:
+    def free_variables(self) -> AbstractSet[V]:
         """
         Calculate the free variables of this Term.
 
@@ -366,7 +368,7 @@ class Application(Term[V]):
         """
         return self.abstraction.free_variables() | self.argument.free_variables()
 
-    def bound_variables(self) -> Set[V]:
+    def bound_variables(self) -> AbstractSet[V]:
         """
         Calculate the free variables of this Term.
 
@@ -388,9 +390,11 @@ class Application(Term[V]):
 
         :return: if no beta reductions can be performed
         """
-        return not self.is_redex() \
-            and self.abstraction.is_beta_normal_form() \
+        return (
+            not self.is_redex()
+            and self.abstraction.is_beta_normal_form()
             and self.argument.is_beta_normal_form()
+        )
 
     def beta_reduction(self) -> Term[V]:
         """
@@ -403,9 +407,10 @@ class Application(Term[V]):
             case Abstraction(bound, body):
                 return body.substitute(bound, self.argument)
             case _:
-                raise ValueError("can not perform reduction without known Abstraction")
+                msg = "can not perform reduction without known Abstraction"
+                raise ValueError(msg)
 
-    def accept(self, visitor: visitors.Visitor[T, V]) -> T:
+    def accept(self, visitor: Visitor[T, V]) -> T:
         """
         Accept a visitor by calling visitors.Visitor.visit_application.
 
@@ -414,7 +419,9 @@ class Application(Term[V]):
         """
         return visitor.visit_application(self)
 
-    def replace(self, *, abstraction: Term[V] | None = None, argument: Term[V] | None = None) -> Application[V]:
+    def replace(
+        self, *, abstraction: Term[V] | None = None, argument: Term[V] | None = None
+    ) -> Application[V]:
         """
         Return a copy with specific attributes replaced.
 
@@ -424,5 +431,5 @@ class Application(Term[V]):
         """
         return Application(
             self.abstraction if abstraction is None else abstraction,
-            self.argument if argument is None else argument
+            self.argument if argument is None else argument,
         )

lambda_calculus/terms/abc.py

@@ -1,13 +1,13 @@
-#!/usr/bin/python3
-
 """Predefined Variables for all ASCII letters"""
 
 from string import ascii_letters
+
 from . import Variable
 
 __all__ = tuple(ascii_letters)
 
 # better IDE autocompletion
+# ruff: noqa: E741
 a, b, c, d, e, f, g, h, i, j = map(Variable, "abcdefghij")
 k, l, m, n, o, p, q, r, s, t = map(Variable, "klmnopqrst")
 u, v, w, x, y, z = map(Variable, "uvwxyz")

lambda_calculus/terms/arithmetic.py

@@ -1,21 +1,11 @@
-#!/usr/bin/python3
-
 """Implementations of natural numbers and arithmetic operators"""
 
 from typing import Final
-from . import Term, Variable, Abstraction, Application
-from .logic import TRUE, FALSE
 
-__all__ = (
-    "ISZERO",
-    "SUCCESSOR",
-    "PREDECESSOR",
-    "ADD",
-    "SUBTRACT",
-    "MULTIPLY",
-    "POWER",
-    "number"
-)
+from . import Abstraction, Application, Term, Variable
+from .logic import FALSE, TRUE
+
+__all__ = ("ADD", "ISZERO", "MULTIPLY", "POWER", "PREDECESSOR", "SUBTRACT", "SUCCESSOR", "number")
 
 ISZERO: Final = Variable("n").apply_to(FALSE.abstract("x"), TRUE).abstract("n")
 """
@@ -26,12 +16,8 @@ if its argument is zero, :const:`lambda_calculus.terms.logic.FALSE` otherwise
 SUCCESSOR: Final = Abstraction.curried(
     ("n", "f", "x"),
     Application(
-        Variable("f"),
-        Application.with_arguments(
-            Variable("n"),
-            (Variable("f"), Variable("x"))
-        )
-    )
+        Variable("f"), Application.with_arguments(Variable("n"), (Variable("f"), Variable("x")))
+    ),
 )
 """
 Term evaluating to its argument incremented by one.
@@ -43,19 +29,12 @@ PREDECESSOR: Final = Abstraction.curried(
         Variable("n"),
         (
             Abstraction.curried(
-                ("g", "h"),
-                Application(
-                    Variable("h"),
-                    Application(
-                        Variable("g"),
-                        Variable("f")
-                    )
-                )
+                ("g", "h"), Application(Variable("h"), Application(Variable("g"), Variable("f")))
             ),
             Abstraction("u", Variable("x")),
             Abstraction("u", Variable("u")),
-        )
-    )
+        ),
+    ),
 )
 """
 Term ealuating to its argument decremented by one.
@@ -65,51 +44,28 @@ ADD: Final = Abstraction.curried(
     ("m", "n", "f", "x"),
     Application.with_arguments(
         Variable("m"),
-        (
-            Variable("f"),
-            Application.with_arguments(
-                Variable("n"),
-                (Variable("f"), Variable("x"))
-            )
-        )
-    )
+        (Variable("f"), Application.with_arguments(Variable("n"), (Variable("f"), Variable("x")))),
+    ),
 )
 """
 Term evaluating to the sum of its two arguments.
 """
 
 SUBTRACT: Final = Abstraction.curried(
-    ("m", "n"),
-    Application.with_arguments(
-        Variable("n"),
-        (PREDECESSOR, Variable("m"))
-    )
+    ("m", "n"), Application.with_arguments(Variable("n"), (PREDECESSOR, Variable("m")))
 )
 """
 Term evaluating to the difference of its two arguments.
 """
 
 MULTIPLY: Final = Abstraction.curried(
-    ("m", "n", "f"),
-    Application(
-        Variable("m"),
-        Application(
-            Variable("n"),
-            Variable("f")
-        )
-    )
+    ("m", "n", "f"), Application(Variable("m"), Application(Variable("n"), Variable("f")))
 )
 """
 Term evaluating to the product of its two arguments.
 """
 
-POWER: Final = Abstraction.curried(
-    ("b", "e"),
-    Application(
-        Variable("e"),
-        Variable("b")
-    )
-)
+POWER: Final = Abstraction.curried(("b", "e"), Application(Variable("e"), Variable("b")))
 """
 Term evaluating to its first argument to the power of its second argument.
 """
@@ -124,12 +80,10 @@ def number(n: int) -> Abstraction[str]:
     :return: requested term
     """
     if n < 0:
-        raise ValueError("number is not natural")
+        msg = "number is not natural"
+        raise ValueError(msg)
     f = Variable("f")
     body: Term[str] = Variable("x")
     for _ in range(n):
         body = Application(f, body)
-    return Abstraction.curried(
-        ("f", "x"),
-        body
-    )
+    return Abstraction.curried(("f", "x"), body)

lambda_calculus/terms/combinators.py

@@ -1,38 +1,24 @@
-#!/usr/bin/python3
-
 """Common combinators"""
 
 from typing import Final
-from . import Variable, Application
 
-__all__ = (
-    "Y",
-    "S",
-    "K",
-    "I",
-    "B",
-    "C",
-    "W",
-    "DELTA",
-    "OMEGA"
-)
+from . import Application, Variable
+
+__all__ = ("DELTA", "OMEGA", "B", "C", "I", "K", "S", "W", "Y")
 
 Y: Final = Application(
-    Variable("g").apply_to(
-        Variable("x").apply_to(Variable("x"))
-    ).abstract("x"),
-    Variable("g").apply_to(
-        Variable("x").apply_to(Variable("x"))
-    ).abstract("x")
+    Variable("g").apply_to(Variable("x").apply_to(Variable("x"))).abstract("x"),
+    Variable("g").apply_to(Variable("x").apply_to(Variable("x"))).abstract("x"),
 ).abstract("g")
 """
 Y combinator used to define recursive terms.
 """
 
-S: Final = Variable("x").apply_to(
-    Variable("z"),
-    Variable("y").apply_to(Variable("z"))
-).abstract("x", "y", "z")
+S: Final = (
+    Variable("x")
+    .apply_to(Variable("z"), Variable("y").apply_to(Variable("z")))
+    .abstract("x", "y", "z")
+)
 """
 S combinator of the SKI combinator calculus.
 """
@@ -42,37 +28,27 @@ K: Final = Variable("x").abstract("x", "y")
 K combinator of the SKI combinator calculus.
 """
 
-I: Final = Variable("x").abstract("x")
+I: Final = Variable("x").abstract("x")  # noqa: E741
 """
 I combinator of the SKI combinator calculus.
 """
 
-B: Final = Variable("x").apply_to(
-    Variable("y").apply_to(Variable("z"))
-).abstract("x", "y", "z")
+B: Final = Variable("x").apply_to(Variable("y").apply_to(Variable("z"))).abstract("x", "y", "z")
 """
 B combinator of the BCKW combinator calculus.
 """
 
-C: Final = Variable("x").apply_to(
-    Variable("z"),
-    Variable("y")
-).abstract("x", "y", "z")
+C: Final = Variable("x").apply_to(Variable("z"), Variable("y")).abstract("x", "y", "z")
 """
 C combinator of the BCKW combinator calculus.
 """
 
-W: Final = Variable("x").apply_to(
-    Variable("y"),
-    Variable("y")
-).abstract("x", "y")
+W: Final = Variable("x").apply_to(Variable("y"), Variable("y")).abstract("x", "y")
 """
 W combinator of the BCKW combinator calculus.
 """
 
-DELTA: Final = Variable("x").apply_to(
-    Variable("x")
-).abstract("x")
+DELTA: Final = Variable("x").apply_to(Variable("x")).abstract("x")
 """
 Term applying its argument to itself.
 """

lambda_calculus/terms/logic.py

@@ -1,18 +1,10 @@
-#!/usr/bin/python3
-
 """Implementations of boolean values and logical operators"""
 
 from typing import Final
-from . import Variable, Abstraction, Application
-
-__all__ = (
-    "TRUE",
-    "FALSE",
-    "AND",
-    "OR",
-    "NOT",
-    "IF_THEN_ELSE"
-)
+
+from . import Abstraction, Application, Variable
+
+__all__ = ("AND", "FALSE", "IF_THEN_ELSE", "NOT", "OR", "TRUE")
 
 TRUE: Final = Abstraction.curried(("x", "y"), Variable("x"))
 """
@@ -25,16 +17,14 @@ Term representing False
 """
 
 AND: Final = Abstraction.curried(
-    ("p", "q"),
-    Application.with_arguments(Variable("p"), (Variable("q"), Variable("p")))
+    ("p", "q"), Application.with_arguments(Variable("p"), (Variable("q"), Variable("p")))
 )
 """
 Term implementing logical conjunction between its two arguments.
 """
 
 OR: Final = Abstraction.curried(
-    ("p", "q"),
-    Application.with_arguments(Variable("p"), (Variable("p"), Variable("q")))
+    ("p", "q"), Application.with_arguments(Variable("p"), (Variable("p"), Variable("q")))
 )
 """
 Term implementing logical disjunction between its two arguments.
@@ -46,8 +36,7 @@ Term performing logical negation of its argument.
 """
 
 IF_THEN_ELSE: Final = Abstraction.curried(
-    ("p", "a", "b"),
-    Application.with_arguments(Variable("p"), (Variable("a"), Variable("b")))
+    ("p", "a", "b"), Application.with_arguments(Variable("p"), (Variable("a"), Variable("b")))
 )
 """
 Term evaluating to its second argument if its first argument is TRUE