rename Grammar to Production

Author: fluentfuture

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

@@ -89,7 +89,7 @@
  * can cause StackOverflowError.
  */
 @ThreadSafe
-public abstract non-sealed class Parser<T> implements Grammar<T> {
+public abstract non-sealed class Parser<T> implements Production<T> {
   private static final Set<String> EMPTY_PREFIX = Set.of("");
 
   /**
@@ -501,7 +501,7 @@ public static Parser<Integer> bmpCodeUnit() {
    * @since 10.0
    */
   public static <A, B, C> Parser<C> sequence(
-      Parser<A> left, Grammar<B> right, BiFunction<? super A, ? super B, ? extends C> combiner) {
+      Parser<A> left, Production<B> right, BiFunction<? super A, ? super B, ? extends C> combiner) {
     return sequence(left, maybeZeroWidth(right), combiner);
   }
 
@@ -550,7 +550,7 @@ public static <A, B, C> Parser<C> sequence(
    * @since 9.5
    */
   public static <A, B, C, T> Parser<T> sequence(
-      Parser<A> a, Grammar<B> b, Grammar<C> c,
+      Parser<A> a, Production<B> b, Production<C> c,
       TriFunction<? super A, ? super B, ? super C, ? extends T> combiner) {
     requireNonNull(combiner);
     return sequence(
@@ -565,7 +565,7 @@ a, sequence(maybeZeroWidth(b), c, AbstractMap.SimpleImmutableEntry<B, C>::new),
    * @since 9.5
    */
   public static <A, B, C, D, T> Parser<T> sequence(
-      Parser<A> a, Grammar<B> b, Grammar<C> c, Grammar<D> d,
+      Parser<A> a, Production<B> b, Production<C> c, Production<D> d,
       Function4<? super A, ? super B, ? super C, ? super D, ? extends T> combiner) {
     requireNonNull(combiner);
     return sequence(
@@ -877,7 +877,7 @@ public final <A, R> Parser<R>.OrEmpty zeroOrMoreDelimitedBy(
    */
   public static <A, B, R> Parser<R>.OrEmpty zeroOrMoreDelimited(
       Parser<A> first,
-      Grammar<B> second,
+      Production<B> second,
       String delimiter,
       BiCollector<? super A, ? super B, R> collector) {
     return sequence(first, second, Both::of)
@@ -1038,7 +1038,7 @@ public final Parser<T> suchThat(Predicate<? super T> condition, String name) {
   }
 
   /** If this parser matches, continue to match the optional {@code suffix}. */
-  public final <S> Parser<T> followedBy(Parser<S>.OrEmpty suffix) {
+  @Override public final <S> Parser<T> followedBy(Parser<S>.OrEmpty suffix) {
     return sequence(this, suffix, (value, unused) -> value);
   }
 
@@ -1229,7 +1229,7 @@ public final Lexical skipping(CharPredicate charsToSkip) {
    *
    * <p>Equivalent to {@code skipping(skip).parse(input)}.
    */
-  public final T parseSkipping(Parser<?> skip, String input) {
+  @Override public final T parseSkipping(Parser<?> skip, String input) {
     return skipping(skip).parse(input);
   }
 
@@ -1238,7 +1238,7 @@ public final T parseSkipping(Parser<?> skip, String input) {
    *
    * <p>Equivalent to {@code skipping(charsToSkip).parse(input)}.
    */
-  public final T parseSkipping(CharPredicate charsToSkip, String input) {
+  @Override public final T parseSkipping(CharPredicate charsToSkip, String input) {
     return skipping(charsToSkip).parse(input);
   }
 
@@ -1430,7 +1430,7 @@ MatchResult.Success<T> nextOrNull() {
    * <p>Besides {@link #between between()} and {@link #followedBy(String) followedBy()}, the {@link
    * Parser#sequence(Parser, Parser.OrEmpty, BiFunction) sequence()} and {@link
    * Parser#followedBy(Parser.OrEmpty)} methods can be used to specify that a {@code Parser.OrEmpty}
-   * grammar rule follows a regular consuming {@code Parser}.
+   * production rule follows a regular consuming {@code Parser}.
    *
    * <p>The following is a simplified example of parsing a CSV line: a comma-separated list of
    * fields with an optional trailing newline. The field values can be empty; empty line results in
@@ -1453,7 +1453,7 @@ MatchResult.Success<T> nextOrNull() {
    * input in this one stop shop without having to remember to check for emptiness, because this
    * class already knows the default value to use when the input is empty.
    */
-  public final class OrEmpty implements Grammar<T> {
+  public final class OrEmpty implements Production<T> {
     private final Supplier<? extends T> defaultSupplier;
 
     private OrEmpty(Supplier<? extends T> defaultSupplier) {
@@ -1781,7 +1781,7 @@ public static <T> Parser<T> define(
   }
 
   /**
-   * A forward-declared grammar rule, to be used for recursive grammars.
+   * A forward-declared production rule, to be used for recursive grammars.
    *
    * <p>For example, to create a parser for a simple calculator that supports single-digit numbers,
    * addition, and parentheses, you can write:
@@ -1896,8 +1896,8 @@ static int skipIfAny(Parser<?> skip, CharInput input, int start) {
     };
   }
 
-  static <T> Parser<T> maybeZeroWidth(Grammar<T> grammar) {
-    return switch (grammar) {
+  static <T> Parser<T> maybeZeroWidth(Production<T> production) {
+    return switch (production) {
       case Parser<T> parser -> parser;
       case Parser<T>.OrEmpty orEmpty -> orEmpty.asUnsafeZeroWidthParser();
     };

…om/google/common/labs/parse/Grammar.java …google/common/labs/parse/Production.javadot-parse/src/main/java/com/google/common/labs/parse/Grammar.java renamed to dot-parse/src/main/java/com/google/common/labs/parse/Production.java dot-parse/src/main/java/com/google/common/labs/parse/Grammar.java renamed to dot-parse/src/main/java/com/google/common/labs/parse/Production.java

@@ -3,17 +3,20 @@
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
+import com.google.common.labs.parse.Parser.OrEmpty;
 import com.google.common.labs.parse.Parser.ParseException;
 import com.google.mu.util.CharPredicate;
 
 /**
- * A sealed interface that can either be an always-consuming {@link Parser}
- * or an optional {@link Parser.OrEmpty}. Useful as a parameter to {@code Parser.sequence()}
- * methods, so that we can avoid exponential number of overloads.
+ * A sealed interface representing an abstract production rule that can either be an
+ * always-consuming {@link Parser} or an optional {@link Parser.OrEmpty}.
+ *
+ * <p>Useful as a parameter to {@code Parser.sequence()} methods, so as to avoid exponential
+ * number of overloads.
  *
  * @since 10.0
  */
-public sealed interface Grammar<T> permits Parser, Parser.OrEmpty {
+public sealed interface Production<T> permits Parser, OrEmpty {
 
   /**
    * Parses the entire input string and returns the result. Upon successful return, the {@code
@@ -39,15 +42,15 @@ public sealed interface Grammar<T> permits Parser, Parser.OrEmpty {
    */
   T parseSkipping(CharPredicate charsToSkip, String input);
 
-  /** Returns true if this grammar matches the entirety of {@code input} string. */
+  /** Returns true if this production matches the entirety of {@code input} string. */
   boolean matches(String input);
 
-  /** The current grammar must be enclosed between non-empty {@code prefix} and {@code suffix}. */
+  /** The current production must be enclosed between non-empty {@code prefix} and {@code suffix}. */
   default Parser<T> between(String prefix, String suffix) {
     return between(Parser.string(prefix), Parser.string(suffix));
   }
 
-  /** The current grammar must be enclosed between non-empty {@code prefix} and {@code suffix}. */
+  /** The current production must be enclosed between non-empty {@code prefix} and {@code suffix}. */
   default Parser<T> between(Parser<?> prefix, Parser<?> suffix) {
     return Parser.sequence(prefix, this, (p, t) -> t).followedBy(suffix);
   }
@@ -56,13 +59,13 @@ default Parser<T> between(Parser<?> prefix, Parser<?> suffix) {
    * Returns a parser that matches {@code this} pattern enclosed between {@code prefix} and {@code suffix},
    * both allowed to be empty.
    *
-   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are declared to return the more specific
-   * {@code Parser<T>} or {@code Parser<T>.OrEmpty} subtypes respectively.
+   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are re-declared to
+   * return the more specific {@code Parser<T>} or {@code Parser<T>.OrEmpty} subtypes respectively.
    */
-  Grammar<T> between(Parser<?>.OrEmpty prefix, Parser<?>.OrEmpty suffix);
+  Production<T> between(Parser<?>.OrEmpty prefix, Parser<?>.OrEmpty suffix);
 
   /**
-   * The current grammar must be <em>immediately</em> enclosed between
+   * The current production must be <em>immediately</em> enclosed between
    * non-empty {@code prefix} and {@code suffix} (no skippable characters as specified by {@link
    * #parseSkipping parseSkipping()} in between). Useful for matching a literal string, such as
    * {@code zeroOrMore(isNot('"')).immediatelyBetween("\"", "\"")}.
@@ -72,7 +75,7 @@ default Parser<T> immediatelyBetween(String prefix, String suffix) {
   }
 
   /**
-   * After matching the current grammar, proceed to match {@code suffix}.
+   * After matching the current production, proceed to match {@code suffix}.
    */
   default <S> Parser<S> then(Parser<S> suffix) {
     return Parser.sequence(Parser.maybeZeroWidth(this), suffix, (a, b) -> b);
@@ -81,53 +84,53 @@ default <S> Parser<S> then(Parser<S> suffix) {
   /**
    * After matching the current optional (or zero-or-more) parser, proceed to match {@code suffix}.
    *
-   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are declared to
+   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are re-declared to
    * return the more specific {@code Parser<S>} or {@code Parser<S>.OrEmpty} subtypes respectively.
    */
-  <S> Grammar<S> then(Parser<S>.OrEmpty suffix);
+  <S> Production<S> then(Parser<S>.OrEmpty suffix);
 
-  /** The current grammar must be followed by non-empty {@code suffix}. */
+  /** The current production must be followed by non-empty {@code suffix}. */
   default Parser<T> followedBy(String suffix) {
     return followedBy(Parser.string(suffix));
   }
 
-  /** The current grammar must be followed by non-empty {@code suffix}. */
+  /** The current production must be followed by non-empty {@code suffix}. */
   default Parser<T> followedBy(Parser<?> suffix) {
     return Parser.sequence(Parser.maybeZeroWidth(this), suffix, (a, b) -> a);
   }
 
   /**
-   * The current grammar may optionally be followed by {@code suffix}.
+   * The current production may optionally be followed by {@code suffix}.
    *
-   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are declared to
+   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are re-declared to
    * return the more specific {@code Parser<T>} or {@code Parser<T>.OrEmpty} subtypes respectively.
    */
-  <S> Grammar<T> followedBy(Parser<S>.OrEmpty suffix);
+  <S> Production<T> followedBy(Parser<S>.OrEmpty suffix);
 
   /**
-   * Returns an equivalent grammar except it allows {@code suffix} if present.
+   * Returns an equivalent production except it allows {@code suffix} if present.
    *
-   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are declared to
+   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are re-declared to
    * return the more specific {@code Parser<T>} or {@code Parser<T>.OrEmpty} subtypes respectively.
    */
-  Grammar<T> optionallyFollowedBy(String suffix);
+  Production<T> optionallyFollowedBy(String suffix);
 
   /**
-   * If this parser matches, optionally applies the {@code op} function if this grammar is followed
+   * If this parser matches, optionally applies the {@code op} function if this production is followed
    * by {@code suffix}.
    *
-   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are declared to
+   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are re-declared to
    * return the more specific {@code Parser<T>} or {@code Parser<T>.OrEmpty} subtypes respectively.
    */
-  Grammar<T> optionallyFollowedBy(String suffix, Function<? super T, ? extends T> op);
+  Production<T> optionallyFollowedBy(String suffix, Function<? super T, ? extends T> op);
 
   /**
-   * If this grammar matches, optionally matches {@code suffix} with the {@code op} BiFunction
-   * to transform the current grammar's result.
+   * If this production matches, optionally matches {@code suffix} with the {@code op} BiFunction
+   * to transform the current production's result.
    *
-   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are declared to
+   * <p>Note that the {@link Parser} and {@link Parser.OrEmpty} implementations are re-declared to
    * return the more specific {@code Parser<T>} or {@code Parser<T>.OrEmpty} subtypes respectively.
    */
-  <S> Grammar<T> optionallyFollowedBy(
+  <S> Production<T> optionallyFollowedBy(
       Parser<S> suffix, BiFunction<? super T, ? super S, ? extends T> op);
 }

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

@@ -536,7 +536,7 @@ public void bmpCodeUnit_emoji() {
   }
 
   @Test
-  @Ignore("Grammar is a sealed interface, unsupported by NPT")
+  @Ignore("Production is a sealed interface, unsupported by NPT")
   public void testNulls() throws Exception {
     NullPointerTester tester =
         new NullPointerTester()
@@ -3836,6 +3836,7 @@ public void orEmpty_optionallyFollowedBy_string_function_success() {
         .between("[", "]");
     assertThat(parser.parse("[aa++]")).isEqualTo("aab");
     assertThat(parser.parse("[aa]")).isEqualTo("aa");
+    assertThat(parser.parse("[++]")).isEqualTo("b");
     assertThat(parser.parse("[]")).isEqualTo("");
   }
 
@@ -3848,6 +3849,7 @@ public void orEmpty_optionallyFollowedBy_parser_biFunction_success() {
         .between("[", "]");
     assertThat(parser.parse("[aa+123]")).isEqualTo("aa3");
     assertThat(parser.parse("[aa]")).isEqualTo("aa");
+    assertThat(parser.parse("[+123]")).isEqualTo("3");
     assertThat(parser.parse("[]")).isEqualTo("");
   }