anchor.diff:                     [],
                      state()) -> {ok, any()} | {async, fun()} | {error, term()}.
   fold_buckets(FoldBucketsFun, Acc, _Opts, #state{opts=BitcaskOpts,
  -                                                data_file=DataFile,
  +                                                data_dir=DataFile,
                                                   root=DataRoot,
                                                   async_folds=true}) ->
       FoldFun = fold_buckets_fun(FoldBucketsFun),
  
positive.code: -define(CAPABILITIES, [async_fold]).
  
  -record(state, {ref :: reference(),
                  link_file :: string(),
                  data_file :: string(),
                  opts :: [{atom(), term()}],
                  root :: string(),
                  async_folds :: boolean()}).
  
  
negative.code: %%  of its own, use that instead.
  -spec drop(state()) -> {ok, state()} | {error, term(), state()}.
  drop(#state{ref=Ref,
              partition=Partition,
              root=DataRoot,
              opts=BitcaskOpts}=State) ->
      %% Close the bitcask reference
      bitcask:close(Ref),
  
      case make_data_dir(filename:join([DataRoot,
                                        integer_to_list(Partition)])) of
          {ok, DataDir} ->
              %% Spawn a process to cleanup the old data files.
              %% The use of spawn is intentional. We do not
              %% care if this process dies since any lingering
              %% files will be cleaned up on the next drop.
              %% The worst case is that the files hang
              %% around and take up some disk space.
              spawn(drop_data_cleanup(DataRoot, Partition, DataDir)),
  
              %% Now open the bitcask and return an updated state
              %% so this backend can continue processing.
              case bitcask:open(filename:join(DataRoot, DataDir), BitcaskOpts) of
                  Ref1 when is_reference(Ref1) ->
                      {ok, State#state{data_dir=DataDir,
                                       ref=Ref1}};
                  {error, Reason} ->
                      {error, Reason, State#state{data_dir=DataDir}}
              end;
          {error, Reason1} ->
              {error, Reason1, State}
  