Macros should have an operator type

[darkf]

AFAIK there is currently no way to quote an operator such as + or /, and this would be useful to reduce code duplication.

Something like:

macro_rules! foo(
    ($oper:op) => 10i $oper 20i
)

fn main() {
    printfln!("%d", foo!(+));
    printfln!("%d", foo!(*));
}

[metajack]

This seems in the same vein as #5748

I believe all the operators map to functions in built in traits, so you can probably work around this right now by switching to the method version.

[darkf]

@metajack The problem with the methods is that they accept different types, for example:

fn main() {
    let x = ~"foo";
    let y = ~"bar";
    println(x.add(y));
}

/* z.rs:4:15: 4:16 error: mismatched types: expected `&&str` but found `~str` (expected &-ptr but found ~str)
z.rs:4  println(x.add(y));
                      ^
*/

[japaric]

This can be worked around using the "expr! trick":

#![feature(macro_rules)]

macro_rules! expr {
    ($e:expr) => {
        $e
    }
}

macro_rules! foo(
    ($op:tt) => {
        expr!(10i $op 20i)
    }
)

fn main() {
    println!("{}", foo!(+));
    println!("{}", foo!(*));
}

---

@nick29581 Should this be moved to rust-lang/rfcs? I recall reading somewhere that all the changes to the macro system now require an RFC. (Found it)

[rust-highfive]

This issue has been moved to the RFCs repo: rust-lang/rfcs#426