`stringify!` în Rust

Macro-uri evaluate la compilare Rust 1.0

Transformă codul primit în text, fără să-l execute. Folosit în macro-uri pentru mesaje care arată expresia exactă.

Sintaxă

stringify!(orice cod)     // -> "orice cod" (&'static str), codul NU este executat

Ce face `stringify!`

stringify!(a + b * 2) nu calculează nimic: dă textul "a + b * 2". Codul primit nu trebuie nici măcar să fie valid ca expresie, doar să fie format din tokeni Rust. Textul rezultat păstrează în mare scrierea ta (spațiile multiple dintre tokeni devin unul singur), dar forma exactă nu este garantată.

Este folosit mai ales în macro-uri, ca să afișeze codul cu care au fost apelate. Așa funcționează mesajele lui assert! (assertion failed: x > 0) și dbg! ([main.rs:3:5] a * 2 = 10).

Rezultatul este un literal de text (&'static str), deci poate fi combinat cu concat!.

Exemple

Exemplul 1: Codul devine text

Nicio expresie nu este evaluată: nici funcția inexistentă, nici împărțirea la zero. Pe al treilea rând se vede că spațiile multiple au devenit unul singur, iar restul scrierii a rămas cum era.

fn main() {
    println!("{}", stringify!(pret * cantitate + transport));
    println!("{}", stringify!(functie_inexistenta(1/0)));
    println!("{}", stringify!(a+b   *2));
    println!("{}", stringify!(Vec<String>));
}

Rezultat

pret * cantitate + transport
functie_inexistenta(1/0)
a+b *2
Vec<String>

Exemplul 2: Un macro de verificare care arată expresia

verifica! afișează textul condiției și rezultatul ei, ca un assert! care nu oprește programul.

macro_rules! verifica {
    ($conditie:expr) => {
        println!("{:<30} {}", stringify!($conditie), if $conditie { "DA" } else { "NU" })
    };
}

fn main() {
    let varsta = 17;
    let oras = "Iași";
    verifica!(varsta >= 18);
    verifica!(oras.starts_with("I"));
    verifica!(oras.chars().count() == 4);
}