Reorganization: interfaces and core functionality

szabo137 commented 1 month ago

As we discussed offline, we must reorganize parts of the QEDjl ecosystem. Most importantly, QEDbase.jl must contain all interfaces used in several QED.jl packages. Furthermore, there is a new package QEDcore.jl which contains all the core types and functionality (particles, four-momenta, dirac-tensors, etc). Essentially, we move all concrete implementations from QEDbase.jl to QEDcore.jl and ship all interfaces from the downstream packages to QEDbase.jl.

Some pull requests were already opened to reorganize QEDbase.jl, QEDcore.jl, and QEDprocesses.jl (big thanks to @AntonReinhard). Nevertheless, the procedure of merging is still an open question and seems to be doable, but not straightforward, as discussed offline with @SimeonEhrig.

Here I would like to propose an alternative solution to the follow-the-integration-test errors.

Suggested solution

Preparation

Assume, we have a working version of QEDcore.jl (say QEDcore0.1), depending on the old version of QEDbase.jl (say QEDbase0.1). This is possible by replacing

using QEDbase -> import QEDbase
AbstractType -> QEDbase.AbstractType
interface_function -> QEDbase.interface_function

where AbstractType and interface_function stand for the root types and interface functions of all interfaces.

Similarly, in the downstream packages, one can put QEDbase0.1 beside QEDcore0.1 without breaking the unit tests, by using again import QEDbase, QEDbase.AbstractType, and QEDbase.interface_function instead of using QEDbase. In this case, using using QEDcore will not break the tests, because the breaking redefinitions still are in the QEDbase namespace.

At this point, one can easily include the integration tests to QEDcore.jl without breaking anything.

Updates

Now we can update QEDbase.jl by removing the core functions (now provided by QEDcore0.1) and merge the new version (say QEDbase0.2) to dev. This must not break the integration tests, because all downstream packages only depend on exported types and interface functions, the core functions are already coming from QEDcore. Therefore, one can release QEDbase0.2.

Since QEDbase0.2 is now in place, we can update all the downstream packages (including QEDcore0.1) can be updated by bumping the version of QEDbase.jl, removing the interfaces now in QEDbase and revoking the replacement

import QEDbase -> using QEDbase
QEDbase.AbstractType -> AbstractType
QEDbase.interface_function -> interface_function

Proposed schedule

[x] move core function to QEDcore, add integration tests to `QEDcore, and merge it to dev (using the replacement above), passing all unit tests and all integration tests. This might require several PRs and registration in the local registry.
[x] For all downstream packages: move all QEDbase stuff behind the QEDbase namespace using the replacement above. Add QEDcore as the dependency, where the core functionality now comes from.
[x] Update QEDbase by removing core functionality, which is now placed in QEDcore (must not break anything because of 2.) and adding all interfaces from all downstream packages. This must not break the integration tests. Release QEDbase0.2.
[x] Update QEDcore by revoking the QEDbase-namespace replacement. Must not break the integration tests. Release QEDcore0.1.
[x] Update QEDprocesses.jl by revoking the QEDbase-namespace replacement along with removing the interfaces now in QEDbase. Release QEDprocesses0.2
[x] Update QEDevents.jl by revoking the QEDbase-namespace replacement along with removing the interfaces now in QEDbase. Release QEDevents0.1.
[x] Update QEDfields.jl by revoking the QEDbase-namespace replacement along with removing the interfaces now in QEDbase. Release QEDfields0.1.