fix(patterns): fix composing AnyOf and AllOf patterns (#7)

* test: add test for and-ing and or-ing allof/anyof

* fix(patterns): reference the correct attribute in sugar

* chore: split up and/or and add cython casts

* test: check for AnyOf and AllOf unnesting

Co-authored-by: Krisztián Szűcs <szucs.krisztian@gmail.com>

Author: cpcloud

koerce/patterns.py

@@ -279,12 +279,8 @@ def __or__(self, other: Pattern) -> AnyOf:
         -------
         New pattern that matches if either of the patterns match.
         """
-        if isinstance(self, AnyOf) and isinstance(other, AnyOf):
-            return AnyOf(*self.patterns, *other.patterns)
-        elif isinstance(self, AnyOf):
-            return AnyOf(*self.patterns, other)
-        elif isinstance(other, AnyOf):
-            return AnyOf(self, *other.patterns)
+        if isinstance(other, AnyOf):
+            return AnyOf(self, *cython.cast(AnyOf, other).inners)
         else:
             return AnyOf(self, other)
 
@@ -300,12 +296,8 @@ def __and__(self, other: Pattern) -> AllOf:
         -------
         New pattern that matches if both of the patterns match.
         """
-        if isinstance(self, AllOf) and isinstance(other, AllOf):
-            return AllOf(*self.patterns, *other.patterns)
-        elif isinstance(self, AllOf):
-            return AllOf(*self.patterns, other)
-        elif isinstance(other, AllOf):
-            return AllOf(self, *other.patterns)
+        if isinstance(other, AllOf):
+            return AllOf(self, *cython.cast(AllOf, other).inners)
         else:
             return AllOf(self, other)
 
@@ -883,6 +875,23 @@ def match(self, value, ctx: Context):
                 pass
         raise NoMatchError()
 
+    def __or__(self, other: Pattern) -> AnyOf:
+        """Syntax sugar for matching either of the patterns.
+
+        Parameters
+        ----------
+        other
+            The other pattern to match against.
+
+        Returns
+        -------
+        New pattern that matches if either of the patterns match.
+        """
+        if isinstance(other, AnyOf):
+            return AnyOf(*self.inners, *cython.cast(AnyOf, other).inners)
+        else:
+            return AnyOf(*self.inners, other)
+
 
 @cython.final
 @cython.cclass
@@ -905,6 +914,23 @@ def match(self, value, ctx: Context):
             value = inner.match(value, ctx)
         return value
 
+    def __and__(self, other: Pattern) -> AllOf:
+        """Syntax sugar for matching both of the patterns.
+
+        Parameters
+        ----------
+        other
+            The other pattern to match against.
+
+        Returns
+        -------
+        New pattern that matches if both of the patterns match.
+        """
+        if isinstance(other, AllOf):
+            return AllOf(*self.inners, *cython.cast(AllOf, other).inners)
+        else:
+            return AllOf(*self.inners, other)
+
 
 def NoneOf(*args) -> Pattern:
     """Match none of the passed patterns."""

koerce/tests/test_patterns.py

@@ -440,6 +440,24 @@ def test_any_of():
     # assert p.describe() == "an int, a str or a float"
 
 
+def test_any_all_of_operator_overloading():
+    is_int = InstanceOf(int)
+    is_str = InstanceOf(str)
+    is_float = InstanceOf(float)
+
+    assert (is_int | is_str) == AnyOf(is_int, is_str)
+    assert (is_int & is_str) == AllOf(is_int, is_str)
+    assert (is_int & is_str & is_float) == AllOf(is_int, is_str, is_float)
+    assert (is_int | is_str | is_float) == AnyOf(is_int, is_str, is_float)
+    assert (is_int | is_str & is_float) == AnyOf(is_int, AllOf(is_str, is_float))
+    assert ((is_int | is_str) | (is_float | is_int)) == AnyOf(
+        is_int, is_str, is_float, is_int
+    )
+    assert ((is_int & is_str) & (is_float & is_int)) == AllOf(
+        is_int, is_str, is_float, is_int
+    )
+
+
 def test_all_of():
     def negative(_):
         return _ < 0
@@ -1117,6 +1135,12 @@ def test_pattern_sequence_with_nested_some_of():
             {"a": 1, "b": 2},
             {"a": 1, "b": 2},
         ),
+        (AnyOf(InstanceOf(str)) | InstanceOf(int), 7, 7),
+        (AllOf(InstanceOf(int)) & InstanceOf(int), 7, 7),
+        (InstanceOf(int) | AnyOf(InstanceOf(str)), 7, 7),
+        (InstanceOf(int) & AllOf(InstanceOf(int)), 7, 7),
+        (AnyOf(InstanceOf(str)) | AnyOf(InstanceOf(int)), 7, 7),
+        (AllOf(InstanceOf(int)) & AllOf(InstanceOf(int)), 7, 7),
     ],
 )
 def test_various_patterns(pattern, value, expected):
@@ -1451,7 +1475,9 @@ class OtherClass(metaclass=OtherMeta): ...
     my_other_instance = OtherClass()
 
     assert InstanceOf(Class).apply(my_instance, context={}) == my_instance
-    assert InstanceOf(OtherClass).apply(my_other_instance, context={}) == my_other_instance
+    assert (
+        InstanceOf(OtherClass).apply(my_other_instance, context={}) == my_other_instance
+    )
 
     assert InstanceOf(Class).apply(my_other_instance, context={}) == NoMatch
     assert InstanceOf(OtherClass).apply(my_instance, context={}) == NoMatch