anchor.diff:      match !allObj, reducedArray |> Array.isEmpty, !arrTyp with
       | true, false, Some typ -> 
           // Create Typed Array
  -        let objArr = reducedArray |> exprRepsToObjsArray
  +        let objArr = reducedArray |> exprRepsToObjs
           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
  +        reducedArray |> exprRepsToObjs |> box |> Obj
       | false, false, _ -> 
           // Created unresolved expression
           reducedArray |> ArrayBuilder |> Unresolved
  
positive.code:                         | result :: [] -> result |> Some
                          | many -> None
                      | And (lExpr, rExpr) ->
                          // Left and side of the And 
                          match reduceSubexpr lExpr with
                          // False short curcuits 
  
negative.code:     | :? int64 as idx -> elements.[int idx] 
      | _ -> failwith (sprintf "Bad type for tuple index: %A" index)
  
  let exprRepsToObjs (tuple: ExprRep array) = 
      tuple |> Array.map (fun ex -> ex.Expr) 
      |> Array.map (function | Obj v -> v | other -> failwith (sprintf "Cannot resolve the given tuple-internal expression to a object type: %A" other))    
  
  let resolveExpressionResult (input: ExprRep list) =
      match input with
      | { Expr = Obj (res) } :: [] -> res
      | { Expr = Tuple (items) } :: [] -> exprRepsToObjs items |> box
      | otherTokens -> failwith (otherTokens |> List.fold (fun s t -> s + (sprintf "Unexpected result: %A" t.Expr)) "")
  
  let applyArgToLambda (l: LambdaRecord) (arg: obj) =
  