anchor.diff:  open System
   open System.Collections.Generic
   
  -type 'a Lump =
  -    // FJ(JF(x:'a))
  -    | FS of 'a
  -    // JF(pointer)
  -    | JSLump of nativeint
  +
   
   module V8 =
       [<DllImport("v8_helper.dylib", CallingConvention=CallingConvention.Cdecl)>]
  
positive.code:     [<DllImport("v8_helper.dylib", CallingConvention=CallingConvention.Cdecl)>]
      extern void dispose_handle(nativeint)
  
  
  
  module JS =
      let create_fun context code name =
          let pointer = V8.create_function(context, code, name)
          in JSLump(pointer)
          
  
      let execute_JS context code =
          let pointer = V8.execute_string(context, code)
          in JSLump(pointer)
              
      let print_JS context lump =
          match lump with
              | JSLump(pointer) -> V8.print_result(context, pointer)
              | FS(e) -> printf "%A" e
  
      let apply_JS_func context func arg =
          match (func, arg) with
              | (JSLump(p1), JSLump(p2)) -> JSLump(V8.apply_function(context, p1, p2))
              | (_,_) -> failwith "apply_JS_func only implemented for JSLump"
  
      let dispose_handle handle =
          match handle with
              | JSLump(pointer) -> V8.dispose_handle(pointer)
              | _ -> failwith "dispose_handle only implemented for JSLump"
  
  
  // module FS =
  //     let fs_values = new Dictionary<'a Lump, 'a>:
  
  let context = V8.get_context();
  
  
negative.code:     
      JS.dispose_handle(num)
      printf "disposed num\n"
  
      JS.print_JS context (new FSLump<int>(3));
      printf "\n"
      // V8.dispose_handle(num._pointer);
      // V8.dispose_handle(add._pointer);
      // V8.dispose_handle(result._pointer);
  
      let er = JS.fs_values.[12]
      let er_casted = er :?> FSLump<int>
      printf "%d\n" er_casted.Value;
  
  do
      main()
      V8.dispose_handle(context);
  