What is the typing.Concatenate?

Question

Accepted Answer

**Concatenate** adds **parameters to the beginning** of a ParamSpec.

```python
from typing import ParamSpec, TypeVar, Callable, Concatenate

P = ParamSpec("P")
R = TypeVar("R")

# Add Request parameter to function
def with_request(
    func: Callable[Concatenate[Request, P], R]
) -> Callable[P, R]:
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
        request = get_current_request()
        return func(request, *args, **kwargs)
    return wrapper

@with_request
def get_user(request: Request, user_id: int) -> User:
    return User.objects.get(id=user_id)

# Request is injected, type checker knows!
user = get_user(42)  # OK — (int) -> User

# With logger
import logging

def with_logger(
    func: Callable[Concatenate[logging.Logger, P], R]
) -> Callable[P, R]:
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
        logger = logging.getLogger(func.__module__)
        return func(logger, *args, **kwargs)
    return wrapper

@with_logger
def process(logger: logging.Logger, data: str) -> None:
    logger.info(f"Processing {data}")

process("hello")  # Logger is injected!
```

**Benefits:**
- Type-safe parameter injection.
- Decorator composition.
- Dependency injection.

Python: What is the typing.Concatenate?