anchor.diff:      | h :: [] -> h.Expr
       | list -> SubExpression list
   
  +let resolveToObjs reducer wrapit resultCtor reps = 
  +    let reducedReps = 
  +        reps |> Array.map (fun t -> 
  +                match reducer t with 
  +                | res -> SubExpressionIfNeeded res |> wrapit)
  +    match reducedReps |> Array.forall (function | {Expr = Obj o} -> true | _ -> false) with
  +    | true -> reducedReps |> resultCtor |> Resolved
  +    | false -> reducedReps |> resultCtor |> Unresolved
  +    |> wrapit |> Some         
  +
  +let resolveArrayBuilder arrayReducer wrapit builderReps = 
  +    // True when all contents are Obj or reducedArray is empty                      
  +    let allObj = ref true 
  +    let arrTyp = ref None
  +    let arrTypSame = ref true
  +    let reducedArray = 
  +        builderReps
  +        |> Array.map (fun t -> 
  +                    match arrayReducer t 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   
  +
   let resolveExpression exprs initialBindings settings (finalReduction: bool) = 
   
       let rec (|ResolveSingle|_|) bindings lists =
  +            let inline reduceSubexpr subExpr = reduceExpressions [] [subExpr] bindings |> fst
  +            let inline reduceSubexprs subExpr = reduceExpressions [] subExpr bindings |> fst |> List.rev 
               match lists with 
               | left, ({ Expr = rExpr; Offset = exprOffset; Length = exprLength } & erep) :: rt ->
                   try 
  
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:                         // 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 = reduceSubexpr rExpr |> List.rev |> SubExpressionIfNeeded }
                              And (repL, repR) |> Unresolved |> wrapit |> Some
                          | res -> raise <| BarbExecutionException("Left hand side of And did not evaluate properly", sprintf "%A" lExpr, exprOffset, exprLength)
                      | Or (lExpr, rExpr) ->
                          // Left and side of the Or 
                          match reduceSubexpr lExpr with
                          // True short curcuits 
                          | { Expr = Obj (null)} :: [] -> Obj null |> wrapit |> Some
                          | { Expr = Obj (:? bool as res)} :: [] when res = true -> Obj res |> wrapit |> Some
                          | { Expr = Obj (:? bool as res)} :: [] when res = false ->
                              // Evaluate right hand side of the Or
                              match reduceSubexpr rExpr with
                              | { Expr = Obj (null) } :: [] -> Obj null |> wrapit |> Some
                              | { Expr = Obj (:? bool as res)} :: [] -> Obj res |> wrapit |> Some
                              | res when not finalReduction -> 
  