anchor.diff:  
   
   %% @private
  -do_parse_list(list, _SyntaxOp, _Key, [], _Parse, Acc) ->
  -    {ok, lists:reverse(Acc)};
  -
  -do_parse_list(slist, _SyntaxOp, _Key, [], _Parse, Acc) ->
  -    {ok, lists:sort(Acc)};
  -
  -do_parse_list(ulist, _SyntaxOp, _Key, [], _Parse, Acc) ->
  -    {ok, lists:usort(Acc)};
  +do_parse_list(list, _SyntaxOp, _Key, [], Parse, Acc) ->
  +    {ok, lists:reverse(Acc), Parse};
  +
  +do_parse_list(slist, _SyntaxOp, _Key, [], Parse, Acc) ->
  +    {ok, lists:sort(Acc), Parse};
  +
  +do_parse_list(ulist, _SyntaxOp, _Key, [], Parse, Acc) ->
  +    {ok, lists:usort(Acc), Parse};
   
   do_parse_list(ListType, SyntaxOp, Key, [Term|Rest], Parse, Acc) ->
       case spec(SyntaxOp, Key, Term, Parse) of
           {ok, Val} ->
               do_parse_list(ListType, SyntaxOp, Key, Rest, Parse, [Val|Acc]);
  +        {ok, Val, Parse2} ->
  +            do_parse_list(ListType, SyntaxOp, Key, Rest, Parse2, [Val|Acc]);
           Other ->
               Other
       end;
  
positive.code: 
  %% @private
  do_parse_key(Key, Val, Parse) ->
      #parse{ok=OK, ok_exp=OkExp, no_ok=NoOk, opts=Opts} = Parse,
      case to_existing_atom(Key) of
          {ok, Key2} ->
              case find_config(Key2, Val, Parse) of
                  {ok, Key3, Val3} ->
                      PathKey = path_key(Key3, Parse),
                      Key4 = case maps:get({binary_key, PathKey}, Opts, false) of
                          false -> Key3;
                          true -> to_bin(Key3)
                      end,
                      Parse2 = Parse#parse{
                          ok = [{Key4, Val3}|OK],
                          ok_exp = [{PathKey, Val3}|OkExp]
                      },
                      {ok, Parse2};
                  {ok, Key3, Val3, Exp3, NoOk3} ->
                      PathKey = path_key(Key3, Parse),
                      Key4 = case maps:get({binary_key, PathKey}, Opts, false) of
                          false -> Key3;
                          true -> to_bin(Key3)
                      end,
                      Parse2 = Parse#parse{
                          ok = [{Key4, Val3}|OK],
                          ok_exp = [{PathKey, Val3}|Exp3++OkExp],
                          no_ok = NoOk3++NoOk
                      },
                      {ok, Parse2};
                  {nested, Val2, Nested} ->
                      #parse{defaults=Defaults} = Parse,
                      NestedParse = Parse#parse{
                          ok = [], 
                          path = path_key(Key, Parse), 
  
negative.code: spec({syntax, Syntax}, Key, Val, Parse) ->
      Path2 = path_key(Key, Parse),
      case parse(Val, Syntax, #{path=>Path2}) of
          {ok, Parsed, Exp2, NoOk2} ->
              %% lager:warning("Parsed: ~p\nExp: ~p\nNoOk: ~p", [Parsed, Exp, NoOk]),
              #parse{ok_exp=Exp, no_ok=NoOk} = Parse,
              Parse2 = Parse#parse{ok_exp=Exp2++Exp, no_ok=NoOk2++NoOk},
              {ok, Parsed, Parse2};
          {error, Error} ->
              {error, Error}
      end;
  