anchor.diff:                          // 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 }
  +                            let repR = { rExpr with Expr = reduceSubexpr rExpr |> List.rev |> SubExpressionIfNeeded }
                               And (repL, repR) |> Unresolved |> wrapit |> Some
                           | res -> raise <| BarbExecutionException("Left hand side of And did not evaluate properly", sprintf "%A" lExpr, exprOffset, exprLength)
                       | Or (lExpr, rExpr) ->
                           // Left and side of the Or 
  -                        match reduceExpressions [] [lExpr] bindings |> fst with
  +                        match reduceSubexpr lExpr with
                           // True short curcuits 
                           | { Expr = Obj (null)} :: [] -> Obj null |> wrapit |> Some
                           | { Expr = Obj (:? bool as res)} :: [] when res = true -> Obj res |> wrapit |> Some
                           | { Expr = Obj (:? bool as res)} :: [] when res = false ->
                               // Evaluate right hand side of the Or
  -                            match reduceExpressions [] [rExpr] bindings |> fst  with
  +                            match reduceSubexpr rExpr with
                               | { Expr = Obj (null) } :: [] -> Obj null |> wrapit |> Some
                               | { Expr = Obj (:? bool as res)} :: [] -> Obj res |> wrapit |> Some
                               | res when not finalReduction -> 
  
positive.code:                         | (:? float as s), (:? float as i), (:? float as e) -> Obj (seq {s .. i .. e }) |> wrapit |> Some
                          | _ -> raise <| BarbExecutionException("Unexpected Generator Paramters", (sprintf "%A, %A, %A" s i e), exprOffset, exprLength)
                      | Generator (sexpr, iexpr, eexpr) ->
                          let rs, _ = reduceExpressions [] [sexpr] bindings
                          let ri, _ = reduceExpressions [] [iexpr] bindings
                          let re, _ = reduceExpressions [] [eexpr] bindings
                          match rs, ri, re with
                          | (({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 = SubExpressionIfNeeded s}, {iexpr with Expr = SubExpressionIfNeeded i}, {eexpr with Expr = SubExpressionIfNeeded e}
                              Generator gen |> Unresolved |> wrapit |> Some
                          | _ -> raise <| BarbExecutionException("One or more generator expressions could not be resolved", (sprintf "%A, %A, %A" rs ri re), exprOffset, exprLength)
                      | IfThenElse (ifexpr, thenexpr, elseexpr) ->
                          match reduceExpressions [] [ifexpr] bindings |> fst with
                          // If fully resolved in initial reduction, resolve and return the result clause
                          | {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 abort if it doesn't fully reduce
                      | Lambda {Params = []; Contents = lambdaContents; Bindings = lambdaBindings } -> 
  
negative.code:                         | many -> None
                      | And (lExpr, rExpr) ->
                          // Left and side of the And 
                          match reduceSubexpr lExpr with
                          // False short curcuits 
                          | { Expr = Obj (null) } :: [] -> Obj null |> wrapit |> Some
                          | { Expr = Obj (:? bool as res)} :: [] when res = false -> Obj res |> wrapit |> Some
                          | { Expr = Obj (:? bool as res)} :: [] when res = true ->
                              // Evaluate right hand side of the And
                              match reduceSubexpr rExpr 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 |> SubExpressionIfNeeded}) |> Unresolved |> wrapit |> Some
  