anchor.diff:                              match reduceExpressions [] [rExpr] bindings |> fst with
                               | { Expr = Obj (null) } :: [] -> Obj null |> wrapit |> Some
                               | { Expr = Obj (:? bool as res)} :: [] -> Obj res |> wrapit |> Some
  -                            | res when not finalReduction -> And ({lExpr with Expr = Obj true}, {rExpr with Expr = res |> List.rev |> subexprIfNeeded}) |> Unresolved |> wrapit |> Some
  +                            | res when not finalReduction -> And ({lExpr with Expr = Obj true}, {rExpr with Expr = res |> List.rev |> SubExpressionIfNeeded}) |> Unresolved |> wrapit |> Some
                               | res -> failwith (sprintf "Right hand side of And did not evaluate properly: %A" rExpr)
                           // 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 |> subexprIfNeeded }
  -                            let repR = { rExpr with Expr = reduceExpressions [] [rExpr] bindings |> fst |> List.rev |> subexprIfNeeded }
  +                            let repL = { lExpr with Expr = res |> List.rev |> SubExpressionIfNeeded }
  +                            let repR = { rExpr with Expr = reduceExpressions [] [rExpr] bindings |> fst |> List.rev |> SubExpressionIfNeeded }
                               And (repL, repR) |> Unresolved |> wrapit |> Some
                           | res -> failwith (sprintf "Right hand side of And did not evaluate properly: %A" rExpr)
                       | Or (lExpr, rExpr) ->
  
positive.code:                             tc |> Array.map (fun t -> 
                                      match reduceExpressions [] [t] bindings |> fst  with 
                                      | ({ Expr = Obj o } & oobj) :: [] -> oobj 
                                      | res -> SubExpression res |> wrapit)
                          match reducedTuples |> Array.forall (function | {Expr = Obj o} -> true | _ -> false) with
                          | true -> reducedTuples |> (fun tc -> Obj (tupleToObj tc |> box))
                          | false -> reducedTuples |> Tuple |> Unresolved
  
negative.code:                             | { Expr = Obj (null) } :: [] -> Obj null |> wrapit |> Some
                              | { Expr = Obj (:? bool as res)} :: [] -> Obj res |> wrapit |> Some
                              | res when not finalReduction -> 
                                  let orExpr = Or ({lExpr with Expr = Obj false}, {rExpr with Expr = res |> List.rev |> SubExpressionIfNeeded}) 
                                  orExpr |> Unresolved |> wrapit |> Some
                              | res -> failwith (sprintf "Right hand side of Or did not evaluate properly: %A" rExpr)
                          // 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 }
                              Or (repL, repR) |> Unresolved |> wrapit |> Some
                          | res -> failwith (sprintf "Left hand side of Or did not evaluate properly: %A" lExpr)
                      | _ -> None
  