anchor.diff:  
           static member Compile<'T>(queryExpr : QueryExpr, optimize : Func<Expression,Expression>, allowNonPublicMemberAccess : bool) : Func<'T> =
               if allowNonPublicMemberAccess then
  -                let d = CoreHelpers.Compile(queryExpr, fun expr -> Compiler.compileToSequential expr optimize.Invoke)
  -                Func<'T>(fun () -> d.DynamicInvoke() :?> _)
  +                CoreHelpers.Compile(queryExpr, fun expr -> Compiler.compileToSequential expr optimize.Invoke)
               else
  -                let mi, objs = CoreHelpers.CompileToMethod(queryExpr, fun expr -> Compiler.compileToSequential expr optimize.Invoke )
  -                Func<'T>(CoreHelpers.WrapInvocation(mi, objs))
  +                CoreHelpers.CompileToMethod(queryExpr, fun expr -> Compiler.compileToSequential expr optimize.Invoke )
  +                
   
           static member Compile(queryExpr : QueryExpr, optimize : Func<Expression,Expression>,  allowNonPublicMemberAccess : bool) : Action =
               if allowNonPublicMemberAccess then
  -                let d = CoreHelpers.Compile(queryExpr, fun expr -> Compiler.compileToSequential expr optimize.Invoke)
  -                Action(fun () -> d.DynamicInvoke() :?> _)
  +                let func = CoreHelpers.Compile(queryExpr, fun expr -> Compiler.compileToSequential expr optimize.Invoke)
  +                Action(fun () -> func.Invoke())
               else
  -                let mi, objs = CoreHelpers.CompileToMethod(queryExpr, fun expr -> Compiler.compileToSequential expr optimize.Invoke )
  -                Action(CoreHelpers.WrapInvocation(mi, objs))
  +                let func = CoreHelpers.CompileToMethod(queryExpr, fun expr -> Compiler.compileToSequential expr optimize.Invoke )
  +                Action(fun () -> func.Invoke())
   
           static member CompileToParallel<'T>(queryExpr : QueryExpr,  optimize : Func<Expression,Expression>, allowNonPublicMemberAccess : bool ) : Func<'T> =
               if allowNonPublicMemberAccess then
  -                let d = CoreHelpers.Compile(queryExpr, fun expr -> Compiler.compileToParallel expr optimize.Invoke)
  -                Func<'T>(fun () -> d.DynamicInvoke() :?> _)
  +                CoreHelpers.Compile(queryExpr, fun expr -> Compiler.compileToParallel expr optimize.Invoke)
               else
  -                let mi, objs = CoreHelpers.CompileToMethod(queryExpr,  fun expr -> Compiler.compileToParallel expr optimize.Invoke )
  -                Func<'T>(CoreHelpers.WrapInvocation(mi, objs))
  +                CoreHelpers.CompileToMethod(queryExpr,  fun expr -> Compiler.compileToParallel expr optimize.Invoke )
  +                
   
   
  
positive.code:             let objs, pms = csv.Environment.Values.ToArray(), csv.Environment.Keys
  
              let func = Expression.Lambda(expr', pms)
              Session.Compile(func), objs
  
          static member private Compile(query : QueryExpr, compile : QueryExpr -> Expression) : Delegate =
              let expr = compile query
              Expression.Lambda(expr).Compile()
  
          static member private WrapInvocation<'T>(mi : MethodInfo, args : obj []) =
              fun () -> 
                  try mi.Invoke(null, args) :?> 'T
                  with :? TargetInvocationException as ex -> 
                      if ex.InnerException :? MemberAccessException 
                      then raise <| Exception(
                                          "Attempting to access non public member or type from dynamic assembly. Consider making your type/member public or use the appropriate Run method.",
                                          ex.InnerException)
                      else raise ex.InnerException 
  
  
  
  
          static member Compile<'T>(queryExpr : QueryExpr, optimize : Func<Expression,Expression>) : Func<'T> =
              CoreHelpers.Compile<'T>(queryExpr, optimize, false)
  
negative.code:             | _ -> 
                  Source (constant enumerable, ty)
  
          static member private CompileToMethod(query : QueryExpr, compile : QueryExpr -> Expression) : Func<'T> =
              let expr = compile query
              
              let eraser = AnonymousTypeEraser()
  