anchor.diff:                      let cleanBinds = lambda.Params |> List.fold (fun bnds pn -> if bnds |> Map.containsKey pn then bnds |> Map.remove pn else bnds) bindings         
                       let reducedExpr, _ = reduceExpressions [] [lambda.Contents] cleanBinds
                       let recLambda = 
  -                        let newLambda = {lambda with Contents = { lambda.Contents with Expr = SubExpression reducedExpr }}
  +                        let newLambda = {lambda with Contents = { lambda.Contents with Expr = SubExpressionIfNeeded reducedExpr }}
                           do newLambda.Bindings <- newLambda.Bindings |> Map.add bindName (Lambda newLambda |> Lazy.CreateFromValue)
                           { lmbExpr with Expr = Lambda newLambda }
                       let newbindings = bindings |> Map.add bindName (lazy recLambda.Expr)
  -                    let res = { bindExpr with Expr = reduceExpressions [] [boundScope] newbindings |> fst |> SubExpression }
  +                    let res = { bindExpr with Expr = reduceExpressions [] [boundScope] newbindings |> fst |> SubExpressionIfNeeded }
                       reduceExpressions left (res :: rt) newbindings
               // Normal Value Binding
               | rexpr -> 
  -                let newbindings = bindings |> Map.add bindName (lazy SubExpression rexpr) in
  -                    let res = { bindExpr with Expr = reduceExpressions [] [boundScope] newbindings |> fst |> SubExpression }
  +                let newbindings = bindings |> Map.add bindName (lazy SubExpressionIfNeeded rexpr) in
  +                    let res = { bindExpr with Expr = reduceExpressions [] [boundScope] newbindings |> fst |> SubExpressionIfNeeded }
                       reduceExpressions left (res :: rt) bindings
           | ResolveSingle bindings (res, lt, rt)
           | ResolveTuple bindings (res, lt, rt) 
  
positive.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 |> subexprIfNeeded}) 
                                  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 |> subexprIfNeeded }
                              let repR = { rExpr with Expr = reduceExpressions [] [rExpr] bindings |> fst |> List.rev |> subexprIfNeeded }
                              Or (repL, repR) |> Unresolved |> wrapit |> Some
                          | res -> failwith (sprintf "Left hand side of Or did not evaluate properly: %A" lExpr)
                      | _ -> None
  
negative.code:                             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 |> 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 |> 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) ->
  