support validation

[siywilliams]

The Api lends itself nicely to some fluent validation. The failures would be returned as part of the parse result object.

The fluent Api could be provided by a set of extenstion methods that hang off the WithValidation() result, for example

parser.Setup<int>("p", "percent").Required().WithValidation()
      .GreaterOrEqualTo(0)
      .LessOrEqualTo(100);

[pragmatrix]

I think a predicate should be sufficient. Syntax could be

parser.Setup<int>("p", "percent")
    .Required()
    .Validate(v => v >= 0 && v <= 100); 

[siywilliams]

That's true, although I find my example to be more readable at a glance.

Both would work alongside each other, although using a predicate is much less work than developing yet-another fluent validation framework as I suggested.

[do0om]

I also think both syntaxes are complementary.
-Syntax like GreaterOrEqualTo or LessOrEqualTo could automatically bring nicely formatted errors.
-while the predicate brings a lot more flexibility for cases not covered by the other syntax.

[bastienJS]

For me a total flexible Predicate is enough. No need for those little extra cases like GreaterOrEqualTo or LessOrEqualTo because they are all covered by the Validate(predicate). (v => v >= 10) is very readable we do it all day with Linq...

[siywilliams]

The user may want to provide a message to display when the validation fails, perhaps using something similar to WithMessage(string), for example:

p.Setup('i')
 .Validate(i => i > 0)
 .WithMessage("Number must be greater than zero");

The error formatter would have to be updated to understand and format these validation failure messages correctly.

Also the module that generates the help text would possibly need to be updated to show any validation constraints that have been setup, although I'm not sure how that would look.

I think the flexible predicate is the way to go.

[GothikX]

Rather than having a separate WithMessage, just have the message as the second argument of the Validate function; that's what I'd to make chaining the validations (and any other stuff after them) more readable and quicker to write. It's also a pattern employed by many validation frameworks. Just my 2c :)