How can I statically register structures at compil

Question

I'm looking for the right method to statically register structures at compile time.

The origin of this requirement is to have a bunch of applets with dedicated tasks so that if I run myprog foo, it will call the foo applet.

So I started by defining an Applet structure:

struct Applet {
    name: &str,
    call: fn(),
}

Then I can define my foo applet this way:

fn foo_call() {
    println!("Foo");
}
let foo_applet = Applet { name: "foo", call: foo_call };

Now I would like to register this applet so that my main function can call it if available:

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();

    match AppletRegistry.get(args[1]) {
        Some(x) => x.call(),
        _ => (),
    }
}

The whole deal is about how AppletRegistry should be implemented so that I can list all the available applets preferably at compile time.

Answer 1

This is not a direct answer to your question but just FYI... For ELF binaries, I could achieve something similar to GCC's __attribute__((constructor)) with

fn init() { ... }
#[link_section = ".init_array"]
static INIT: fn() = init;

This is obviously a deviation from Rust's design philosophies. (Portability and what @DK calls "no code before main" principle.)

INIT can also be an Rust array. You might need to pay more attention to alignments.

Answer 2

You can.

You need to use the inventory crate. This is limited to Linux, macOS and Windows at the moment.

You need to use inventory::submit to add it to a global registry, inventory::collect to build the registry, and inventory::iter to iterate over the registry:

use inventory; // 0.1.3
use std::{collections::BTreeMap, env};

struct Applet {
    name: &'static str,
    call: fn(),
}

// Add something to the registry

fn foo_call() {
    println!("Foo");
}
inventory::submit!(Applet {
    name: "foo",
    call: foo_call
});

// Build the registry

inventory::collect!(Applet);

fn main() {
    let args: Vec<String> = env::args().collect();

    let mut registry = BTreeMap::new();

    // Access the registry
    for applet in inventory::iter::<Applet> {
        registry.insert(applet.name, applet);
    }

    if let Some(applet) = registry.get(&args[1].as_ref()) {
        (applet.call)();
    }
}

Running it shows how it works:

$ cargo run foo
Foo

$ cargo run bar

Answer 3

You can't.

One of the conscious design choices with Rust is "no code before main", thus there is no support for this sort of thing. Fundamentally, you need to have code somewhere that you explicitly call that registers the applets.

Rust programs that need to do something like this will just list all the possible implementations explicitly and construct a single, static array of them. Something like this:

pub const APPLETS: &'static [Applet] = [
    Applet { name: "foo", call: ::applets::foo::foo_call },
    Applet { name: "bar", call: ::applets::bar::bar_call },
];

(Sometimes, the repetitive elements can be simplified with macros, i.e. in this example, you could change it so that the name is only mentioned once.)

Theoretically, you could do it by doing what languages like D do behind the scenes, but would be platform-specific and probably require messing with linker scripts and/or modifying the compiler.

Aside: What about #[test]? #[test] is magic and handled by the compiler. The short version is: it does the job of finding all the tests in a crate and building said giant list, which is then used by the test runner which effectively replaces your main function. No, there's no way you can do anything similar.