Macros

[mdinger]

Japaric's branch: #193. My original PR: #185. I'm hoping the comments will merge onto the end of his...

Target's helping fix this comment. Hopefully it's a little better at showing how repetition works and what is allowed.

[nixpulvis]

Some of the examples seem repetitive.

[mdinger]

Any recommendations? I could probably turn it into a match like below but I was avoiding matching till the later match example:

#![feature(macro_rules)]

macro_rules! echo {
    // Match a series of expressions separated by `,`; return the same
    // and convert the result into a string. `stringify!` causes
    // evaluation to be skipped.
    ($($x:expr),+) => { stringify!($($x),+) };

    // Same. Whitespace is ignored. This won't run because the first will match.
    //($($x:expr) , +) => { stringify!($($x) , +) };

    // Split on `|`. `stringify` is important here.
    ($($x:expr)|+) => { stringify!($($x)|+) };

    // `$` isn't valid. It's a special macro key.
    ($($x:expr)$+) => { stringify!($($x)$+) };

    // Split on `,` with trailing comma.
    ($($x:expr),+,) => { stringify!($($x),+,) };

    // Split on `any_word`. `stringify` is important here.
    ($($x:expr) any_word +) => { stringify!($($x) any_word +) };

    // Error: only allows one symbol between `$(...)` and `+`
    //($($x:expr),,+) => { stringify!($($x),,+) };
    // Error: only allows one word between `$(...)` and `+`
    //($($x:expr) two words +) => { stringify!($($x) two words +) };
}

fn main() {
    println!("{}", echo!(1u, 2u, 3u));
    // Error: Only a single symbol allowed
    //println!("{}", echo!(1u,, 2u,, 3u));
    println!("{}", echo!(1u | 2u | 3u));
    // Error: not valid. Don't split on `$`.
    //println!("{}", echo!(1u $ 2u $ 3u));
    println!("{}", echo!(1u, 2u, 3u,));
    // Trailing comma              ^
    println!("{}", echo!(1u any_word 2u any_word 3u));
    //Error: Only a single word allowed
    //println!("{}", echo!(1u two words 2u two words 3u));
}

The intent is to highlight that the symbol you split with matters. | might work but $ and + are problematic. Multiple characters (a word) can be used but not multiple words or symbols. It looks a lot like a regex but behaves very differently.

[nixpulvis]

Hmmm interesting, I like the more concise example you posted, but it would be important to explain matches first. Either of the two paths I'd avoid duplicate examples like:

macro_rules! echo_word {
  // Split on `word`. `stringify` is important here.
  ($($x:expr) word +) => { stringify!($($x) word +) };
}

macro_rules! echo_and {
  // Split on `and`. `stringify` is important here.
  ($($x:expr) and +) => { stringify!($($x) and +) };
}

[mdinger]

and looks like it's a built in keyword which means && (like python's). Same for or and ||. If you don't realize it isn't builtin, you might not expect word to work which is why I originally had both. any_word might be a good compromise.

[steveklabnik]

this change seems unrelated

[mdinger]

This was because I originally thought automatically hiding gedit temp files might be a good thing. Japaric didn't like it though so I removed it.

[mdinger]

I'll close for now. If I decide to work on it, I'll rebase.