[std-proposals] Clarification on P1203: Modular Main

[Jim Porter]

P1203: Modular Main looks like it addresses a concern I had with modules
quite some time ago[1]; specifically, whether you can define a "generic
main()" in a module-based library to use, instead of forcing users to
write their own main(). However, since the paper is fairly brief, and I
haven't followed the modules work closely, I wanted to confirm whether
this scenario would be supported by P1203.

My use case is primarily for providing a generic main() function for a
unit testing framework to allow users of the framework to avoid having
to write their own. Currently, I inject the main() via an #include
statement, and all the user-written tests are defined within static
globals[2].

It may turn out that this method has other issues when used with
modules, but I wanted to see if it's even possible under P1203. As the
paper wisely notes, tests for a module probably need to live *within*
that module in order to see non-exported names. However, initializing
your tests within the constructors of static globals would cause them to
be created even when merely *using* the module. Perhaps there's an easy
alternative here that retains the expressiveness of my current solution,
but I'm not sure what it would be just yet...

- Jim

[1]
https://groups.google.com/a/isocpp.org/d/msg/modules/naaN9T3cmMM/oeT1Ig7WaTYJ
[2]
https://github.com/jimporter/mettle/blob/master/examples/test_01_basic.cpp

[i***@gmail.com]

Post by Jim Porter
P1203: Modular Main looks like it addresses a concern I had with modules
quite some time ago[1]; specifically, whether you can define a "generic
main()" in a module-based library to use, instead of forcing users to
write their own main(). However, since the paper is fairly brief, and I
haven't followed the modules work closely, I wanted to confirm whether
this scenario would be supported by P1203.
My use case is primarily for providing a generic main() function for a
unit testing framework to allow users of the framework to avoid having
to write their own. Currently, I inject the main() via an #include
statement, and all the user-written tests are defined within static
globals[2].
It may turn out that this method has other issues when used with
modules, but I wanted to see if it's even possible under P1203. As the
paper wisely notes, tests for a module probably need to live *within*
that module in order to see non-exported names. However, initializing
your tests within the constructors of static globals would cause them to
be created even when merely *using* the module. Perhaps there's an easy
alternative here that retains the expressiveness of my current solution,
but I'm not sure what it would be just yet...
- Jim
[1]
https://groups.google.com/a/isocpp.org/d/msg/modules/naaN9T3cmMM/oeT1Ig7WaTYJ
[2]
https://github.com/jimporter/mettle/blob/master/examples/test_01_basic.cpp

This will have interesting side effect, with this user could use "main"
with different parameters:

include std.main;

int std::main(std::view<std::string_view> args)
{
}

This would need some tweaks to modules proposition (`std::main` is declared
in `std.main` but defined in some other module).
We avoid all concerns with old proposition that change `main` arguments
(like allocation before `main`) because we have still normal main around
and simply it call new main.

[Serdar Sanli]

I proposed something different to tackle the same problem before:
https://groups.google.com/a/isocpp.org/forum/#!msg/std-proposals/E3ljdlN3f5c/TD79wZvfCgAJ
That thread has some interesting discussion which might be of interest

Serdar

Post by Jim Porter
P1203: Modular Main looks like it addresses a concern I had with modules
quite some time ago[1]; specifically, whether you can define a "generic
main()" in a module-based library to use, instead of forcing users to
write their own main(). However, since the paper is fairly brief, and I
haven't followed the modules work closely, I wanted to confirm whether
this scenario would be supported by P1203.
My use case is primarily for providing a generic main() function for a
unit testing framework to allow users of the framework to avoid having
to write their own. Currently, I inject the main() via an #include
statement, and all the user-written tests are defined within static
globals[2].
It may turn out that this method has other issues when used with
modules, but I wanted to see if it's even possible under P1203. As the
paper wisely notes, tests for a module probably need to live *within*
that module in order to see non-exported names. However, initializing
your tests within the constructors of static globals would cause them to
be created even when merely *using* the module. Perhaps there's an easy
alternative here that retains the expressiveness of my current solution,
but I'm not sure what it would be just yet...
- Jim
[1]
https://groups.google.com/a/isocpp.org/d/msg/modules/naaN9T3cmMM/oeT1Ig7WaTYJ
[2]
https://github.com/jimporter/mettle/blob/master/examples/test_01_basic.cpp