anchor.diff:                              state) |> asExpression;
   
                       if letrec.IsSome then
  -                        AsLetRecExpression (theFuncObject, assignToConstruction, assignState)
  +                        AsLetRecFunction (theFuncObject, assignToConstruction, assignState)
                       else
                           Expression.Block (
                               [ theFuncObject ],
  
positive.code:                 match capturedVars with
                  | [] ->
                      let obj = ``constructor``.Invoke [| ``function`` |]
                      let func = Expression.Constant (obj) 
                      if letrec.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 newObject = 
                          Expression.New (
  
negative.code:         Expression.Lambda(linqExpr, Expression.Parameter(typeof<unit>)) |> asExpression
  
      let CompileImpl (e: #Expr, eraseEquality) = 
         let linqExpr = Conv (e,eraseEquality)
         let linqExpr = (linqExpr :?> LambdaExpression)
         let d = linqExpr.Compile()
  