anchor.diff:              let arg_pointers = Array.map (lumpify context) args
               new JSLump(V8.apply_function_arr(context, (func:>Lump).Pointer, Array.length args, arg_pointers))
   
  -        // TODO: get rid of this
  +        // TODO: get rid of this (moving it to the finalizer of JSLump)
           let dispose_handle handle =
               match handle with
                   | JS(pointer) -> V8.disposeHandle(pointer)
                   | _ -> failwith "disposeHandle only implemented for JSLump"
  +
  
positive.code:         abstract Native: bool
          abstract Pointer: IdType
          abstract Print: unit
  
      let fs_values = new Dictionary<IdType, Lump>()
      let mutable pointer_counter = 0
  
      let nextPointerCounter () =
          pointer_counter <- pointer_counter + 1
      
      type 'a FSLump(value : 'a) as this =
          let current_count = new IdType(pointer_counter)
          do
              // pointer_counter <- pointer_counter + 1
              nextPointerCounter()
              fs_values.Add(current_count, this :> Lump)
      
          member this.Value = value
          interface Lump with
              member this.Native = true
              member this.Pointer = current_count
              member this.Print = printf "%A\n" this
      
  
  
      type JSLump(pointer: nativeint) =
  
          let mutable disposed = false
          let cleanup disposing =
              printf "cleanup!\n"
              // this.Print
              if not disposed then
                  disposed <- true
  
                  if disposing then
                      printf "disposing is true!\n"
                  V8.disposeHandle(pointer)
  
negative.code:     
          with
              | :? System.IndexOutOfRangeException -> false
              
      // since func can be a curried function, it acts as an accumulator argument
      let rec eval_array (func: Lump) (arg: Lump list) =
  
          // This function takes two Lumps: a function (which will be an FSLump)
          // and an argument (it could be a JSLump or FSLump). It returns the result as an
          // FSLump upcasted to a Lump
          let eval (func: Lump) (arg: Lump) =
              if not func.Native then failwith("the function is not an FSLump")
      
              // check func is a function
              let generic_func = typedefof<Microsoft.FSharp.Core.FSharpFunc<_,_>>
              let is_function_okay = check_function_type func
      
              if not is_function_okay then failwith("the first argument doesn't contain a function inside the FSLump or the function is not appropriate for the arguments it was called with")
  
              // get f as object
              let f = get_fslump_value func
              printf "eval called once\n"
      
              // if the argument is a FSLump, extract its value as an object,
              // otherwise box the JSLump into an object
              let a = if arg.Native then (get_fslump_value arg) else box(arg)
      
      
              // the type that fun takes in
              let in_type = func.GetType().GetGenericArguments().[0].GetGenericArguments().[0]
              // the type that fun returns
              // first genericarguments is the type of Lump that func is
              // second generic arguments is the input type (0) and return type of the function (1)
              let return_type = func.GetType().GetGenericArguments().[0].GetGenericArguments().[1]
      
              // the type of arg
              let actual_in_type =
                  if arg.Native then arg.GetType().GetGenericArguments().[0]
                  else arg.GetType()
          
              // type mismatch
              if in_type <> actual_in_type then failwith("type mismatch")
      
              let result = apply_func f a
              
          
              let generic_lump = typedefof<FSLump<_>>
              // Type of the FSLump<return_type>
              let return_lump_type = generic_lump.MakeGenericType(return_type)
              let return_constructor = return_lump_type.GetConstructors().[0]
              
              // construct FSLump<return_type>(result)
              let return_lump = return_constructor.Invoke([| result; fscontext |])
              return_lump :?> Lump
  
  
          match arg with
              | x::xs -> eval_array (eval func x) xs
              | [] -> func
  