anchor.diff:        var check = exclusive
                     ? (Expression v) => v.greaterOrEqualTo(literal)
                     : (Expression v) => v.greaterThan(literal);
  -      var requiredString = _Rule((v) => check(v),
  -                                 _outOfBound,
  -                                 validatorFactory.violationList);
  +      var requiredString = _rule((v) => check(v), _outOfBound);
         return requiredString;
       }
   
  
positive.code:       var check = exclusive
                    ? (Expression v) => v.lessOrEqualTo(literal)
                    : (Expression v) => v.lessThan(literal);
        var requiredString = _Rule((v) => check(v),
                                   _outOfBound,
                                   validatorFactory.violationList);
        return requiredString;
      }
  
  
negative.code:         : super._(validatorFactory, field);
  
      Iterable<_Rule> _rules() {
          var options = field.options;
          var rules = <_Rule>[];
          if (options.hasExtension(Options.required) && options.getExtension(Options.required)) {
              var requiredString = _rule((v) => v.property('isEmpty'),
                                         (v) => _requiredMissing());
              rules.add(requiredString);
          }
          if (options.hasExtension(Options.pattern)) {
              PatternOption pattern = options.getExtension(Options.pattern);
              var rule = _rule((v) => refer('RegEx').newInstance([literalString(pattern.regex)])
                                                    .property('stringMatch')
                                                    .call([v])
                                                    .equalTo(v),
                               (v) => _patternMismatch(pattern.regex));
              rules.add(rule);
          }
          return rules;
      }
  
      Expression _patternMismatch(String pattern) {
          var message = 'String must match the regular expression `$pattern`';
          return violationRef.call([literalString(message),
                                    literalString(validatorFactory.fullTypeName),
                                    literalList([field.name])]);
      }
  }
  
  