I never tried to implement them, finding it easier and more effective for the compiler to simply compile all the source files at the same time.
The D compiler is designed to be able to build one object file per source file at a time, or one object file which combines all of the source files. Most people choose the one object file.
Of course, being C++, this subtly changes behavior and must be done carefully. I like this article that explains the ins and outs of using unity builds: https://austinmorlan.com/posts/unity_jumbo_build/
The D module design ensures that module imports are independent of each other and are independent of the importer.
http://mlton.org/WholeProgramOptimization
Dynamically linked and dynamically loaded libraries are useful though (paid for with its problems of course)
The downside is that you can end up with thousands of object files, but for modern linkers that isn't a problem.
Because then you need to link them, thus you need some kind of linker.
Just generate one output file and skip the linker
1. linkers have increased enormously in complexity
2. little commonality between linkers for different platforms
3. compatibility with the standalone linkers
4. trying to keep up with constant enhancement of existing linkers
Then only the functions touched inside some file would be recompiled, not the remainder of the file or other files.
Obviously, choosing incremental compilation inhibited some optimizations.
Many software projects that must generate multiple executables are better structured as a static library plus one source file with the "main" function for each executable.
I haven't used a librarian program for maybe a decade.
On the other hand, the optimizer and code generator can be run concurrently in multiple processes/threads.