#define and #ifdef macro in Rust

Is it possible to rewrite this C++ code into Rust?

#define is_unionfind_imported
class UnionFind {
};

class Kruskal {
#ifndef is_unionfind_imported
    #error "UnionFind not imported"
#endif
    UnionFind u;
};

int main() {
}

Why, in the first place?

I often do competitive programming in Rust. In competitive programming, users usually register the source codes of frequently used data structures as snippets.

For example, in my case, this code is inserted from ~/snippets/union_find.rs when I execute :I unionfind command in Vim:

#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
struct UnionFind {
    /* ... */
}
impl UnionFind {
    /* ... */
}

Also, when I execute :I kruskal in Vim, this code is inserted from ~/snippets/kruskal_method.rs:

#[derive(Debug, Clone)]
struct Kruskal {
    u: UnionFind,
    /* ... */
}
impl Kruskal {
    fn new(/* ... */) -> Self {
        /* ... */
        Self {
            u: UnionFind::new(0),
        }
    }
}

The problem is Kruskal depends on UnionFind. If I manually execute :I UnionFind and :I Kruskal, there is no problem, but I often forget to first import UnionFind. Then the compiler says

error[E0412]: cannot find type `UnionFind` in this scope

but I'd like to make this error message more user-friendly (e.g. UnionFind is not imported. Execute :I unionfind in Vim.).

And please note

• Module system cannot be used in competitive programming environment. (Only a single source file can be submitted.)

• I don't want to replicate UnionFind code in Kruskal snippet for maintainability.

• Implementing a dependency management system in my snippet inserter (i.e. the backend of :I command) is the last resort.

I've cooked up a hacky solution.

#![allow(unused)]

mod placeholders {
    pub struct UnionFind;
    pub const UNION_FIND_IMPORTED: bool = false;
}

use placeholders::*;

// Start snippet
struct Kruskal {
    u: UnionFind,
}
const _: () = if !UNION_FIND_IMPORTED {
    panic!("UnionFind is not imported. Execute :I unionfind in Vim.");
};
// End snippet

// Start snippet
// struct UnionFind;
// const UNION_FIND_IMPORTED: bool = true;
// End snippet

fn main() {
    println!("hello");
}

The way this works is that when the UnionFind snippet is not present, it is pulled from the glob import. This means UnionFind is always present. In order to check if it's the right one, the constant UNION_FIND_IMPORTED is present next to both UnionFind structs. This is then compile-time evaluated with const _: (), which will compile-panic when the import constant is false.

Pros:

• Custom error message
• Single file
• No CLI args needed

Cons:

• Requires you to have a placeholder module with all your types and the same implemented methods and traits as your real types so that the compiler doesn't stop before const evaluation
• Extra constants