Merged for javadoc

Author: fluentfuture

dot-parse/src/main/java/com/google/common/labs/parse/Parser.java

@@ -29,7 +29,6 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiFunction;
 import java.util.function.Function;
-import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collector;
@@ -583,31 +582,6 @@ public final Parser<Optional<T>>.OrEmpty optional() {
     return map(Optional::ofNullable).new OrEmpty(Optional::empty);
   }
 
-  /**
-   * Returns an equivalent parser that fails if the parser result doesn't satisfy the given {@code
-   * predicate}. For example, you could use it to implement a parser for keywords:
-   *
-   * <pre>{@code
-   * consecutive(ALPHA, "word").expecting(SUPPORTED_KEYWORDS::contains, "keyword")
-   * }</pre>
-   */
-  public final Parser<T> expecting(Predicate<? super T> predicate, String name) {
-    requireNonNull(predicate);
-    requireNonNull(name);
-    Parser<T> self = this;
-    return new Parser<>() {
-      @Override MatchResult<T> skipAndMatch(
-           Parser<?> skip, String input, int start, ErrorContext context) {
-        var result = self.skipAndMatch(skip, input, start, context);
-        return switch (result) {
-          case MatchResult.Success<T> success when !predicate.test(success.value()) ->
-              context.expecting(name, success.head());
-          default -> result;
-        };
-      }
-    };
-  }
-
   /**
    * Returns an equivalent parser that suppresses character skipping that's otherwise applied if
    * {@link #parseSkipping parseSkipping()} or {@link #parseToStreamSkipping parseToStreamSkipping()}

dot-parse/src/test/java/com/google/common/labs/parse/ParserTest.java

@@ -1688,29 +1688,6 @@ public void notEmpty_twoOptionalParsers_bothFail_secondErrorIsFarther() {
     assertThat(thrown).hasMessageThat().contains("at 1:6: expecting <!>, encountered [.]");
   }
 
-  @Test
-  public void expecting_primaryParserFails() {
-    Parser<String> parser =
-        consecutive(DIGIT, "number").expecting(s -> s.length() > 1, "long number");
-    ParseException e = assertThrows(ParseException.class, () -> parser.parse("abc"));
-    assertThat(e).hasMessageThat().contains("expecting <number>, encountered [abc]");
-  }
-
-  @Test
-  public void expecting_predicateFails() {
-    Parser<?> parser =
-        consecutive(DIGIT, "number").expecting(s -> s.length() > 3, "long number").atLeastOnceDelimitedBy(",");
-    ParseException e = assertThrows(ParseException.class, () -> parser.parse("1234,5"));
-    assertThat(e).hasMessageThat().contains("at 1:6: expecting <long number>, encountered [5]");
-  }
-
-  @Test
-  public void expecting_succeeds() {
-    Parser<String> parser =
-        consecutive(DIGIT, "number").expecting(s -> s.length() > 1, "long number");
-    assertThat(parser.parse("123")).isEqualTo("123");
-  }
-
   @Test
   public void skipping_anyOfWithLiterally() {
     Parser<String> parser = anyOf(string("foo"), literally(consecutive(DIGIT, "digit")));