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)
  +let wasReducedToObjs reducedReps wrapit resultCtor = 
       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                      
  +    |> wrapit |> Some             
  +
  +let resolveArrayBuilderResults arrayElements wrapit =
       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)                         
  +        arrayElements 
  +        |> Array.map (function 
  +                        | ({ 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
  
positive.code:     and reduceExpressions (lleft: ExprRep list) (lright: ExprRep list) (bindings: Bindings) : ExprRep list * Bindings =
         reduceExpressionsCont lleft lright bindings id
  
      // Tries to merge/convert local tokens, if it can't it moves to the right
      and reduceExpressionsCont (lleft: ExprRep list) (lright: ExprRep list) (bindings: Bindings) cont : ExprRep list * Bindings =
          match lleft, lright with
  
negative.code: let resolveExpression exprs initialBindings settings (finalReduction: bool) = 
  
      let rec (|ResolveSingle|_|) bindings lists =
              let inline reduceSubexprCont subExpr  = 
                  Cont {
                      let! res = reduceExpressionsCont [] [subExpr] bindings
  