anchor.diff:                          // Left hand side did not evaluate fully, try to reduce both and return
                           | res when not finalReduction -> 
                               let repL = { lExpr with Expr = res |> List.rev |> SubExpressionIfNeeded }
  -                            let repR = { rExpr with Expr = reduceExpressions [] [rExpr] bindings |> fst |> List.rev |> SubExpressionIfNeeded }
  +                            let repR = { rExpr with Expr = reduceSubexpr rExpr |> List.rev |> SubExpressionIfNeeded }
                               Or (repL, repR) |> Unresolved |> wrapit |> Some
                           | res -> raise <| BarbExecutionException("Left hand side of Or did not evaluate properly", sprintf "%A" lExpr, exprOffset, exprLength)
                       | _ -> None
  
positive.code:                     match rExpr with
                      | Returned o -> resolveResultType o |> wrapit |> Some
                      | SubExpression exp ->
                          match reduceExpressions [] exp bindings |> fst |> List.rev with
                          | single :: [] -> single
                          | many -> SubExpression many |> Unresolved |> wrapit
                          |> Some
                      | IndexArgs tc -> 
                          let reducedTuples = 
                              tc |> Array.map (fun t -> 
                                      match reduceExpressions [] [t] bindings |> fst  with 
                                      | res -> SubExpressionIfNeeded res |> wrapit)
                          match reducedTuples |> Array.forall (function | {Expr = Obj o} -> true | _ -> false) with
                          | true -> reducedTuples |> IndexArgs |> Resolved
                          | false -> reducedTuples |> IndexArgs |> Unresolved
                          |> wrapit |> Some           
                      | Tuple tc -> 
                          let reducedTuples = 
                              tc |> Array.map (fun t -> 
                                      match reduceExpressions [] [t] bindings |> fst  with 
                                      | res -> SubExpressionIfNeeded res |> wrapit)
                          match reducedTuples |> Array.forall (function | {Expr = Obj o} -> true | _ -> false) with
                          | true -> reducedTuples |> Tuple |> Resolved
                          | false -> reducedTuples |> Tuple |> Unresolved
                          |> wrapit |> Some           
                      | ArrayBuilder ar ->  
                          // True when all contents are Obj or reducedArray is empty                      
                          let allObj = ref true 
                          let arrTyp = ref None
                          let arrTypSame = ref true
                          let reducedArray = 
                              ar |> Array.map (fun t -> 
                                      match reduceExpressions [] [t] bindings |> fst  with 
                                      | ({ Expr = Obj o } & oobj) :: [] -> 
                                          let oTyp = o.GetType()
                                          if !arrTypSame then
                                              match !arrTyp with
                                              | None -> arrTyp := Some oTyp
                                              | Some aTyp when aTyp = oTyp -> ()
                                              | Some aTyp -> arrTyp := None; arrTypSame := false
                                          oobj 
                                      | res -> allObj := false; SubExpressionIfNeeded res |> wrapit)                         
                          match !allObj, reducedArray |> Array.isEmpty, !arrTyp with
                          | true, false, Some typ -> 
                              // Create Typed Array
                              let objArr = reducedArray |> exprRepsToObjsArray
                              let newArr = Array.CreateInstance(typ, objArr.Length)
                              do Array.Copy(objArr, newArr, objArr.Length) 
                              newArr |> box |> Obj
                          | true, false, None -> 
                              // Create Untyped Array
                              reducedArray |> exprRepsToObj |> Obj
                          | false, false, _ -> 
                              // Created unresolved expression
                              reducedArray |> ArrayBuilder |> Unresolved
                          | _ -> [||] |> box |> Obj
                          |> wrapit |> Some            
                      | Unknown unk -> 
                          match bindings |> Map.tryFind unk with
                          | Some ComingLater when finalReduction -> raise <| BarbExecutionException(sprintf "Expected value not bound: %s" unk, (sprintf "%A" lists), exprOffset, exprLength)
  
negative.code:         | l,  r :: rt -> reduceExpressions (r :: l) rt bindings
          // Single Element, Done Reducing
          | l :: [], [] -> [l], bindings
          // Unexpected case, fail with  error message
          | ((lh :: lr) & left, (rh :: rr) & right) when finalReduction -> 
              let offset, length = 
                  match (left, right) with
  