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:         [T] ->
              TS = erl_types:t_to_string(T),
              case erl_types:t_is_opaque(T) of
                  true  -> format("an opaque term of type ~s is expected", [TS]);
                  false -> format("a structured term of type ~s is expected", [TS])
              end;
          [_,_|_] -> "terms of different types are expected in these positions"
      end.
  
  form_position_string(ArgNs) ->
  
negative.code: %% We know which positions N are to blame;
  %% the list of triples will never be empty.
  form_expected_without_opaque([{N, T, TStr}]) ->
      FStr = case erl_types:t_is_opaque(T) of
                 true  ->
                     "~!Wan opaque term of type~!g ~s ~!Was ";
                 false ->
                     "~!Wa term of type ~!g~s ~!W(with opaque subterms) as "
             end ++ form_position_string([N]) ++ "~!W argument",
      fmt(FStr, [TStr]);
  
  form_expected_without_opaque(ExpectedTriples) -> %% TODO: can do much better here
      {ArgNs, _Ts, _TStrs} = lists:unzip3(ExpectedTriples),
      "opaque terms as " ++ form_position_string(ArgNs) ++ " arguments".
  