Allow empty precedence levels

Author: MarcellPerger1

src/main/java/net/marcellperger/mathexpr/parser/Parser.java

@@ -80,11 +80,10 @@ public MathSymbol parseInfixPrecedenceLevel(int level) throws ExprParseException
         if(level == 0) {
             return parseParensOrLiteral();
         }
-        // TODO remove this next-line:
-        if(SymbolInfo.PREC_TO_INFO_MAP.get(level) == null) { return parseInfixPrecedenceLevel(level - 1); }
-        Set<SymbolInfo> symbols = Util.requireNonEmptyNonNull(SymbolInfo.PREC_TO_INFO_MAP.get(level));
+        Set<SymbolInfo> symbols = SymbolInfo.PREC_TO_INFO_MAP.get(level);
+        if(symbols == null || symbols.isEmpty()) return parseInfixPrecedenceLevel(level - 1);
         @Nullable GroupingDirection dirn = symbols.stream()
-            .map(sm -> sm.groupingDirection).distinct().collect(UtilCollectors.singleItem());
+            .map(sm -> sm.groupingDirection).collect(UtilCollectors.singleDistinctItem());
         Map<String, SymbolInfo> infixToSymbolInfo = symbols.stream().collect(  // TODO pre-compute/cache these
             Collectors.toUnmodifiableMap(
                 si -> Objects.requireNonNull(si.infix, "null infix not allowed for parseInfixPrecedenceLevel"),

src/main/java/net/marcellperger/mathexpr/util/Util.java

@@ -1,16 +1,15 @@
 package net.marcellperger.mathexpr.util;
 
 
+import org.intellij.lang.annotations.Flow;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.AbstractMap;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.stream.Stream;
 
 @SuppressWarnings("unused")
 public class Util {
@@ -168,4 +167,13 @@ public static void realAssert(boolean b, String msg, Throwable cause) {
     public static @NotNull <K, V> Map.Entry<K, V> makeEntry(K k, V v) {
         return new AbstractMap.SimpleImmutableEntry<>(k, v);
     }
+
+    public static<T> T getOnlyItem(@Flow(sourceIsContainer = true) @NotNull Collection<T> c) {
+        if(c.size() != 1) throw new CollectionSizeException("Expected collection to have 1 item");
+        return c.iterator().next();
+    }
+    public static<T> T getOnlyItem(@Flow(sourceIsContainer = true) @NotNull SequencedCollection<T> c) {
+        if(c.size() != 1) throw new CollectionSizeException("Expected collection to have 1 item");
+        return c.getFirst();
+    }
 }

src/main/java/net/marcellperger/mathexpr/util/UtilCollectors.java

@@ -14,11 +14,10 @@ protected UtilCollectors() {}  // prevent instantiation, allow subclassing
 
     @Contract(" -> new")
     public static <T> @NotNull Collector<T, ?, T> singleItem() {
-        return Collectors.collectingAndThen(
-            Collectors.toList(),
-            items -> Util.expectOrFail(items, items.size() == 1,
-                new CollectionSizeException("UtilCollectors.singleItem expected a single item")).getFirst()
-        );
+        return Collectors.collectingAndThen(Collectors.toList(), Util::getOnlyItem);
+    }
+    public static <T> @NotNull Collector<T, ?, T> singleDistinctItem() {
+        return Collectors.collectingAndThen(Collectors.toSet(), Util::getOnlyItem);
     }
 
     public static <K, V> @NotNull Collector<Entry<K, V>, ?, Map<K, V>> entriesToUnmodifiableMap() {