Add ConditionalRule

This looks to capture what people generically mean when saying if-then, rather than an implication

src/consts.py

@@ -27,6 +27,7 @@ AVAILABLE_RULES = [
     "generic.XORRule",
     "generic.XNORRule",
     "generic.ImpliesRule",
+    "generic.ConditionalRule",
     "generic.ResolveAtTime",
     "generic.ResolveToValue",
     "generic.AdditiveRule",

src/market.py

@@ -205,9 +205,8 @@ class Market(DictDeserializable):
 
     def should_resolve(self) -> bool:
         """Return whether the market should resolve, according to our rules."""
-        return any(
-            rule.value(self) for rule in (self.do_resolve_rules or ())
-        ) and not self.market.isResolved
+        futures = [parallel(rule.value, self) for rule in (self.do_resolve_rules or ())]
+        return any(future.result() for future in futures) and not self.market.isResolved
 
     def resolve_to(self) -> AnyResolution:
         """Select a value to be resolved to.

src/rule/generic.py

@@ -106,6 +106,22 @@ class ImpliesRule(BinaryRule[Optional[BinaryResolution]]):
         return not self.rule1._value(market) or bool(self.rule2._value(market))
 
 
+@define(slots=False)
+class ConditionalRule(BinaryRule[BinaryResolution]):
+    """Cancels if the premise is false, and resolve to another value otherwise."""
+
+    _explainer_stub: ClassVar[str] = (
+        "Cancels if the next line resolves False, otherwise resolves to the value of the item after"
+    )
+
+    def _value(self, market: Market) -> BinaryResolution:
+        f_val1 = parallel(self.rule1._value, market)
+        f_val2 = parallel(self.rule2._value, market)
+        if not f_val1.result():
+            return "CANCEL"
+        return f_val2.result()
+
+
 @define(slots=False)
 class ResolveAtTime(DoResolveRule):
     """Return True if the specified time is in the past."""

src/test/rule/test_generic.py

@@ -32,6 +32,7 @@ validators: dict[str, Validator] = {
     "generic.XORRule": (lambda x, y: bool(x) != bool(y)),
     "generic.XNORRule": (lambda x, y: bool(x) == bool(y)),
     "generic.ImpliesRule": (lambda x, y: bool((not x) or y)),
+    "generic.ConditionalRule": (lambda x, y: "CANCEL" if (not x) else bool(y)),
 }
 
 
@@ -62,7 +63,7 @@ def test_binary_rule(binary_rule: str) -> None:
             "rule1": ["generic.ResolveToValue", {"resolve_value": val1}],
             "rule2": ["generic.ResolveToValue", {"resolve_value": val2}]
         })._value(mkt)
-        assert bool(from_dict_val) is expected
+        assert from_dict_val == "CANCEL" or bool(from_dict_val) is expected
 
 
 def test_negate_rule_value() -> None: