Start to tidy up parseInfixPrecedenceLevel

Author: MarcellPerger1

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

@@ -1,6 +1,20 @@
 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);

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

@@ -98,24 +98,21 @@ public MathSymbol parseInfixPrecedenceLevel(int level) throws ExprParseException
             // TODO: refactor this mess - 2 separate loops?
             //  I feel like it should be doable w/ one loop but that may involve risking NullPointerException
             //  by setting some members of LeftRightBinaryOperation to null
+            //  Actually, this first loop could be common between them if we make the other path 2 loops as well
             List<Pair<SymbolInfo, MathSymbol>> otherOps = new ArrayList<>();
             discardWhitespace();
             while((op = discardMatchesNextAny_optionsSorted(infixesToFind)) != null) {
                 SymbolInfo opInfo = Objects.requireNonNull(infixToSymbolInfo.get(op));
-                MathSymbol right = parseInfixPrecedenceLevel(level - 1);
-                otherOps.add(new Pair<>(opInfo, right));
+                MathSymbol sym = parseInfixPrecedenceLevel(level - 1);
+                otherOps.add(new Pair<>(opInfo, sym));
                 discardWhitespace();
             }
             if(otherOps.isEmpty()) return left;
-            SymbolInfo currOp = otherOps.getLast().left;
-            MathSymbol right = otherOps.removeLast().right;
-            while(!otherOps.isEmpty()) {
-                Pair<SymbolInfo, MathSymbol> currPair = otherOps.removeLast();
-                MathSymbol leftLocal = currPair.right;
-                right = currOp.getBiConstructor().construct(leftLocal, right);
-                currOp = currPair.left;
-            }
-            return currOp.getBiConstructor().construct(left, right);
+            MathSymbol javaIsAnIdiot_left = left;
+            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);
         }
         discardWhitespace();
         while((op = discardMatchesNextAny_optionsSorted(infixesToFind)) != null) {

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

@@ -1,5 +1,9 @@
 package net.marcellperger.mathexpr.util;
 
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.BiFunction;
+
 public class Pair<T, U> {
     public T left;
     public U right;
@@ -8,4 +12,22 @@ public Pair(T left, U right) {
         this.left = left;
         this.right = right;
     }
+
+    /**
+     * This is a workaround for Java not having parameter unpacking/similar.
+     * So anything that uses the unpacked variables goes inside, this is
+     * very Haskell-y ({@code let ... in ...})
+     * <p>
+     * Java: <pre>{@code pair.asVars((myLeft, myRight) -> {<function body>})}</pre>
+     * Python: <pre>{@code
+     * myLeft, myRight = pair
+     * <function body>
+     * }</pre>
+     * Haskell: <pre>{@code
+     * let (myLeft, myRight)=pair in <function body>
+     * }</pre>
+     */
+    public <R> R asVars(@NotNull BiFunction<? super T, ? super U, ? extends R> fn) {
+        return fn.apply(left, right);
+    }
 }