Scalas' for comprehension in Rust

for-comprehension.rs

#[macro_export]
macro_rules! foreach {
    ($a:ident <- ($e:expr) if ($cond:expr) yield $result:expr) => {{
        $e.filter(|$a| $cond).map(|$a| $result)
    }};
    ($a:ident <- ($e:expr) yield $result:expr) => {{
        $e.map(|$a| $result)
    }};
    ($a:ident <- ($e:expr) $($r:tt)+) => {{
        $e.flat_map(|$a| foreach!($($r)+))
    }}
}

#[test]
fn it_apply_foreach() {
    let r = foreach!(
        a <- (1..=2)
        b <- (1..=a)
        if (*b < 2)
        yield b
    );
}

// 
// Borrowing limitation
//

#[test]
fn it_apply_foreach() {
    let r = foreach!(
        a <- (1..=2)
        b <- (1..=5)
        yield (a,b)
//             ^ borrowed value does not live long enough
    );
}

Another improvement (kind of variable elision).

#[macro_export]
macro_rules! foreach {
    ($a:ident <- ($e:expr) if ($cond:expr) $($r:tt)+) => {{
        foreach!($a <- ($e.satisfy(move |&$a| $cond)) $($r)+)
    }};
    ($a:ident <- ($e:expr) yield $result:expr) => {{
        $e.fmap(move |$a| $result)
    }};
    ($a:ident <- ($e:expr) $($r:tt)+) => {{
        $e.bind(move |$a| foreach!($($r)+))
    }};
    (($e:expr) yield $result:expr) => {{
        $e.fmap(move |_| $result)
    }};
    (($e:expr) $($r:tt)+) => {{
        $e.bind(move |_| foreach!($($r)+))
    }}
}

Then in my parser combinator library I can write:

#[test]
fn it_parse_any_then_any_macro_seq() {
let r = foreach!(
        ('\'')
        b <- (any()) if (b as char != '\'')
        ('\'')
        yield (b)
    );

    assert_eq!('b', r.execute(&"'b'".as_bytes(), 0).fold(
        |b, _, _| b as char,
        |_, _| panic!("Parse error"),
    ));
}