Fix mypy type handling in partial function and add regression tests

Author: AdrianAcala

docs/conf.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python
 # Configuration file for the Sphinx documentation builder.
 #
 # This file does only contain a selection of the most common options. For a

returns/contrib/mypy/_features/partial.py

@@ -5,11 +5,13 @@
 from mypy.nodes import ARG_STAR, ARG_STAR2
 from mypy.plugin import FunctionContext
 from mypy.types import (
+    AnyType,
     CallableType,
     FunctionLike,
     Instance,
     Overloaded,
     ProperType,
+    TypeOfAny,
     TypeType,
     get_proper_type,
 )
@@ -51,30 +53,55 @@ def analyze(ctx: FunctionContext) -> ProperType:
     default_return = get_proper_type(ctx.default_return_type)
     if not isinstance(default_return, CallableType):
         return default_return
+    return _analyze_partial(ctx, default_return)
+
+
+def _analyze_partial(
+    ctx: FunctionContext,
+    default_return: CallableType,
+) -> ProperType:
+    if not ctx.arg_types or not ctx.arg_types[0]:
+        # No function passed: treat as decorator factory and fallback to Any.
+        return AnyType(TypeOfAny.implementation_artifact)
 
     function_def = get_proper_type(ctx.arg_types[0][0])
     func_args = _AppliedArgs(ctx)
 
     if len(list(filter(len, ctx.arg_types))) == 1:
         return function_def  # this means, that `partial(func)` is called
-    if not isinstance(function_def, _SUPPORTED_TYPES):
+    callable_def = _coerce_to_callable(function_def, func_args)
+    if callable_def is None:
         return default_return
-    if isinstance(function_def, Instance | TypeType):
-        # We force `Instance` and similar types to coercse to callable:
-        function_def = func_args.get_callable_from_context()
 
     is_valid, applied_args = func_args.build_from_context()
-    if not isinstance(function_def, CallableType | Overloaded) or not is_valid:
+    if not is_valid:
         return default_return
 
     return _PartialFunctionReducer(
         default_return,
-        function_def,
+        callable_def,
         applied_args,
         ctx,
     ).new_partial()
 
 
+def _coerce_to_callable(
+    function_def: ProperType,
+    func_args: '_AppliedArgs',
+) -> CallableType | Overloaded | None:
+    if not isinstance(function_def, _SUPPORTED_TYPES):
+        return None
+    if isinstance(function_def, Instance | TypeType):
+        # We force `Instance` and similar types to coerce to callable:
+        from_context = func_args.get_callable_from_context()
+        return (
+            from_context
+            if isinstance(from_context, CallableType | Overloaded)
+            else None
+        )
+    return function_def
+
+
 @final
 class _PartialFunctionReducer:
     """

returns/curry.py

@@ -2,16 +2,41 @@
 from functools import partial as _partial
 from functools import wraps
 from inspect import BoundArguments, Signature
-from typing import Any, TypeAlias, TypeVar
+from typing import Any, Generic, TypeAlias, TypeVar, overload
 
 _ReturnType = TypeVar('_ReturnType')
+_Decorator: TypeAlias = Callable[
+    [Callable[..., _ReturnType]],
+    Callable[..., _ReturnType],
+]
 
 
+class _PartialDecorator(Generic[_ReturnType]):
+    """Wraps ``functools.partial`` into a decorator without nesting."""
+    __slots__ = ('_args', '_kwargs')
+
+    def __init__(self, args: tuple[Any, ...], kwargs: dict[str, Any]) -> None:
+        self._args = args
+        self._kwargs = kwargs
+
+    def __call__(self, inner: Callable[..., _ReturnType]) -> Callable[..., _ReturnType]:
+        return _partial(inner, *self._args, **self._kwargs)
+
+
+@overload
 def partial(
     func: Callable[..., _ReturnType],
+    /,
     *args: Any,
     **kwargs: Any,
-) -> Callable[..., _ReturnType]:
+) -> Callable[..., _ReturnType]: ...
+
+
+@overload
+def partial(*args: Any, **kwargs: Any) -> _Decorator: ...
+
+
+def partial(*args: Any, **kwargs: Any) -> Any:
     """
     Typed partial application.
 
@@ -35,7 +60,11 @@ def partial(
         - https://docs.python.org/3/library/functools.html#functools.partial
 
     """
-    return _partial(func, *args, **kwargs)
+    if args and callable(args[0]):
+        return _partial(args[0], *args[1:], **kwargs)
+    if args and args[0] is None:
+        args = args[1:]
+    return _PartialDecorator(args, kwargs)
 
 
 def curry(function: Callable[..., _ReturnType]) -> Callable[..., _ReturnType]:

tests/test_curry/test_partial.py

@@ -0,0 +1,30 @@
+from typing import Callable, TypeAlias, TypeVar, cast
+
+from returns.curry import partial
+
+_ReturnType = TypeVar('_ReturnType')
+_Decorator: TypeAlias = Callable[
+    [Callable[..., _ReturnType]],
+    Callable[..., _ReturnType],
+]
+
+
+def add(first: int, second: int) -> int:
+    return first + second
+
+
+def test_partial_direct_call() -> None:
+    add_one = partial(add, 1)
+    assert add_one(2) == 3
+
+
+def test_partial_as_decorator_factory() -> None:
+    decorator = cast(_Decorator[int], partial())
+    add_with_decorator = decorator(add)
+    assert add_with_decorator(1, 2) == 3
+
+
+def test_partial_with_none_placeholder() -> None:
+    decorator = cast(_Decorator[int], partial(None, 1))
+    add_with_none_decorator = decorator(add)
+    assert add_with_none_decorator(2) == 3

typesafety/test_curry/test_partial/test_partial.py

@@ -150,3 +150,97 @@
         function: Callable[[_SecondType, _FirstType], _SecondType],
     ):
         reveal_type(partial(function, default))  # N: Revealed type is "def (_FirstType`-2) -> _SecondType`-1"
+
+
+- case: partial_regression1711
+  disable_cache: false
+  main: |
+    from returns.curry import partial
+
+    def foo(x: int, y: int, z: int) -> int:
+        ...
+
+    def bar(x: int) -> int:
+        ...
+
+    baz = partial(foo, bar(1))
+    reveal_type(baz)  # N: Revealed type is "def (y: builtins.int, z: builtins.int) -> builtins.int"
+
+
+- case: partial_optional_arg
+  disable_cache: false
+  main: |
+    from returns.curry import partial
+
+    def test_partial_fn(
+        first_arg: int,
+        optional_arg: str | None,
+    ) -> tuple[int, str | None]:
+        ...
+
+    bound = partial(test_partial_fn, 1)
+    reveal_type(bound)  # N: Revealed type is "def (optional_arg: builtins.str | None) -> tuple[builtins.int, builtins.str | None]"
+
+
+- case: partial_decorator
+  disable_cache: false
+  main: |
+    from returns.curry import partial
+
+    @partial(first=1)
+    def _decorated(first: int, second: str) -> float:
+        ...
+
+    reveal_type(_decorated)  # N: Revealed type is "Any"
+  out: |
+    main:3: error: Untyped decorator makes function "_decorated" untyped  [misc]
+
+
+- case: partial_keyword_arg
+  disable_cache: false
+  main: |
+    from returns.curry import partial
+
+    def test_partial_fn(
+        first_arg: int,
+        optional_arg: str | None,
+    ) -> tuple[int, str | None]:
+        ...
+
+    bound = partial(test_partial_fn, optional_arg='a')
+    reveal_type(bound)  # N: Revealed type is "def (first_arg: builtins.int) -> tuple[builtins.int, builtins.str | None]"
+
+
+- case: partial_keyword_only
+  disable_cache: false
+  main: |
+    from returns.curry import partial
+
+    def _target(*, arg: int) -> int:
+        ...
+
+    bound = partial(_target, arg=1)
+    reveal_type(bound)  # N: Revealed type is "def () -> builtins.int"
+
+
+- case: partial_keyword_mixed
+  disable_cache: false
+  main: |
+    from returns.curry import partial
+
+    def _target(arg1: int, *, arg2: int) -> int:
+        ...
+
+    bound = partial(_target, arg2=1)
+    reveal_type(bound)  # N: Revealed type is "def (arg1: builtins.int) -> builtins.int"
+
+
+- case: partial_wrong_signature_any
+  disable_cache: false
+  main: |
+    from returns.curry import partial
+
+    reveal_type(partial(len, 1))
+  out: |
+    main:3: error: Argument 1 to "len" has incompatible type "int"; expected "Sized"  [arg-type]
+    main:3: note: Revealed type is "def (*Any, **Any) -> builtins.int"