# Function nom::branch::permutation

source · [−]

    pub fn permutation<I: Clone, O, E: ParseError<I>, List: Permutation<I, O, E>>(
        l: List
    ) -> impl FnMut(I) -> IResult<I, O, E>

Expand description

Applies a list of parsers in any order.

Permutation will succeed if all of the child parsers succeeded. It takes as argument a tuple of parsers, and returns a tuple of the parser results.

    use nom::character::complete::{alpha1, digit1};
    use nom::branch::permutation;
    fn parser(input: &str) -> IResult<&str, (&str, &str)> {
      permutation((alpha1, digit1))(input)
    }

    // permutation recognizes alphabetic characters then digit
    assert_eq!(parser("abc123"), Ok(("", ("abc", "123"))));

    // but also in inverse order
    assert_eq!(parser("123abc"), Ok(("", ("abc", "123"))));

    // it will fail if one of the parsers failed
    assert_eq!(parser("abc;"), Err(Err::Error(Error::new(";", ErrorKind::Digit))));

The parsers are applied greedily: if there are multiple unapplied parsers that could parse the next slice of input, the first one is used.

    use nom::branch::permutation;
    use nom::character::complete::{anychar, char};

    fn parser(input: &str) -> IResult<&str, (char, char)> {
      permutation((anychar, char('a')))(input)
    }

    // anychar parses 'b', then char('a') parses 'a'
    assert_eq!(parser("ba"), Ok(("", ('b', 'a'))));

    // anychar parses 'a', then char('a') fails on 'b',
    // even though char('a') followed by anychar would succeed
    assert_eq!(parser("ab"), Err(Err::Error(Error::new("b", ErrorKind::Char))));