anchor.diff:  
       autotest:mark(?LINE, "delete/2 - 2"),
       %% check results
  -    #keylist{list=[
  -		   #keyelem{key="header", name="Header", item=["zero", "one"]},
  -		   #keyelem{key=via, name="Via", item=["bar"]}
  -		  ]} = DeleteH2,
  +    [{"header", "Header", ["zero", "one"]},
  +     {'via', "Via", ["bar"]}
  +    ] = test_to_list(DeleteH2),
   
       autotest:mark(?LINE, "delete/2 - 2"),
       %% delete both the 'via' and "header" elements, leaving an empty list
       #keylist{list=[]} = delete("header", delete(via, DeleteH2)),
   
  -    %% deletefirstvalue/2
  +    %% deletefirstvalue(Name, Keylist)
       %%--------------------------------------------------------------------
       autotest:mark(?LINE, "deletefirstvalue/2 - 1"),
       DFVH1 = from_list([{via, "Via", ["one", "two", "three"]},
  
positive.code: %%====================================================================
  
  %%--------------------------------------------------------------------
  %% @spec    (Key, List) ->
  %%            [string()] "the value of Key - Key may have several values associated with it (e.g. the Via header in sip requests)"
  %%
  %%            Key  = string() | atom() "either the header name (string) or the internal form of it (atom)."
  %%            List = #keylist{}
  %%
  %% @doc     return the contents of the header that matches Key
  %% @end
  %%--------------------------------------------------------------------
  fetch(Key, List) when is_list(Key), is_record(List, keylist) ->
      fetchcase(normalize(Key), List#keylist.list);
  fetch(Key, List) when is_atom(Key), is_record(List, keylist) ->
      fetchcase(Key, List#keylist.list).
  
  fetchcase(_Key, []) ->
      [];
  fetchcase(Key, [#keyelem{key=Key}=Elem | _List]) ->
      %% match
      Elem#keyelem.item;
  fetchcase(Key, [Elem | List]) when is_record(Elem, keyelem) ->
      %% no match
      fetchcase(Key, List).
  
negative.code: %%            Keylist = [#keyelem{}]
  %%            Keys    = [string()]
  %%
  %% @doc     Copy the elements matching Keys from Keylist.
  %% @end
  %%--------------------------------------------------------------------
  copy(Keylist, Names) when record(Keylist, keylist) ->
      Keys = normalize_list(Names),
      KeyElems = Keylist#keylist.list,
      Copies = [E || E <- KeyElems, lists:member(E#keyelem.key, Keys)],
      #keylist{list = Copies}.
  
  %%--------------------------------------------------------------------
  %% @spec    (Func, Keylist) -> [term()]
  %%
  %%            Func    = fun() "fun(Key, Name, Value) -> term()"
  %%            Keylist = #keylist{}
  %%
  %% @doc     Apply Func to all elements in Keylist. Func must be of
  %%          arity three, and accept arguments Func(Key, Name, Value)
  %%          where Key is an atom() or a string(), Name is always a
  %%          string() and Value is [string()].
  %% @end
  %%--------------------------------------------------------------------
  map(Func, Keylist) when is_record(Keylist, keylist) ->
      F = fun(Elem) ->
  		Func(Elem#keyelem.key, Elem#keyelem.name, Elem#keyelem.value)
  	end,
      lists:map(F, Keylist#keylist.list).
  
  