anchor.diff:  
                   let ``constructor`` = ``type``.GetConstructor [| ``function``.GetType () |]
   
  +                let theFuncObject = Expression.Variable (``type``, "funcObject")
  +
                   match capturedVars with
                   | [] ->
                       let obj = ``constructor``.Invoke [| ``function`` |]
  -                    Expression.Constant (obj) |> asExpr
  +                    let func = Expression.Constant (obj) 
  +                    if letRecVar.IsSome then
  +                        // TODO: Simplify this; I only really need to return theFuncObject
  +                        AsLetRecExpression (
  +                            theFuncObject,
  +                            Expression.Assign(theFuncObject, func),
  +                            Expression.Empty () :> Expression)
  +                    else
  +                        func|> asExpr
                   | _ ->
  -                    let construction = Expression.Variable (``type``, "construction")
  -
  -                    let getVar var =
  -                        if Some var = env.letrec
  -                            then construction |> asExpression
  -                            else Map.find var env.varEnv
  +                    let newObject = 
  +                        Expression.New (
  +                            ``constructor``,
  +                            [Expression.Constant(``function``) |> asExpression])
   
                       let state =
  +                        let getVar var =
  +                            if Some var = letRecVar
  +                                then theFuncObject |> asExpression
  +                                else Map.find var env.varEnv
  +
                           match capturedVars with
                           | v1 :: [] -> getVar v1
                           | _ ->
  
positive.code:             | 21 -> typedefof<FuncHelper<_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_>>.MakeGenericType args
              | _ -> raise <| new NotSupportedException("Quotation expressions with statements or closures containing more then 20 free variables may not be translated in this release of the F# PowerPack. This is due to limitations in the variable binding expression forms available in LINQ expression trees")
              
  
      let LetRec1Helper (F1:System.Func<_,_,_>) (B:System.Func<_,_>) = 
          let fhole = ref (Unchecked.defaultof<_>)
          let f = new System.Func<_,_>(fun x -> F1.Invoke(fhole.Value,x))
  
negative.code:                 vPs
                  |> List.map (fun (v, vP, e) ->
                      let env = { env with letrec = Some v }
                      let funcObject, assignToConstruction, assignState = 
                          match LetRecConvExpr env e with
                          | AsLetRecExpression (funcObject, assignToFuncObject, assignState) -> funcObject, assignToFuncObject, assignState
                          | _ -> failwith "Logic error"
                      vP, funcObject, assignToConstruction, assignState)
  
              let assignToLocalObject =
                  vePs
                  |> List.map (fun (_,_,assignToFuncObject,_) -> assignToFuncObject)
  
              let assignToFuncObject =
                  vePs
                  |> List.map (fun (vP, funcObject, assignToConstruction, assignState) ->
                      Expression.Assign (vP, funcObject) |> asExpression)
                  
              let assignState =
                  vePs
                  |> List.map (fun (vP, funcObject, assignToConstruction, assignState) -> assignState)
  
              let bodyP = ConvExpr env body
  
              Expression.Block (
                  vePs |> List.collect (fun (v,fo,_,_) -> [ v; fo ]),
                  [
                      yield! assignToLocalObject;
                      yield! assignToFuncObject;
                      yield! assignState;
                      yield bodyP
                  ]) |> asExpr
  (*
              let vfs = List.map fst binds
              
  