def METHOD_NAME(function: Callable[..., _ReturnType]) -> Callable[..., _ReturnType]:
    """
    Typed currying decorator.
    Currying is a conception from functional languages that does partial
    applying. That means that if we pass one argument in a function that
    gets 2 or more arguments, we'll get a new function that remembers all
    previously passed arguments. Then we can pass remaining arguments, and
    the function will be executed.
    :func:`~partial` function does a similar thing,
    but it does partial application exactly once.
    ``curry`` is a bit smarter and will do partial
    application until enough arguments passed.
    If wrong arguments are passed, ``TypeError`` will be raised immediately.
    We use a custom ``mypy`` plugin to make sure types are correct.
    Otherwise, it is currently impossible to properly type this function.
    .. code:: pycon
      >>> from returns.curry import curry
      >>> @curry
      ... def divide(number: int, by: int) -> float:
      ...     return number / by
      >>> divide(1)  # doesn't call the func and remembers arguments
      <function divide at ...>
      >>> assert divide(1)(by=10) == 0.1  # calls the func when possible
      >>> assert divide(1)(10) == 0.1  # calls the func when possible
      >>> assert divide(1, by=10) == 0.1  # or call the func like always
    Here are several examples with wrong arguments:
    .. code:: pycon
      >>> divide(1, 2, 3)
      Traceback (most recent call last):
        ...
      TypeError: too many positional arguments
      >>> divide(a=1)
      Traceback (most recent call last):
        ...
      TypeError: got an unexpected keyword argument 'a'
    Limitations:
    - It is kinda slow. Like 100 times slower than a regular function call.
    - It does not work with several builtins like ``str``, ``int``,
      and possibly other ``C`` defined callables
    - ``*args`` and ``**kwargs`` are not supported
      and we use ``Any`` as a fallback
    - Support of arguments with default values is very limited,
      because we cannot be totally sure which case we are using:
      with the default value or without it, be careful
    - We use a custom ``mypy`` plugin to make types correct,
      otherwise, it is currently impossible
    - It might not work as expected with curried ``Klass().method``,
      it might generate invalid method signature
      (looks like a bug in ``mypy``)
    - It is probably a bad idea to ``curry`` a function with lots of arguments,
      because you will end up with lots of overload functions,
      that you won't be able to understand.
      It might also be slow during the typecheck
    - Currying of ``__init__`` does not work because of the bug in ``mypy``:
      https://github.com/python/mypy/issues/8801
    We expect people to use this tool responsibly
    when they know that they are doing.
    See also:
        - https://en.wikipedia.org/wiki/Currying
        - https://stackoverflow.com/questions/218025/
    """
    argspec = Signature.from_callable(function).bind_partial()
    def decorator(*args, **kwargs):
        return _eager_curry(function, argspec, args, kwargs)
    return wraps(function)(decorator)