anchor.diff:      and reduceExpressions (lleft: ExprRep list) (lright: ExprRep list) (bindings: Bindings) : ExprRep list * Bindings =
          reduceExpressionsCont lleft lright bindings id
   
  +    and reduceEachExpression exprs bindings =
  +        Cont {
  +            match exprs with
  +            | h :: t -> 
  +                let! res = reduceExpressionsCont [] [h] bindings
  +                let res = res |> fst
  +                let! rest = reduceEachExpression t bindings
  +                let comb = res :: rest
  +                return comb 
  +            | [] -> return []
  +        }
  +
       // 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
  
positive.code: let resolveExpression exprs initialBindings settings (finalReduction: bool) = 
  
      let rec (|ResolveSingle|_|) bindings lists =
              let inline reduceSubexpr subExpr = reduceExpressions [] [subExpr] bindings |> fst
              let inline reduceSubexprCont subExpr  = 
                  Cont {
                      let! res = reduceExpressionsCont [] [subExpr] bindings
  
negative.code:     | h :: [] -> h.Expr
      | list -> SubExpression list
  
  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 resolveArrayBuilderResults arrayElements wrapit =
      let allObj = ref true 
      let arrTyp = ref None
      let arrTypSame = ref true
      let reducedArray = 
          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
  