anchor.diff:          [N1] -> ordinal(N1);
           [_,_|_] ->
               [Last|Prevs] = lists:reverse(ArgNs),
  -            ", " ++ Head = lists:flatten([format(", ~s",[ordinal(N)]) ||
  +            ", " ++ Head = lists:flatten([fmt(", ~s",[ordinal(N)]) ||
                                                N <- lists:reverse(Prevs)]),
               Head ++ " and " ++ ordinal(Last)
       end.
   
  -ordinal(1) -> ?BB ++ "1" ++ ?R ++ "st";
  -ordinal(2) -> ?BB ++ "2" ++ ?R ++ "nd";
  -ordinal(3) -> ?BB ++ "3" ++ ?R ++ "rd";
  -ordinal(N) when is_integer(N) -> format(?BB ++ "~w" ++ ?R ++ "th", [N]).
  +ordinal(1) -> fmt("~!B1~!!st");
  +ordinal(2) -> fmt("~!B2~!!nd");
  +ordinal(3) -> fmt("~!B3~!!rd");
  +ordinal(N) when is_integer(N) -> fmt("~!B~w~!!th", [N]).
   
   
   bad_pat("pattern " ++ P) ->
  -    "pattern " ?NR ++ P ++ ?R;
  +    fmt("pattern ~!r~s",[P]);
   bad_pat("variable " ++ P) ->
  -    "variable " ?NR ++ P ++ ?R;
  +    fmt("variable ~!r~s",[P]);
   bad_pat(P) ->
  -    "pattern " ?NR ++ P ++ ?R.
  +    fmt("~!r~s",[P]).
   
   
   bad_arg(N, Args) ->
  -    color_arg(N, ?NR, Args).
  +    color_arg(N, g, Args).
   
   good_arg(N, Args) ->
  -    color_arg(N, ?NG, Args).
  +    color_arg(N, r, Args).
   color_arg(N, C, Args) when is_integer(N) ->
       color_arg([N], C, Args);
   color_arg(Ns, C, Args) ->
  
positive.code:             case ArgNs =:= [] of
                  true ->
                      %% We do not know which argument(s) caused the failure
                      format(?BW "will never return since the success typing arguments"
                              " are " ?R "~s\n", [SigArgs]);
                  false ->
                      format(?BW "will never return since it differs in the" ?R
                             " ~s " ?BW "argument from the success typing"
                             " arguments:" ?R " ~s\n",
                             [PositionString, good_arg(ArgNs, SigArgs)])
              end;
          only_contract ->
              case (ArgNs =:= []) orelse IsOverloaded of
                  true ->
                      %% We do not know which arguments caused the failure
                      format(?BW "breaks the contract"?R" ~s\n", [Contract]);
                  false ->
                      format(?BW "breaks the contract"?R" ~s "?BW"in the"?R
                             " ~s "?BW"argument\n",
                             [good_arg(ArgNs, Contract), PositionString])
              end;
          both ->
              format(?BW "will never return since the success typing is "
                     ?R"~s "?BW"->"?R" ~s " ?BW"and the contract is "?R"~s\n",
                     [good_arg(ArgNs, SigArgs), SigRet,
                      good_arg(ArgNs, Contract)])
      end.
  
negative.code:         [T] ->
              TS = erl_types:t_to_string(T),
              case erl_types:t_is_opaque(T) of
                  true  -> fmt("~!Wan opaque term of type ~!!~s~!W is"
                                  " expected", [TS]);
                  false -> fmt("~!Wa structured term of type ~!!~s~!W is"
                                  " expected", [TS])
              end;
          [_,_|_] -> fmt("~!Wterms of different types are expected in these"
                            " positions", [])
      end.
  
  form_position_string(ArgNs) ->
  