Return types of expressions w/ repetition operators about rust-peg HOT 1 CLOSED

The return types you're seeing aren't actually due to the repetition operators but the things inside them.
Character classes, literals, and concatenations without semantic actions all return (). Thus, repeating them results in a Vec<()>.

You found the right way to extract substrings, though: use match_str. If you wanted your third example in a single line, you could do:

peg! parser(r#"
    #[pub]
    sqayz -> String
        = ['] content:([a]+  { match_str.to_string() }) [']  { content }       
"#);

Some PEG implementations (e.g. PEG.js) make character classes and literals return the matched string. The majority of parser rules are used only for parsing the structure of the code, rather than extracting strings that will be used. Originally, rust-peg couldn't return slices and had to return String, so returning unnecessary results would result in a lot of unnecessary String allocations. Now that we can return &'input str, this is less of a performance issue, but would still result in the allocation of unused Vec<&str> buffers, whereas Vec<()> is just a counter. Performance aside, the implicit returns are rarely used in practice.

The rules that do extract values are often reusable rules like identifier, stringLiteral, number, etc, and typically care about the entire matched string rather than its individual characters (as in your 4th example), so the match_str slice of the input string is more desirable than manually concatenating together the characters (another allocation) from the repetition result vector.

Would "Match one or more repetitions of expression and return a Vec of the expression's return values" clarify the distinction between the rule's return value and the portion of the input string that was matched by that particular expression?

from rust-peg.