Add ~ operator for simple inline null coalescing

Author: Jamie-Chang

better_functools/apply.py

@@ -2,7 +2,6 @@
 
 from dataclasses import dataclass
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     Concatenate,
@@ -36,27 +35,35 @@
 Ts = TypeVarTuple("Ts")
 
 
-class apply(Generic[T_APPLY]):
+class apply(Generic[T, R]):
     """Make a function callable by using `@` operator.
 
     This is the `@` version of `... | fn` in `better_functools.pipe.Composition`.
 
     >>> "1234" @ apply(int)
     1234
+
+    prepending with `~` will return the null coalescing version.
+
+    >>> None @ ~apply(int) is None
+    True
     """
 
-    def __init__(self, fn: T_APPLY) -> None:
+    def __init__(self, fn: Callable[[T], R]) -> None:
         self.fn = fn
 
-    if TYPE_CHECKING:
-        __call__: T_APPLY
-        __rmatmul__: T_APPLY
-    else:
+    def __call__(self, val: T) -> R:
+        return self.fn(val)
 
-        def __call__(self, *args, **kwargs):
-            return self.fn(*args, **kwargs)
+    __rmatmul__ = __call__
 
-        __rmatmul__ = __call__
+    def __invert__(self) -> apply[T | None, R | None]:
+        def _fn(v: T | None) -> R | None:
+            if v is None:
+                return None
+            return self.fn(v)
+
+        return apply(_fn)
 
 
 @dataclass
@@ -235,7 +242,7 @@ def __rmatmul__(self, left: T | None) -> T | Self:
 """
 
 
-def static(fn: Callable[Concatenate[T, P], R]) -> Callable[P, apply[Callable[[T], R]]]:
+def static(fn: Callable[Concatenate[T, P], R]) -> Callable[P, apply[T, R]]:
     """*Experimental*: Make a bound method static.
 
     This makes it easier to chain the method.
@@ -259,7 +266,7 @@ def static(fn: Callable[Concatenate[T, P], R]) -> Callable[P, apply[Callable[[T]
     - Does not work well with MyPy.
     """
 
-    def _outer(*args: P.args, **kwargs: P.kwargs) -> apply[Callable[[T], R]]:
+    def _outer(*args: P.args, **kwargs: P.kwargs) -> apply[T, R]:
         @apply
         def _inner(first: T) -> R:
             return fn(first, *args, **kwargs)

tests/test_apply.py

@@ -33,6 +33,8 @@ def fetch(v: int, return_none: bool) -> int | None:
         (lambda: assert_type(mod @ star_args @ invoke((3, 2)), int), 1),
         (lambda: assert_type(add @ compose(mul @ bind(2)) @ invoke(1, 2), int), 6),
         (lambda: assert_type({"id": 1234} @ static(dict[str, int].get)("id"), int | None), 1234),
+        (lambda: assert_type({"a": 1}.get("b") @ ~apply(add @ bind(1)), int | None), None),
+        (lambda: assert_type({"a": 1}.get("a") @ ~apply(add @ bind(1)), int | None), 2),
     ],
 )
 def test_expressions(expression: Callable[[], Any], expected: Any) -> None: