Un-generic-ify BinOpBiConstructor

Author: MarcellPerger1

src/main/java/net/marcellperger/mathexpr/BinOpBiConstructor.java

@@ -1,21 +1,10 @@
 package net.marcellperger.mathexpr;
 
 
-// TODO: this is stupid - it should not be generic!!! It should return a MathSymbol always
-//  (not a specific subclass but exactly a `impl MathSymbol` that MUST BE CAST)
-//  i.e. we want this to be like `MathSymbol construct(MathSymbol left, MathSymbol right)`
-//  similar to `List<T> of(T... values)` is NOT `(? extends List<T>) of(T... values)`
-//  (or maybe could be generic on method? but probably bad idea)
-//  This is NOT rust, you don't need to make it explicit `impl MathSymbol`
-//  i.e. currently:
-//    trait BinOpBinConstructor<R: MathSymbol> {
-//        fn construct(MS left, MS right) -> R;
-//    }
-//  and we want:
-//    trait BinOpBiConstructor {
-//        fn construct(MS left, MS right) -> (dyn?) impl MS;
-//    }
 @FunctionalInterface
-public interface BinOpBiConstructor<R extends MathSymbol> {
-    R construct(MathSymbol left, MathSymbol right);
+public interface BinOpBiConstructor {
+    // NOTE: Not generic, but implementations will just return `MathSymbol`
+    // (which is allowed to be any subclass of MathSymbol) similar to
+    // `List<T> of(T... values)` can return any `List` implementation
+    MathSymbol construct(MathSymbol left, MathSymbol right);
 }

src/main/java/net/marcellperger/mathexpr/SymbolInfo.java

@@ -46,7 +46,7 @@ public enum SymbolInfo {
     }
     SymbolInfo(Class<? extends BinaryOperationLeftRight> cls, int precedence,
                GroupingDirection groupingDirection, @Nullable String infix,
-               BinOpBiConstructor<?> biConstructor) {
+               BinOpBiConstructor biConstructor) {
         this.precedence = precedence;
         this.cls = cls;  // TODO: private + getters?
         this.groupingDirection = groupingDirection;
@@ -69,8 +69,8 @@ public enum SymbolInfo {
         return Util.chainNulls(fromClass(cls), x -> x.infix);
     }
 
-    private BinOpBiConstructor<?> biConstructorCache = null;
-    public @NotNull BinOpBiConstructor<?> getBiConstructor() {
+    private BinOpBiConstructor biConstructorCache = null;
+    public @NotNull BinOpBiConstructor getBiConstructor() {
         if(biConstructorCache != null) return biConstructorCache;
         assert BinaryOperationLeftRight.class.isAssignableFrom(cls);
 

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

@@ -112,13 +112,13 @@ public MathSymbol parseInfixPrecedenceLevel(int level) throws ExprParseException
             return otherOps.reversed().stream().reduce((rightpair, leftpair) ->
                 leftpair.asVars((preOp, argL) ->
                     new Pair<>(preOp, rightpair.asVars((midOp, argR) -> midOp.getBiConstructor().construct(argL, argR))))
-            ).map(p -> p.<MathSymbol>asVars((midOp, argR) -> midOp.getBiConstructor().construct(javaIsAnIdiot_left, argR))).orElse(left);
+            ).map(p -> p.asVars((midOp, argR) -> midOp.getBiConstructor().construct(javaIsAnIdiot_left, argR))).orElse(left);
         }
         discardWhitespace();
         while((op = discardMatchesNextAny_optionsSorted(infixesToFind)) != null) {
             SymbolInfo opInfo = Objects.requireNonNull(infixToSymbolInfo.get(op));
             MathSymbol right = parseInfixPrecedenceLevel(level - 1);
-            BinOpBiConstructor<?> ctor = opInfo.getBiConstructor();
+            BinOpBiConstructor ctor = opInfo.getBiConstructor();
             left = ctor.construct(left, right);
             discardWhitespace();
         }

src/test/java/net/marcellperger/mathexpr/parser/ParserTest.java

@@ -216,15 +216,15 @@ public void close() {
         // region implementation details (ctor, clearCache, restoreCache
         private WithSuppressingCache() {}
 
-        private Map<SymbolInfo, Optional<BinOpBiConstructor<?>>> origCache = null;
+        private Map<SymbolInfo, Optional<BinOpBiConstructor>> origCache = null;
 
         protected void clearCache() {
             Field cacheField = getBiConstructorCache();
             origCache = Arrays.stream(SymbolInfo.values()).map(sym -> {
                 try {
-                    @Nullable BinOpBiConstructor<?> cachedValue = (BinOpBiConstructor<?>)cacheField.get(sym);
+                    @Nullable BinOpBiConstructor cachedValue = (BinOpBiConstructor)cacheField.get(sym);
                     cacheField.set(sym, null);
-                    return Util.makeEntry(sym, Optional.<BinOpBiConstructor<?>>ofNullable(cachedValue));
+                    return Util.makeEntry(sym, Optional.ofNullable(cachedValue));
                 } catch (IllegalAccessException e) {
                     throw Util.excToError(e);
                 }