Jak używać makra w plikach modułów?

Mam dwa moduły w osobnych plikach w tej samej skrzynce, w której skrzynia została macro_ruleswłączona. Chcę użyć makr zdefiniowanych w jednym module w innym module.

// macros.rs
#[macro_export] // or not? is ineffectual for this, afaik
macro_rules! my_macro(...)

// something.rs
use macros;
// use macros::my_macro; <-- unresolved import (for obvious reasons)
my_macro!() // <-- how?

Aktualnie trafiam na błąd kompilatora " macro undefined: 'my_macro'" ... który ma sens; system makr działa przed systemem modułu. Jak mam to obejść?

Makra w tej samej skrzynce

#[macro_use]
mod foo {
    macro_rules! bar {
        () => ()
    }
}

bar!();    // works

Jeśli chcesz użyć makra w tej samej skrzynce, moduł, w którym zdefiniowane jest makro, potrzebuje atrybutu #[macro_use].

Makra można używać tylko po ich zdefiniowaniu. Oznacza to, że to nie działa:

bar!();  // ERROR: cannot find macro `bar!` in this scope

#[macro_use]
mod foo {
    macro_rules! bar {
        () => ()
    }
}

Makra w skrzyniach

Aby użyć macro_rules!makra z innych skrzynek, samo makro potrzebuje atrybutu #[macro_export]. Skrzynka importująca może następnie zaimportować makro przez use crate_name::macro_name;.

Skrzynia util

#[macro_export]
macro_rules! foo {
    () => ()
}

Skrzynia user

use util::foo;

foo!();

Zwróć uwagę, że makra zawsze znajdują się na najwyższym poziomie skrzynki; więc nawet gdyby foobył wewnątrz a mod bar {}, userskrzynia nadal musiałaby pisać, use util::foo;a nie use util::bar::foo; .

Przed Rust 2018 trzeba było importować makro z innych skrzynek, dodając atrybut #[macro_use]do extern crate util;instrukcji. Spowoduje to zaimportowanie wszystkich makr z util. Alternatywnie #[macro_use(cat, dog)]można użyć tylko do importowania makr cati dog. Ta składnia nie powinna być już potrzebna.

Więcej informacji można znaleźć w rozdziale poświęconym makrom w języku programowania Rust .

Ta odpowiedź jest nieaktualna w wersji stabilnej dla Rust 1.1.0.

Musisz dodać go #![macro_escape]na górze macros.rsi dołączyć, używając, mod macros;jak wspomniano w Przewodniku po makrach .

$ cat macros.rs
#![macro_escape]

#[macro_export]
macro_rules! my_macro {
    () => { println!("hi"); }
}

$ cat something.rs
#![feature(macro_rules)]
mod macros;

fn main() {
    my_macro!();
}

$ rustc something.rs
$ ./something
hi

Dla przyszłego odniesienia,

$ rustc -v
rustc 0.13.0-dev (2790505c1 2014-11-03 14:17:26 +0000)

Dodanie #![macro_use]na początek pliku zawierającego makra spowoduje pobranie wszystkich makr do main.rs.

Na przykład załóżmy, że ten plik nazywa się node.rs:

#![macro_use]

macro_rules! test {
    () => { println!("Nuts"); }
}

macro_rules! best {
    () => { println!("Run"); }
}

pub fn fun_times() {
    println!("Is it really?");
}

Twój plik main.rs wyglądałby kiedyś tak:

mod node;  //We're using node.rs
mod toad;  //Also using toad.rs

fn main() {
    test!();
    best!();
    toad::a_thing();
}

Na koniec powiedzmy, że masz plik o nazwie toad.rs, który również wymaga tych makr:

use node; //Notice this is 'use' not 'mod'

pub fn a_thing() {
  test!();

  node::fun_times();
}

Zwróć uwagę, że po ściągnięciu plików do main.rs z mod, pozostałe pliki mają do nich dostęp poprzez usesłowo kluczowe.

I natknąłem się na ten sam problem w Rust 1.44.1, a to rozwiązanie działa na nowszych wersjach (nazywanych pracujących dla Rust 1.7).

Załóżmy, że masz nowy projekt jako:

src/
    main.rs
    memory.rs
    chunk.rs

W main.rs musisz dodać adnotację, że importujesz makra ze źródła, w przeciwnym razie nie będzie to dla Ciebie przydatne.

#[macro_use]
mod memory;
mod chunk;

fn main() {
    println!("Hello, world!");
}

Więc w memory.rs możesz zdefiniować makra i nie potrzebujesz adnotacji:

macro_rules! grow_capacity {
    ( $x:expr ) => {
        {
            if $x < 8 { 8 } else { $x * 2 }
        }
    };
}

Wreszcie możesz go użyć w chunk.rs i nie musisz tutaj umieszczać makra, ponieważ jest to zrobione w main.rs:

grow_capacity!(8);

Upvoted odpowiedź spowodowała zamieszanie na mnie, z tego dokumentu przez przykład , byłoby zbyt pomocne.