Functional Dependency Injection in Python: From Simple Thresholds to Contextual Composition

Dependency injection (DI) is a controversial topic, especially when trying to blend typed functional functions with classic object‑oriented DI frameworks. The article starts with a simple Django game that awards points for correctly guessed letters and discusses the limitations of adding extra parameters (like a score threshold) throughout the call stack.

It shows a naive solution where the _award_points_for_letters function is extended with a threshold argument, causing type‑checking failures and requiring changes in every caller, which quickly becomes unmanageable in larger applications.

To address this, the author introduces a functional style using a factory that supplies dependencies from the top of the application, defining a Deps protocol that enforces required attributes (e.g., WORD_THRESHOLD) and leverages static type checking with Django stubs.

The article then presents the Reader monad (referred to as RequiresContext) as a compositional helper, allowing pure functions to be combined without passing explicit parameters. It demonstrates how calculate_points returns a context container, which can be mapped or bound with additional functions such as _maybe_add_extra_holiday_point, preserving immutability and framework independence.

Transparent dependencies are handled via Context.ask(), which explicitly retrieves needed values from the environment, and the .bind method enables chaining of functions that return the same container type.

Static typing is emphasized throughout, distinguishing between pure functions, functions that may fail (using Result), and impure functions (using IO). The article explains how various RequiresContext variants (e.g., RequiresContextResult, RequiresContextIOResult) express these semantics clearly.

Finally, the author argues that while small projects can avoid DI containers, complex systems benefit from a DI framework at the top level to manage large dependency graphs, repositories, HTTP services, authentication helpers, caching, and asynchronous tasks.

The conclusion summarizes the key takeaways: choose the appropriate architectural level for DI, consider functional composition with RequiresContext for clear APIs, use static types to express contracts and potential failures, and resort to a DI container when application complexity exceeds manageable limits.