anchor.diff:              Rule max = _maxRule(options);
               rules.add(max);
           }
  +        if (options.hasExtension(Options.range)) {
  +            Iterable<Rule> range = _rangeRules(options);
  +            rules.addAll(range);
  +        }
           return rules;
       }
   
       Rule _minRule(FieldOptions options) {
           var min = options.getExtension(Options.min) as MinOption;
  -        var bound = parse(min.value);
  +        var bound = _parse(min.value);
           var exclusive = min.exclusive;
  +        return _constructMinRule(bound, exclusive);
  +    }
  +    
  +    Rule _constructMinRule(N bound, bool exclusive) {
           var literal = literalNum(bound);
           var check = exclusive
                       ? (Expression v) => v.lessOrEqualTo(literal)
  
positive.code:                 .assign(value)
                  .statement).closure]);
          var any = refer('Any', protoAnyImport(standardPackage)).property('pack').call([floatValue]);
          return violationRef.call([literalString('Float field is out of bound.'),
                                    literalString(validatorFactory.fullTypeName),
                                    literalList([field.name]),
                                    any]);
  
negative.code: 
      Rule _maxRule(FieldOptions options) {
          var max = options.getExtension(Options.max) as MaxOption;
          var bound = _parse(max.value);
          var exclusive = max.exclusive;
          return _constructMaxRule(bound, exclusive);
      }
  
      Rule _constructMaxRule(bound, bool exclusive) {
        var literal = literalNum(bound);
        var check = exclusive
                    ? (Expression v) => v.greaterOrEqualTo(literal)
                    : (Expression v) => v.greaterThan(literal);
        var rule = newRule((v) => check(v), _outOfBound);
        return rule;
      }
      
      Iterable<Rule> _rangeRules(FieldOptions options) {
          var rangeNotation = options.getExtension(Options.range) as String;
          var rangePattern = RegExp(_numericRange);
          var match = rangePattern.firstMatch(rangeNotation.trim());
          if (match == null) {
              throw ArgumentError('Malformed range: `$rangeNotation`. '
                                  'See doc of (range) for the proper format.');
          }
          var startOpen = match.group(1) == '(';
          var start = _parse(match.group(2));
          var end = _parse(match.group(3));
          var endOpen = match.group(4) == ')';
  
          var minRule = _constructMinRule(start, startOpen);
          var maxRule = _constructMaxRule(end, endOpen);
          return [minRule, maxRule];
      }
  
      // TODO:2019-10-14:dmytro.dashenkov: Support custom error messages based on the option value.
      // https://github.com/SpineEventEngine/base/issues/482
  