Add parser methods wrapTimes, wrapAtLeast, wrapAtMost and wrapMany about parsimmon HOT 6 CLOSED

Can you explain how these differ from method chaining?

How does wrapTimes compare to the following?

parser.times(n).wrap(before, after)
parser.times(min, max).wrap(before, after)
// --- or ---
parser.wrap(before, after).times(n)
parser.wrap(before, after).times(min, max)

Same sort of question for wrapAtLeast, wrapAtMost, wrapMany.

from parsimmon.

This parser will only succeed when the input is "(abra-abra-abra-)"

string("abra-").times(3).wrap(string("("), string(")"))
```

This parser will only succeed when the input is "(abra)(abra)(abra)"
```js 
string("abra").wrap(string("("), string(")")).times(3)
```

```
```

from parsimmon.

Times followed with wrap will only succeed when the input is "(abra-abra-abra-)"

string("abra-").times(3).wrap(string("("), string(")"))

Wrap followed with times will only succeed when the input is "(abra)(abra)(abra)"

string("abra").wrap(string("("), string(")")).times(3)

WrapTimes will only succeed when the input is "(((abra)))"

string("abra").wrapTimes(string("("), string(")"), 3);

// wrapTimes is same as this below
string("abra")
.wrap(string("("), string(")"))
.wrap(string("("), string(")"))
.wrap(string("("), string(")"))

WrapAtLeast will succeed if you have wrapped it at least n times. In this case "abra" must be wrapped at least in 2 parentheses or more, for example it would succeed if the input is "((abra))" or "(((((abra)))))"

string("abra").wrapAtLeast(string("("), string(")"), 2)

WrapAtMost will succeed if you have wrapped it at most n times. In this case "abra" must be wrapped at most 2 times or less, for example it would succeed if the input is "abra" or "(abra)" or "((abra))".

string("abra").wrapAtMost(string("("), string(")"), 2)

WrapMany will succeed if you have wrapped n times or not at all. In this case "abra" can be wrapped n times or not at all, for example it would succeed if the input is "abra" or "(((((((((((((abra)))))))))))))" or "(((((abra)))))"

from parsimmon.

Parsimmon already has a lot of methods, and I've never wanted this one personally. You can write this in terms of other combinators without a ton of fuss, so I don't want to add 4 new methods.

const P = require('parsimmon');

const x = P.string('x');
const xp = P.string('(').atLeast(1).chain((lp) => {
    return x.skip(P.string(')').times(lp.length));
});

xp.parse('(((x)))');

from parsimmon.

To be honest with you I thought I would need it, but I realized now I don't actually need and it is nisch feature. By the way thanks for the answer.

from parsimmon.

Ah, good to know. I like hearing real-world use-cases for methods before adding them anyway.

from parsimmon.