anchor.diff:          // a FSLump
           let extract_fslump (arg: JSLump) =
               let index = IdType(V8.get_pointer_lump((arg :> Lump).Pointer))
  -            fs_values.[index]
  -
  -        // process_arg takes an argument
  +            fscontext.Lookup index
  +
  +        // process_arg returns the FSLump (as a Lump) that JSLump contains as an FLump JavaScript object or the argument upcasted as a Lump if it's not an FLump object
           let process_arg (arg: JSLump) =
               let lumpy_arg = arg :> Lump
               if (V8.get_pointer_lump(lumpy_arg.Pointer)) = -1 then lumpy_arg
               else extract_fslump(arg)
  -    
  +
           let evaluator context args =
               // the JSLumps that contain a pointer to a FSLump are processed into that FSLump
               let processed_args = args |> get_all_JS_arguments JSLump.Context |> Array.map process_arg
  -            printf "these are processed_args %A\n" (Array.toList processed_args)
  +            printf "these are processed_args %A\n" <| Array.toList processed_args
               let result = eval_array (processed_args.[0]) (Array.toList (processed_args.[1..]))
               printf "this is the result %A\n" <| get_fslump_value(result)
               // return the pointer to a FLump object (in JavaScript)
  
positive.code:             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
          let dispose_handle handle =
              match handle with
                  | JS(pointer) -> V8.disposeHandle(pointer)
                  | _ -> failwith "disposeHandle only implemented for JSLump"
  
negative.code:         abstract Native: bool
          abstract Pointer: IdType
          abstract Print: unit
      
      type FSValuesStorage () =
          let _dict = new Dictionary<IdType, Lump>()
          // only allow positive integers
          let mutable _pointer_counter = 0
          let nextPointerCounter () =
              _pointer_counter <- _pointer_counter + 1
                      
          member this.Dict = _dict
          member this.Insert (lump: FSLump<_>) =
              this.Dict.Add(IdType(_pointer_counter), lump)
              nextPointerCounter ()
              // _pointer_counter
          member this.CurrentPointer = _pointer_counter
          member this.Lookup pointer = this.Dict.[pointer]
  
      
      and 'a FSLump(value : 'a, fscontext: FSValuesStorage) as this =
          let _fscontext = fscontext
          let _pointer = _fscontext.CurrentPointer
          do _fscontext.Insert(this)
          member this.Value = value
  
          interface Lump with
              member this.Native = true
              member this.Pointer = IdType(_pointer)
              member this.Print = printf "%A\n" this
      
      let fscontext = new FSValuesStorage()
  
      type JSLump(pointer: nativeint) =
          let mutable disposed = false
          let cleanup disposing =
              printf "cleanup!\n"
              if not disposed then
                  disposed <- true
                  if disposing then
                      printf "disposing is true!\n"
                  V8.disposeHandle(pointer)
  