Conditionally include main in a file

matklad · July 31, 2023, 6:55pm

A small trick that made me smile! Turns out Zig has an equivalent of Python’s

if __name__ == "__main__":

idiom for including a main function in arbitray files:

pub usingnamespace if (@import("root") == @This()) struct {
    pub fn main() void { std.debug.print("you can run this file directly") }
} else struct {
    // But if you @import() it instead,
    // there won't be a useless `main` symbol available!
};

AndrewCodeDev · August 1, 2023, 3:56am

Nice one! I ran it from some other directories to make sure it wasn’t doing something weird with relative paths (at least in ubuntu) and it seems to work fine!

And just for the record, this is actually a very useful technique beyond just importing main. Detecting the root of your location is very important if you do something where your current working directory can change.

kristoff · August 2, 2023, 6:24pm

cursed, thanks for sharing

Sze · August 3, 2023, 6:39pm

I think there may be cases where it is valid to run a main function exported from a lib and pretend it was run as an application directly, haven’t tried that so far, but it seems possible and there might be cases where it is useful. So I think always exporting it isn’t necessarily useless and could make it even more flexible to use.

One case might be if you want to compile a bunch of examples into one fat executable, that acts as a launcher for the different examples and distribute that as a single executable instead of a “real” launcher that starts separate processes, but also have the option of compiling the examples as standalone apps for different distributions of your code.
I think when compiling for wasm/browser such a fake-launcher could make sense.

matklad · August 3, 2023, 9:14pm

This is where I use it at TigerBeetle:

github.com

tigerbeetle/tigerbeetle/blob/8d8eafe125043617093ed7cc04e236f63468fc58/src/flags.zig#L405


      
          fn default_value(comptime field: std.builtin.Type.StructField) ?field.field_type {
              return if (field.default_value) |default_opaque|
                  @ptrCast(
                      *const field.field_type,
                      @alignCast(@alignOf(field.field_type), default_opaque),
                  ).*
              else
                  null;
          }
          
          // CLI parsing makes a liberal use of `fatal`, so testing it within the process is impossible. We
          // test it our of process by:
          //   - using Zig compiler to build this vey file as an executable in a temporary directory,
          //   - running the following main with various args and capturing stdout, stderr, and the exit code.
          //   - asserting that the captured values are correct.
          pub usingnamespace if (@import("root") != @This()) struct {
              // For production builds, don't include the main function.
              // This is `if __name__ == "__main__":` at comptime!
          } else struct {
              const CliArgs = union(enum) {
                  empty,

I want to unit-test some code, but it does process.exit, so I need to run it in a different process. So I just let the file to compile&run itself from test blocks.