Add Scheme-style cond! macro

[brendanzab]

Addressing issue #6037, this Scheme-style conditional helps to improve code clarity in instances where the if, else if, and else keywords obscure predicates undesirably.

Here is an example:

let clamped =
    if x > mx { mx }
    else if x < mn { mn }
    else { x };

Using cond!, the above could be written as:

let clamped = cond!(
    (x > mx) { mx }
    (x < mn) { mn }
    _        { x  }
);

The optional default case is denoted by _.

I have altered std::fun_treemap to demonstrate it in use. I am definitely interested in using it for some of the numeric functions, but I will have to wait for it to reach stage0 first.

[brendanzab]

@graydon r?

[graydon]

nice. Can it use cond! { ... } invocation? and can it possibly dispense with the | markers? Or do these make it not parse right?

[brendanzab]

Ahh yes. I tried without the markers, but I get:

cond.rs:16:8: 16:9 error: Local ambiguity: multiple parsing options: built-in NTs expr ('pred') or 1 other options.
cond.rs:16         _     { io::println(~"bananas"); }
                   ^

How would I switch to using { ... }. That would be awesome. I tried before, but couldn't figure out how to do it.

[brendanzab]

@graydon should we close this until those things can be fixed? Or are you happy with having this in the interim?

[brendanzab]

@graydon ok, I have a possible interim fix for the bad parsing without using the |s.

macro_rules! cond(
    ($(($pred:expr) $body:block)+ _ $default:block) => (
        $(if $pred $body )else+
        else $default
    );
    ($(($pred:expr) $body:block)+) => (
        $(if $pred $body )else+
    );
)

fn main() {
    let x = 1;
    cond!(
        (x < 0) { io::println(~"woops");   }
        (true ) { io::println(~"hullo");   }
        _       { io::println(~"bananas"); }
    )

    cond!(
        (x < 0) { io::println(~"woops");   }
        (true ) { io::println(~"hullo");   }
    )
}

It's not the greatest solution, but it is a backwards compatible fix that could serve us until the macro parser can be improved (or rewritten) to enable:

cond! {
    x < 0 { io::println(~"woops");   }
    true  { io::println(~"hullo");   }
    _     { io::println(~"bananas"); }
}

I definitely think the above syntax is what we should aim for, if macros could ever allow it.