Làm cách nào để sử dụng macro trên các tệp mô-đun?

Tôi có hai mô-đun trong các tệp riêng biệt trong cùng một thùng, nơi thùng đã macro_rulesđược kích hoạt. Tôi muốn sử dụng các macro được xác định trong một mô-đun trong một mô-đun khác.

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

Tôi hiện gặp lỗi trình biên dịch " macro undefined: 'my_macro'" ... có lý; hệ thống macro chạy trước hệ thống mô-đun. Làm cách nào để giải quyết vấn đề đó?

Macro trong cùng một thùng

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

bar!();    // works

Nếu bạn muốn sử dụng macro trong cùng một thùng, mô-đun mà macro của bạn được xác định cần thuộc tính #[macro_use].

Macro chỉ có thể được sử dụng sau khi chúng đã được xác định. Điều này có nghĩa là điều này không hoạt động:

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

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

Macro trên các thùng

Để sử dụng macro_rules!macro của bạn từ các thùng khác, bản thân macro cần thuộc tính #[macro_export]. Sau đó, thùng nhập có thể nhập macro qua use crate_name::macro_name;.

Thùng util

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

Thùng user

use util::foo;

foo!();

Lưu ý rằng macro luôn ở cấp cao nhất của thùng; vì vậy ngay cả khi foosẽ ở bên trong a mod bar {}, userthùng vẫn phải ghi use util::foo;và không use util::bar::foo; .

Trước Rust 2018, bạn phải nhập macro từ các thùng khác bằng cách thêm thuộc tính #[macro_use]vào extern crate util;câu lệnh. Điều đó sẽ nhập tất cả các macro từ util. Ngoài ra, #[macro_use(cat, dog)]có thể được sử dụng để chỉ nhập các macro catvà dog. Cú pháp này không cần thiết nữa.

Thông tin thêm có sẵn trong chương Ngôn ngữ lập trình Rust về macro .

Câu trả lời này đã lỗi thời kể từ Rust 1.1.0-ổn định.

Bạn cần thêm #![macro_escape]ở đầu macros.rsvà thêm nó bằng cách sử dụng mod macros;như đã đề cập trong Hướng dẫn Macro .

$ 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

Để tham khảo trong tương lai,

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

Thêm #![macro_use]vào đầu tệp của bạn có chứa macro sẽ khiến tất cả các macro được kéo vào main.rs.

Ví dụ: giả sử tệp này được gọi là node.rs:

#![macro_use]

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

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

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

Đôi khi main.rs của bạn sẽ trông giống như sau:

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

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

Cuối cùng, giả sử bạn có một tệp có tên là kid.rs cũng yêu cầu các macro này:

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

pub fn a_thing() {
  test!();

  node::fun_times();
}

Lưu ý rằng khi các tệp được kéo vào main.rs bằng mod, phần còn lại của các tệp của bạn có quyền truy cập vào chúng thông qua usetừ khóa.

Tôi đã gặp vấn đề tương tự trong Rust 1.44.1 và giải pháp này hoạt động cho các phiên bản sau (được biết là hoạt động cho Rust 1.7).

Giả sử bạn có một dự án mới là:

src/
    main.rs
    memory.rs
    chunk.rs

Trong main.rs , bạn cần phải chú thích rằng bạn đang nhập macro từ nguồn, nếu không, nó sẽ không làm cho bạn.

#[macro_use]
mod memory;
mod chunk;

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

Vì vậy, trong memory.rs, bạn có thể xác định các macro và bạn không cần chú thích:

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

Cuối cùng, bạn có thể sử dụng nó trong chunk.rs và bạn không cần bao gồm macro ở đây, vì nó được thực hiện trong main.rs:

grow_capacity!(8);

Các câu trả lời upvoted gây nhầm lẫn đối với tôi, với doc này bằng ví dụ , nó sẽ là hữu ích quá.