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:                         | (({Expr = Obj(s)} :: []), ({Expr = Obj(i)} :: []), ({Expr = Obj(e)} :: [])) -> 
                              Generator ({sexpr with Expr = Obj(s)}, {iexpr with Expr = Obj(i)}, {eexpr with Expr = Obj(e)}) |> wrapit |> Some
                          | s, i, e when not finalReduction -> 
                              let gen = {sexpr with Expr = SubExpression s}, {iexpr with Expr = SubExpression i}, {eexpr with Expr = SubExpression e}
                              Generator gen |> Unresolved |> wrapit |> Some
                          | _ -> failwith (sprintf "One or more generator expressions could not be resolved: %A, %A, %A" rs ri re)
                      | IfThenElse (ifexpr, thenexpr, elseexpr) ->
  
negative.code:                         | {Expr = Obj (:? bool as res)} :: [] -> 
                              if res then reduceExpressions [] [thenexpr] bindings
                              else reduceExpressions [] [elseexpr] bindings
                              |> fun resExpr -> resExpr |> fst |> SubExpressionIfNeeded |> wrapit |> Some
                          // If not fully resolved in initial reduction, reduce both clauses and return the result
                          // Note: If in the future globally scoped Variables are added, resolving them here will cause problems with inner non-pure calls
                          | rif -> 
                              let repIf = { ifexpr with Expr = rif |> List.rev |> SubExpressionIfNeeded }
                              let repThen = { thenexpr with Expr = reduceExpressions [] [thenexpr] bindings |> fst |> List.rev |> SubExpressionIfNeeded }
                              let repElse = { elseexpr with Expr = reduceExpressions [] [elseexpr] bindings |> fst |> List.rev |> SubExpressionIfNeeded }
                              IfThenElse (repIf, repThen, repElse) |> Unresolved |> wrapit |> Some
                      // Execute Lambda when fully applied, but only on final reduction to preserve semantics
                      | Lambda ({Params = []} & l) when finalReduction -> 
                          let totalBindings = Seq.concat [(Map.toSeq initialBindings); (Map.toSeq l.Bindings)] |> Map.ofSeq
                          reduceExpressions [] [l.Contents] totalBindings |> fst |> SubExpressionIfNeeded |> wrapit |> Some
                      | And (lExpr, rExpr) ->
                          // Left and side of the And 
                          match reduceExpressions [] [lExpr] bindings |> fst with
  