anchor.diff:          ignore ->
               ignore;
           SyntaxOp ->
  -            case spec(SyntaxOp, Val) of
  +            case spec(SyntaxOp, Key, Val, Parse) of
                   {ok, Val2} ->
                       {ok, Key, Val2};
                   error ->
                       {error, syntax_error(Key, Parse)};
  +                {error, Error} ->
  +                    {error, Error};
                   unknown ->
                       error({invalid_syntax, SyntaxOp})
               end
       end.
   
   
  +
  +%% @private
  +-spec spec(syntax_opt(), term(), term(), #parse{}) ->
  +    {ok, term()} | error | {error, term()} | unknown.
  +
  +spec({ListType, SyntaxOp}, Key, Val, Parse) when ListType==list; ListType==slist; ListType==ulist ->
  +    case Val of
  +        [] ->
  +            {ok, []};
  +        [Head|_] when not is_integer(Head) ->
  +            do_parse_list(ListType, SyntaxOp, Key, Val, Parse, []);
  +        _ ->
  +            do_parse_list(ListType, SyntaxOp, Key, [Val], Parse, [])
  +    end;
  +
  +spec({syntax, Syntax}, Key, Val, Parse) ->
  +    Path2 = path_key(Key, Parse),
  +    case parse(Val, Syntax, #{path=>Path2}) of
  +        {ok, Parsed, _List, _Other} ->
  +            {ok, Parsed};
  +        {error, Error} ->
  +            {error, Error}
  +    end;
  +
  +spec([Opt|Rest], Key, Val, Parse) ->
  +    case spec(Opt, Key, Val, Parse) of
  +        {ok, Val2} ->
  +            {ok, Val2};
  +        _ ->
  +            spec(Rest, Key, Val, Parse)
  +    end;
  +
  +spec([], _Key, _Val, _Parse) ->
  +    error;
  +
  +spec(SyntaxOp, _Key, Val, _Parse) ->
  +    spec(SyntaxOp, Val).
  +
  +
  +
   %% @private
   -spec spec(syntax_opt(), term()) ->
  -    {ok, term()} | error | unknown.
  +    {ok, term()} | error | {error, term()} | unknown.
   
   spec(any, Val) ->
       {ok, Val};
  
positive.code:     map() |                     % Allow for nested objects
      list() |                    % First matching option is used
      syntax_fun() |
      '__defaults' |              % Defaults for this level
      '__mandatory'.              % Mandatory fields (only root level)
  
  -type syntax_fun() ::
      fun((Val::term()) -> syntax_fun_out()) |
  
negative.code:         true ->
              check_mandatory(Rest, Parse);
          false ->
              {error, {missing_field, path_key(Term, Parse)}}
      end.
  
  
  