anchor.diff:  %% We know which positions N are to blame;
   %% the list of triples will never be empty.
   form_expected_without_opaque([{N, T, TStr}]) ->
  -    case erl_types:t_is_opaque(T) of
  -        true  ->
  -            format([?BW, "an opaque term of type", ?NG, " ~s ", ?BW, "as "], [TStr]);
  -        false ->
  -            format([?BW, "a term of type ", ?NG, "~s ", ?BW, "(with opaque subterms) as "], [TStr])
  -    end ++ form_position_string([N]) ++ ?BW ++ " argument" ++ ?R;
  +    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".
  
positive.code:         [N1] -> ordinal(N1);
          [_,_|_] ->
              [Last|Prevs] = lists:reverse(ArgNs),
              ", " ++ Head = lists:flatten([format(", ~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]).
  
  
  bad_pat("pattern " ++ P) ->
      "pattern " ?NR ++ P ++ ?R;
  bad_pat("variable " ++ P) ->
      "variable " ?NR ++ P ++ ?R;
  bad_pat(P) ->
      "pattern " ?NR ++ P ++ ?R.
  
  
  bad_arg(N, Args) ->
      color_arg(N, ?NR, Args).
  
  good_arg(N, Args) ->
      color_arg(N, ?NG, Args).
  color_arg(N, C, Args) when is_integer(N) ->
      color_arg([N], C, Args);
  color_arg(Ns, C, Args) ->
  
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) ->
  