anchor.diff:  %%-------------------------------------------------------------------------
   %% @doc
   %% ===Merge two trie instance.===
  +%% Update the second trie parameter with all of the elements
  +%% found within the first trie parameter.
   %% @end
   %%-------------------------------------------------------------------------
   
  
positive.code:     false = trie:is_key("aaaa", RootNode4),
      ok.
  
  %%-------------------------------------------------------------------------
  %% @doc
  %% ===Speed Test.===
  %% @end
  %%-------------------------------------------------------------------------
  
  test_speed() ->
      test_speed("/usr/share/dict/words").
  
  test_speed([_ | _] = FilePath) ->
      {ok, F} = file:open(FilePath, [read_ahead, raw, read]),
      Result0 = test_read(F, trie, trie:new()),
      {ok, 0} = file:position(F, bof),
      Result1 = test_read(F, dict, dict:new()),
      {ok, 0} = file:position(F, bof),
      {T0, _} = timer:tc(trie, test_speed_cases, [trie, F, Result0]),
      {ok, 0} = file:position(F, bof),
      {T1, _} = timer:tc(trie, test_speed_cases, [dict, F, Result1]),
      file:close(F),
      io:format("trie:             cases: ~8w µs~n", [T0]),
      io:format("dict:             cases: ~8w µs~n", [T1]),
      ok.
  
  test_speed_cases(Module, F, State) ->
      case file:read_line(F) of
          {ok, Line} ->
              true = Module:is_key(Line, State),
              Module:fetch(Line, State),
              Module:find(Line, State),
              test_speed_cases(Module, F, State);
          eof ->
              State
      end.
  
  %%-------------------------------------------------------------------------
  %% @doc
  %% ===Size Test.===
  %% Compare the size of a word list with the size of the resulting trie
  %% data structure.
  %% @end
  %%-------------------------------------------------------------------------
  
  test_size() ->
      test_size("/usr/share/dict/words").
  
  test_size([_ | _] = FilePath) ->
      {ok, Info} = file:read_file_info(FilePath),
      FileSize = Info#file_info.size,
      {ok, F} = file:open(FilePath, [read_ahead, raw, read]),
      erlang:garbage_collect(),
      {memory, Size0} = erlang:process_info(self(), memory),
      Result = test_read(F, trie, trie:new()),
      erlang:garbage_collect(),
      {memory, Size1} = erlang:process_info(self(), memory),
      file:close(F),
      ResultRealSize = Size1 - Size0,
      ResultAbstractSize = abstract_binary_size(Result),
      ResultEstimateSize = estimate_binary_size(Result),
      io:format("file ~s (~w bytes)~n",
                [FilePath, FileSize]),
      io:format("trie data:~n"
                "  raw         ~16w bytes~n"
                "  estimated   ~16w bytes~n"
                "  characters  ~16w bytes~n",
                [ResultRealSize, ResultEstimateSize, ResultAbstractSize]),
      io:format("  characters stored  ~.1f %~n"
                "  data stored        ~.2f x~n",
                [erlang:round(ResultAbstractSize / FileSize * 1000) / 10,
                 erlang:round(ResultRealSize / FileSize * 100) / 100]),
      ok.
  
  test_read(F, Module, State) ->
      case file:read_line(F) of
          {ok, Line} ->
              test_read(F, Module, Module:store(Line, empty, State));
          eof ->
              State
      end.
  
  %%%------------------------------------------------------------------------
  %%% Private functions
  %%%------------------------------------------------------------------------
  
negative.code: %%-------------------------------------------------------------------------
  %% @doc
  %% ===Fold a function over the trie.===
  %% Traverses in alphabetical order.
  %% @end
  %%-------------------------------------------------------------------------
  
  