anchor.diff:      ++ "|"
       ++ ?MATCH_ANY
       ++ ")",
  +  {AStringType, AIsString} = if
  +                               is_list(A) ->
  +                                 {list, true};
  +                               is_binary(A) ->
  +                                 {binary, true};
  +                               true ->
  +                                 {undefined, false}
  +                             end,
     case re:run(E, RE_HAS_PARAMS, [global, {capture, all_but_first, list}]) of
  -    nomatch ->
  +    nomatch when AIsString ->
         {not_equal, {Key, E, A, TextDiffFun(E, A)}};
  +    {match, [[?MATCH_ANY]]} ->
  +      {pass, []};
       {match, [[E]]} ->
  -      case E of
  -        ?MATCH_ANY ->
  -          {pass, []};
  -        _ ->
  -          {pass, [{store_tag2param(E), A}]}
  -      end;
  -    {match, Params0} ->
  -      Type = if
  -               is_list(A) ->
  -                 list;
  -               is_binary(A) ->
  -                 binary
  -             end,
  +      {pass, [{store_tag2param(E), A}]};
  +    {match, Params0} when AIsString ->
         Params = lists:map( fun([?MATCH_ANY]) ->
                                 ?MATCH_ANY;
                                ([Match]) ->
  
positive.code:                       , [global]
                        ),
        RE = ["^", RE3, "$"],
        case re:run(A, RE, [global, {capture, all_but_first, Type}]) of
          nomatch ->
            {not_equal, {Key, E, A, TextDiffFun(E, A)}};
          {match, [Values]} ->
  
negative.code:                                      , lists:zip(Params, Values)
                                       ),
            {pass, ParamsValues}
        end;
      _ ->
        {not_equal, {Key, E, A}}
    end;
  validate_primitive(Key, E, A, _Callbacks) ->
    {not_equal, {Key, E, A}}.
  