anchor.diff:     * parsed `operator` and `value`.
      */
     void prefix(Parser operator, [void action(operator, value)]) {
  -    _prefix.add(new _PrefixOperator(operator, action));
  +    _operators.putIfAbsent(_PREFIX, () => new List())
  +        .add(new _ExpressionOperator(operator, action, (operators, next) {
  +          return new _SequenceParser([operators, next]).map((results) {
  +            return results.first.action(results.first.value, results.last);
  +          });
  +        }));
     }
   
     /**
  
positive.code: }
  
  class _ExpressionOperator {
    final Parser operator;
    final Function action;
    _ExpressionOperator(this.operator, this.action);
  }
  
  class _PrimitiveOperator implements _ExpressionOperator {
    _PrimitiveOperator(operator, action) : super(operator, action);
  }
  
negative.code:    * term.
     */
    void left(Parser operator, [void action(left, operator, right)]) {
      _operators.putIfAbsent(_LEFT, () => new List())
          .add(new _ExpressionOperator(operator, action, (operators, next) {
            return next.separatedBy(operators);
          }));
    }
  
    Parser _build(Parser parser) {
      var priorities = new List.from(_operators.keys)
          ..sort()
          ..map((priority) => _operators[priority]);
      return priorities.fold(parser, (parser, operators) {
        if (operators.isEmpty) {
          return parser;
        } else {
          var choice = operators
              .map((operator) => operator.parser.map((result) {
                return new _ExpressionOperatorResult(result, operator.action);
              }))
              .reduce((a, b) => a.or(b));
          return operators.combinator(choice, parser);
        }
      });
    }
  