anchor.diff:                              state) |> asExpression;
   
                       if letrec.IsSome then
  -                        AsLetRecExpression (theFuncObject, assignToConstruction, assignState)
  +                        AsLetRecFunction (theFuncObject, assignToConstruction, assignState)
                       else
                           Expression.Block (
                               [ theFuncObject ],
  
positive.code:             let env = {
                  env with
                      varEnv =
                          (env.varEnv, vPs)
                          ||> List.fold (fun varEnv (v,vP,_) ->
                              varEnv
                              |> Map.add v (vP |> asExpression)) }
  
              let vePs =
                  vPs
                  |> List.map (fun (v, vP, e) ->
                      let funcObject, assignToConstruction, assignState = 
                          match LetRecConvExpr env (Some v) 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, _,_) ->
                      Expression.Assign (vP, funcObject) |> asExpression)
                  
              let assignState =
                  vePs
                  |> List.map (fun (_,_,_, 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
  
          | Patterns.AddressOf _ -> raise <| new NotSupportedException("Address-of expressions may not be converted to LINQ expressions")
  
negative.code:             Expression.Call(minfo,[| eP; filterP; handlerP |]) |> asExpr
  
          | Patterns.LetRecursive (binds, body) -> 
              let variablesAsLinq =
                  binds
                  |> List.map (fun (v, e) ->
                      v, Expression.Variable (v.Type, v.Name), e)
  