# Macro synom::cond_reduce [−] [src]

    macro_rules! cond_reduce {
        ($i:expr, $cond:expr, $submac:ident!( $($args:tt)* )) => { ... };
        ($i:expr, $cond:expr, $f:expr) => { ... };
    }

Fail to parse if condition is false, otherwise parse the given parser.

This is typically used inside of `option!` or `alt!`.

- Syntax: `cond_reduce!(CONDITION, THING)`
- Output: `THING`

    extern crate syn;
    #[macro_use] extern crate synom;

    use syn::parse::boolean;

    #[derive(Debug, PartialEq)]
    struct VariadicBools {
        data: Vec<bool>,
        variadic: bool,
    }

    // Parse one or more comma-separated booleans, possibly ending in "..." to
    // indicate there may be more.
    named!(variadic_bools -> VariadicBools, do_parse!(
        data: separated_nonempty_list!(punct!(","), boolean) >>
        trailing_comma: option!(punct!(",")) >>
        // Only allow "..." if there is a comma after the last boolean. Using
        // `cond_reduce!` is more convenient here than using `cond!`. The
        // alternatives are:
        //
        //   - `cond!(c, option!(p))` or `option!(cond!(c, p))`
        //     Gives `Some(Some("..."))` for variadic and `Some(None)` or `None`
        //     which both mean not variadic.
        //   - `cond_reduce!(c, option!(p))`
        //     Incorrect; would fail to parse if there is no trailing comma.
        //   - `option!(cond_reduce!(c, p))`
        //     Gives `Some("...")` for variadic and `None` otherwise. Perfect!
        variadic: option!(cond_reduce!(trailing_comma.is_some(), punct!("..."))) >>
        (VariadicBools {
            data: data,
            variadic: variadic.is_some(),
        })
    ));

    fn main() {
        let input = "true, true";
        let parsed = variadic_bools(input).expect("variadic bools");
        assert_eq!(parsed, VariadicBools {
            data: vec![true, true],
            variadic: false,
        });

        let input = "true, ...";
        let parsed = variadic_bools(input).expect("variadic bools");
        assert_eq!(parsed, VariadicBools {
            data: vec![true],
            variadic: true,
        });
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)