Include a module and change the implementation of its dependencies

[francoisthire]

Desired Behavior

My use case is the following.

I have a library lib1 which is already implemented.
I would like to have a library lib2 which contains the same modules as lib1 but some hooks are added. However, because lib1 is evolving, I don't want to copy/paste the code of lib1 into lib2 instead, I would like to include lib1 in lib2 and change the linking process so that the modules included refers to the implementation of lib2 and not lib1.

I thought that virtual_libraries could help me but I did a test and the behavior is not the one I expected. I don't really know whether I did something wrong with virtual_libraries or the feature I want is different.

Example

Assume the following structure:

|-- bin
|   |-- dune
|   `-- main.ml
|-- lib1
|   |-- A.ml
|   |-- B.ml
|   `-- dune
|-- lib2
|   |-- A.ml
|   |-- B.ml
|   `-- dune

where :

• lib1/A.ml is implemented as let foo = "foo"
• lib1/B.ml is implemented as let bar = A.foo
• lib2/A.ml is implemented as let foo = "foo2"
• lib2/B.ml is implemented as include Lib1.B
• bin/main.ml is implemented as Format.printf "%s@." Lib2.B.bar

The result when main is compiled as usual is "foo" but I would like to see foo2 instead.
This is possible using ocamlc by giving lib2/A.ml at the linking step, but I did not manage to do it with dune. One may found the current example in the following archive (using virtual libraries):
link.tar.gz.

You need to have one virtual library where A is a virtual module. It will only have a .mli and no .ml. Then lib1 and lib2 should be implementations of this virtual library and can have their own implementation of A.

[francoisthire]

In practice, the implementation of lib2/A may also depend on the implementation of lib1/A. In practice every module in lib2 are a copy of the ones in lib1 using the inclusion of modules with include Lib1 as I did for B with small differences, mainly hooks are added before and after the function. So that I have

lib2/A.ml which is implemented as:

include Lib1

let foo = ignore(A.foo); "foo2" (* Redefinition of foo *)

I just used ignore to make the example type check but in practice I would like to execute A and do some side effect before and/or after.

What about putting the shared code in a shared module A_common that you include in the A modules of both lib1 and lib2

[rgrinberg]

The workaround by Jeremie is the accepted one.