code: public final Parser<T> postfix(Parser<? extends Function<? super T, ? extends T>> op) {
      return Parsers.sequence(this, op.many(), Parser::applyPostfixOperators);
    }
docs: A {@link Parser} that runs {@code this} and then runs {@code op} for 0 or more times greedily.
  The {@link Function} objects returned from {@code op} are applied from left to right to the return
  value of p.
  
  <p>This is the preferred API to avoid {@code StackOverflowError} in left-recursive parsers.
  For example, to parse array types in the form of "T[]" or "T[][]", the following
  left recursive grammar will fail: <pre>   {@code
  Terminals terms = Terminals.operators("[", "]");
  Parser.Reference<Type> ref = Parser.newReference();
  ref.set(Parsers.or(leafTypeParser,
  Parsers.sequence(ref.lazy(), terms.phrase("[", "]"), new Unary<Type>() {...})));
  return ref.get();
  }</pre>
  A correct implementation is:  <pre>   {@code
  Terminals terms = Terminals.operators("[", "]");
  return leafTypeParer.postfix(terms.phrase("[", "]").retn(new Unary<Type>() {...}));
  }</pre>
  A not-so-obvious example, is to parse the {@code expr ? a : b} ternary operator. It too is a
  left recursive grammar. And un-intuitively it can also be thought as a postfix operator.
  Basically, we can parse "? a : b" as a whole into a unary operator that accepts the condition
  expression as input and outputs the full ternary expression: <pre>   {@code
  Parser<Expr> ternary(Parser<Expr> expr) {
  return expr.postfix(
  Parsers.sequence(
  terms.token("?"), expr, terms.token(":"), expr,
  (unused, then, unused, orelse) -> cond ->
  new TernaryExpr(cond, then, orelse)));
  }
  }</pre>
  {@link OperatorTable} also handles left recursion transparently.
  
  <p> {@code p.postfix(op)} is equivalent to {@code p op*} in EBNF.