Refactor resolve infixes in preparation to have it take NonEmpty list

app/RawExpFuncs.hs

@@ -73,42 +73,48 @@ resolveAllInfixesForExp x =
 
 resolveInfixesForOperator :: IsTrace a => InfixOperator -> RawExp a -> RawExp a
 resolveInfixesForOperator (op, LeftAssoc) (RawApply a xs) =
-    let xs' = reverse $ resolveInfixesForOperator' op [] $ reverse (NE.toList xs)
-    in RawApply a $ NE.fromList xs'
-resolveInfixesForOperator (op, RightAssoc) (RawApply a xs) =
-    let xs' = resolveInfixesForOperator' op [] $ NE.toList xs
+    let (expr:|xs') = NE.reverse xs
+        resolved = resolveInfixesForOperator' op [] expr xs'
+        xs'' = reverse resolved
+    in RawApply a $ NE.fromList xs''
+resolveInfixesForOperator (op, RightAssoc) (RawApply a (expr:|xs)) =
+    let xs' = resolveInfixesForOperator' op [] expr xs
     in RawApply a $ NE.fromList xs'
 resolveInfixesForOperator _ x = x
 
-resolveInfixesForOperator' :: IsTrace a => T.Text -> [RawExp a] -> [RawExp a] -> [RawExp a]
-resolveInfixesForOperator' op acc (x@(RawIdent _ name):xs) =
+resolveInfixesForOperator' :: IsTrace a =>
+    T.Text -> [RawExp a] -> RawExp a -> [RawExp a] -> [RawExp a]
+-- base case
+resolveInfixesForOperator' _ acc expr [] = reverse $ expr:acc
+-- special case
+resolveInfixesForOperator' op acc expr@(RawIdent _ name) xs =
     if op == name
     then
         let arg0 = case acc of
                 [] ->
-                    let a' = L.foldl' (<>) (getRange x) (getRange <$> xs)
-                    in RawApply a' (x:|xs)
+                    let a' = L.foldl' (<>) (getRange expr) (getRange <$> xs)
+                    in RawApply a' (expr:|xs)
                 [x'] -> x'
                 (x':xs') ->
                     let (x'':xs'') = reverse (x':xs')
                         a' = L.foldl' (<>) (getRange x'') (getRange <$> xs'')
                     in RawApply a' (x'':|xs'')
             arg1 = case xs of
                 [] ->
-                    let (x':xs') = reverse (x:acc)
+                    let (x':xs') = reverse (expr:acc)
                         a' = L.foldl' (<>) (getRange x') (getRange <$> xs')
                     in RawApply a' (x':|xs')
                 [x'] -> x'
                 (x':xs') ->
                     let a' = L.foldl' (<>) (getRange x') (getRange <$> xs')
                     in RawApply a' (x':|xs')
-        in [x, arg0, arg1]
+        in [expr, arg0, arg1]
     else
-        resolveInfixesForOperator' op (x:acc) xs
+        let (expr':xs') = xs
+        in resolveInfixesForOperator' op (expr:acc) expr' xs'
 -- continuation case
-resolveInfixesForOperator' op acc (x:xs) = resolveInfixesForOperator' op (x:acc) xs
--- base case
-resolveInfixesForOperator' _ acc [] = reverse $ acc
+resolveInfixesForOperator' op acc expr (expr':xs) =
+    resolveInfixesForOperator' op (expr:acc) expr' xs
 
 removeParens :: RawExp a -> RawExp a
 removeParens x =