ฉันจะใช้มาโครข้ามไฟล์โมดูลได้อย่างไร

ฉันมีสองโมดูลในไฟล์แยกกันภายในลังเดียวกันซึ่งลังmacro_rulesเปิดใช้งาน ฉันต้องการใช้มาโครที่กำหนดไว้ในโมดูลหนึ่งในโมดูลอื่น

// 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?

ขณะนี้ฉันพบข้อผิดพลาดของคอมไพเลอร์ " macro undefined: 'my_macro'" ... ซึ่งสมเหตุสมผล ระบบมาโครทำงานก่อนระบบโมดูล ฉันจะหลีกเลี่ยงสิ่งนั้นได้อย่างไร

มาโครภายในลังเดียวกัน

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

bar!();    // works

#[macro_use]หากคุณต้องการใช้แมโครในลังเดียวกันโมดูลแมโครของคุณถูกกำหนดไว้ในความต้องการของแอตทริบิวต์

สามารถใช้มาโครได้หลังจากกำหนดไว้แล้วเท่านั้น ซึ่งหมายความว่าสิ่งนี้ใช้ไม่ได้:

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

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

มาโครข้ามลัง

กับการใช้งานmacro_rules!แมโครจากลังอื่น ๆ #[macro_export]แมโครตัวเองต้องการแอตทริบิวต์ use crate_name::macro_name;ลังการนำเข้านั้นสามารถนำเข้าแมโครผ่าน

ลัง util

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

ลัง user

use util::foo;

foo!();

โปรดทราบว่ามาโครจะอยู่ที่ระดับบนสุดของลังเสมอ ดังนั้นแม้ว่าfooจะเป็นภายในmod bar {}ที่userลังจะยังคงต้องมีการเขียนuse util::foo;และการไม่ได้ use util::bar::foo;

ก่อนเกิดสนิม 2018 คุณต้องนำเข้ามาโครจากลังอื่นโดยการเพิ่มแอตทริบิวต์#[macro_use]ในextern crate util;คำสั่ง utilที่จะนำเข้าแมโครทั้งหมดจาก หรือ#[macro_use(cat, dog)]อาจใช้เพื่อนำเข้ามาโครcatและdog. ไวยากรณ์นี้ไม่จำเป็นอีกต่อไป

ข้อมูลเพิ่มเติมสามารถดูได้ในสนิมเขียนโปรแกรมภาษาบทที่เกี่ยวกับมาโคร

คำตอบนี้ล้าสมัยเนื่องจาก Rust 1.1.0-stable

คุณต้องเพิ่ม#![macro_escape]ที่ด้านบนของmacros.rsและเก็บไว้ใช้mod macros;เป็นที่กล่าวถึงในคู่มือแมโคร

$ 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

สำหรับการอ้างอิงในอนาคต,

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

การเพิ่ม#![macro_use]ที่ด้านบนของไฟล์ที่มีมาโครจะทำให้มาโครทั้งหมดถูกดึงเข้าไปใน main.rs

ตัวอย่างเช่นสมมติว่าไฟล์นี้เรียกว่า node.rs:

#![macro_use]

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

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

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

main.rs ของคุณจะมีลักษณะดังต่อไปนี้:

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

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

สุดท้ายสมมติว่าคุณมีไฟล์ชื่อ toad.rs ซึ่งต้องใช้มาโครเหล่านี้ด้วย:

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

pub fn a_thing() {
  test!();

  node::fun_times();
}

สังเกตว่าเมื่อไฟล์ถูกดึงเข้าสู่ main.rs ด้วยmodแล้วไฟล์ที่เหลือของคุณจะสามารถเข้าถึงไฟล์เหล่านี้ได้ผ่านuseคีย์เวิร์ด

ฉันเจอปัญหาเดียวกันใน Rust 1.44.1 และวิธีนี้ใช้ได้กับรุ่นที่ใหม่กว่า (รู้จักกันในชื่อ Rust 1.7)

สมมติว่าคุณมีโครงการใหม่เป็น:

src/
    main.rs
    memory.rs
    chunk.rs

ในmain.rsคุณต้องใส่คำอธิบายประกอบว่าคุณกำลังนำเข้ามาโครจากแหล่งที่มามิฉะนั้นจะไม่ทำเพื่อคุณ

#[macro_use]
mod memory;
mod chunk;

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

ดังนั้นในmemory.rsคุณสามารถกำหนดมาโครได้และคุณไม่จำเป็นต้องมีคำอธิบายประกอบ:

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

ในที่สุดคุณก็สามารถใช้มันในchunk.rsและคุณไม่จำเป็นต้องรวมมาโครไว้ที่นี่เพราะมันทำใน main.rs:

grow_capacity!(8);

คำตอบ upvotedทำให้เกิดความสับสนสำหรับผมกับเอกสารนี้โดยตัวอย่างก็จะเป็นประโยชน์มากเกินไป