add support for _ default key

adt/decorator.py

@@ -123,17 +123,24 @@ def match(self: Any,
         caseNames = _cases.__members__.keys()
         upperKeys = {k: k.upper() for k in kwargs.keys()}
 
+        unmatched = set(caseNames) - set(upperKeys.values())
+        if "_" in upperKeys.values():
+            for key in unmatched:
+                kwargs[key] = kwargs["_"]
+                upperKeys[key] = key
+            del upperKeys["_"]
+            del kwargs["_"]
+        elif unmatched:
+            raise ValueError(
+                f"Incomplete pattern match against {self} (missing {unmatched})"
+            )
+
         for key in upperKeys.values():
             if key not in caseNames:
                 raise ValueError(
                     f'Unrecognized case {key} in pattern match against {self} (expected one of {caseNames})'
                 )
 
-        for key in caseNames:
-            if key not in upperKeys.values():
-                raise ValueError(
-                    f'Incomplete pattern match against {self} (missing {key})')
-
         for key, callback in kwargs.items():
             upperKey = upperKeys[key]
 

tests/test_either.py

@@ -89,3 +89,24 @@ def test_accessorsConsistentWithMatching(self, e: Either[_L, _R]) -> None:
             self.assertEqual(
                 e.left(),
                 e.match(left=lambda x: x, right=helpers.invalidPatternMatch))
+
+    @given(from_type(Either))
+    def test_matching_with_default_key(self, e: Either[_L, _R]) -> None:
+        if e.match(left=lambda _: True, right=lambda _: False):
+            self.assertEqual(
+                e.left(),
+                e.match(right=helpers.invalidPatternMatch, _=lambda x: x))
+            self.assertEqual(
+                e.left(),
+                e.match(_=helpers.invalidPatternMatch, left=lambda x: x))
+        else:
+            self.assertEqual(
+                e.right(),
+                e.match(_=helpers.invalidPatternMatch, right=lambda x: x))
+
+            self.assertEqual(
+                e.right(),
+                e.match(left=helpers.invalidPatternMatch, _=lambda x: x))
+
+        with self.assertRaises(ValueError):
+            e.match(foobar=lambda x: x, _=lambda x: x)  # type: ignore