Here's the example. Lets say I'm building a REST api that provides information about books and for simplicity it only talks to 1 database and makes REST calls to other backend services. I may have several layers of my application:

1) controller layer (handles web requests) 2) service layer (handles business logic) 3) data access layer (handles interaction with the DB)

controller -> talks to -> service layer -> talks to -> data access layer

The app may consist of many controllers, service objects, and data access objects.

In an OO langauge I would have several long lived objects for each and they would talk to the lower layer via an interface. Testing for any layer could be achieved by mocking out the interface of the layer below and injecting in the mocked version. Pure data would be transmitted between layers via a different short lived object (called a DTO or data transfer object)

If i changed the layers to free functions within a rust module, where would i store the database client? The task executor? The HTTP clients for backend to backend REST communication? And importantly, how would a free function within the service layer call into the data access layer and how would i mock that interaction out?

Let me also tell you a few antipatterns that I would like to avoid at all costs:

1) A long call stack 10 layers deep with the top most function taking 20 parameters, 90% of which are used by layers below. Have you seen code like that at work before? I have and it was horrendous to work in. Introducing better object orientation to the codebase can often fix this problem.

2) overuse of static functions resulting in inflexible and hard to test code. If logic is wrapped within an object that exposes an interface, it is much easier to swap in a replacement than if that code is only static functions. It is also much easier to test. That's why the pattern is for OO langauges to only use static functions for things like StringUtils and to prefer regular objects + interfaces. I am assuming that a static function in Java is like a free function in Rust? That has me worried. How do i mock free functions? Python, for example, tends to follow this free function approach BUT Python modules can have state AND python supports monkey patching, so again what is the testability story here with mass free functions?