code: static Lexicon lexicon(final Collection<String> operatorNames) {
      final Map<String, Object> operators = new HashMap<String, Object>();
      final String[] ops = sort(operatorNames.toArray(new String[operatorNames.size()]));
      final Parser<?>[] lexers = new Parser<?>[ops.length];
      for (int i = 0; i < ops.length; i++) {
        String s = ops[i];
        Parser<?> scanner = s.length() == 1 ? Scanners.isChar(s.charAt(0)) : Scanners.string(s);
        Object value = Tokens.reserved(s);
        operators.put(s, value);
        lexers[i] = scanner.retn(value);
      }
      return new Lexicon(operators::get, Parsers.or(lexers));
    }
docs: Gets a {@link Lexicon} instance with {@link Tokens#reserved(String)} as each operator's value
  and a lexer that strives to try the shortest operator first.
  
  <p> Safely speaking, we can always start from the longest operator and falls back to shorter
  ones. Yet shorter operators are more often used than longer ones and the scanning of them is
  faster. However, scanning shorter operators first has the chance that a "==" is mistakenly
  scanned as "=" followed by another "=". In order to avoid this, we analyze the prefix
  relationship and make sure that prefixes are scanned after prefixes.