@@ -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,6 +53,9 @@ def analyze(ctx: FunctionContext) -> ProperType:
     default_return = get_proper_type(ctx.default_return_type)
     if not isinstance(default_return, CallableType):
         return default_return
+    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)
 
@@ -8,7 +8,7 @@
 
 
 def partial(
-    func: Callable[..., _ReturnType],
+    func: Callable[..., _ReturnType] | None = None,
     *args: Any,
     **kwargs: Any,
 ) -> Callable[..., _ReturnType]:
@@ -35,6 +35,13 @@ def partial(
         - https://docs.python.org/3/library/functools.html#functools.partial
 
     """
+    if func is None:
+        def _decorator(  # type: ignore[return-type]
+            inner: Callable[..., _ReturnType],
+        ) -> Callable[..., _ReturnType]:
+            return _partial(inner, *args, **kwargs)
+
+        return _decorator
     return _partial(func, *args, **kwargs)
 
 
 
@@ -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"