Post-Parsing / Type conversion validation / constraint API

[henrygab]

[[Moving to new issue per @jonsequitur request]]

The current method to add constraints is too complex -- for example, the current suggestions require the user to re-parse the tokens and understand how to iterate though the internal data structures. Ouch.

Strawman goals / Scenarios (click to expand)

Goals

• Solution is invisible to clients which do not require the functionality
• Minimize code duplication
• Requires clients to writes minimal logic required for their particular use case
• Chainable / buildable ... user can add multiple constraints to an Option

Scenarios

• User wants to further restrict an already-supported type, validating individual values
• User wants to further restrict sets of values (for -arity > 1)

---

Strawman client code usage (click to expand)

OK, this uses really long names, solely to be more descriptive.
Framework-provided names would likely be much shorter.

new Option<int[]>("-o")
    .AddConstraintPerValue(IsPositiveValue)
    .AddConstraintPerSet(ValuesAllEvenOrAllOdd);
new Option<string[]>("-s")
    .AddConstraintPerValue(StartsWithVowel)
    .AddConstraintPerSet(AllStartWithSameLetter);

---

Strawman per-value constraints (click to expand)

The idea here is that, even if Arity maximum is greater than one, the library would take care of iterating.

public static bool IsPositiveValue(int value) { return value > 0; } 

public static bool StartsWithVowel(string value) {
    if (String.IsNullOrEmpty(value)) { return false; }
    char tmp = Char.ToLowerInvariant(value[0]);
    return (tmp == 'a' || tmp == 'e' || tmp == 'i' || tmp == 'o' || tmp == 'u' || tmp == 'y');
}

---

Strawman per-set-of-values constraints (click to expand)

The use of IOrderedEnumerable<T> provides flexibility for the library to change the underlying data representation, while ensuring the order of the types matches what was passed via the command line.

The implementations are still simple, iterating through the provided set of values.

public static bool ValuesAllEvenOrAllOdd(IOrderedEnumerable<int> values ) {
    bool any = false;
    bool areEven;
    foreach (var v in values) {
        if (!any) { areEven = ((v % 2) == 0); }
        if (areEven && ((v % 2) != 0)) { return false; }
        else if ((v % 2) == 0) { return false; }
    }
    // return any; // returns false for zero entries
    return true; // returns true for zero entries
}
public static bool AllStartWithSameLetter(IOrderedEnumerable<string> values) {
    bool any = false;
    char firstLetter;
    foreach (var v in values) {
        if (String.IsNullOrEmpty(v)) { return false; }
        if (!any) { firstLetter = v[0]; }
        if (v[0] != firstLetter) { return false; }
    }
    // return any; // returns false for zero entries
    return true; // returns true for zero entries
}

---

I think this would be significantly improved experience for clients. Please consider making it simpler for the client code by enabling something such as the above?

[jonsequitur]

There's been discussion of a better validation / constraint API that's used after parsing and type conversion rather than before. This would reduce code duplication and allow people to write constraints without digging into the parsed tokens.

The straw man is useful here.

I'd add a couple of points to it:

• It should work well with custom ParseArgument<T> delegates
• It should support custom validation messages

One question: In this example, what would constitute a set?

new Option<int>("-o")
    .AddConstraintPerValue(IsPositiveValue)
    .AddConstraintPerSet(ValuesAllEvenOrAllOdd);

I would imagine something like this, based on the generic type parameters:

new Option<int>("-o").AddConstraint(IsPositiveValue);
new Option<int[]>("-o").AddConstraint(IsPositiveValue);
new Option<int[]>("-os").AddConstraint(ValuesAllEvenOrAllOdd);

[henrygab]

One question: In this example, what would constitute a set?

Good catch. My mistake in the examples, which were intended to designate Arity maximum > 1
I've updated those examples to take arrays ( int[] and string[] ).

My intention was .... (click to expand)

My intent is that a set is defined as the ordered list of parsed and type-converted values. It could be an empty set, if the Arity minimum is set to zero.

Having separate .AddConstraintPerValue<T>() and .AddConstraintPerSet<T>() exposed is intentional. Why force the user to write an iterator, when these are common use cases:

• Non-negative -- just checks the value
• Positive -- just checks the value
• IsGregorianCalendarMonth -- just checks if the value exists in a set (trivial even without Linq)
• etc.

---

I hope that's clear.... let me know if I can share any other thoughts.