How to build multiple programs? about fpm HOT 10 CLOSED

Right now, if you want multiple executables you have to specify them manually. I'm open to enabling some auto-detection of multiple executables. I'll put together an outline of what that would look like.

from fpm.

from fpm.

I actually much prefer app to src/bin. In my mind a bin directory is for binary files only, not source code.

from fpm.

from fpm.

The app, src separation makes it much easier to determine what should be packaged up into the library, and what is just for use in executable(s). I also makes finding the executable(s) a bit simpler for the automatically detected case. If we switch to the src/bin approach I'll need to special case out of searching that directory when building the library.

from fpm.

I see, good point. Are we still doing src/main.f90 to mean an executable? If so, then you have to special case this anyway.

from fpm.

I think we should aim to minimize special cases in the UI, and implement accordingly. A good test for this is asking what design leads to the simplest user guide.

For example, if everything in src is considered a library component except src/main.f90 and src/bin/*.f90, then these are special cases that require additional clauses in the documentation.

On the other hand, app for programs and src for library is simplest to explain to a user, and is currently my favorite solution.

An even simpler UI than this (to explain to a user) is to have program files be programs, and module files be modules, regardless of where they are in the tree. However this complicates implementation because now fpm needs to parse the sources. A downside is that now there may not be clear separation between programs and module files if the user is just looking at the source tree. However if you have app and src, it's clear.

We should study Rust+Cargo model in detail, but we shouldn't assume that it's the optimal solution for us. This could be because of Rust's own history of the project, or because Rust and Fortran are different languages and have different cultures.

I agree with @LKedward about app vs bin.

from fpm.

Good points. Note that fpm has to parse the sources anyway to determine module dependencies and to enforce that each module name is named appropriately.

So looks like the most natural solution so far is:

• src contains module files (or loose procedures / function --- we should not encourage it, but some existing projects do that and I think we can incorporate this without harm). Everything in src gets built into a library.
• app, contains programs. Perhaps app/main.f90 could be the main program (by default executed by fpm run).
• tests contains tests
• bench contains benchmarks (we can do this one later perhaps --- although most of my projects contain some kind of benchmarks which are distinct from apps and distinct from tests)

from fpm.

I see, good point. Are we still doing src/main.f90 to mean an executable? If so, then you have to special case this anyway.

No, I didn't implement src/main.f90 to be an executable. If it sees that it will expect it to be a module named main.

from fpm.

Closing as this is now implemented.

from fpm.