anchor.diff:             ?R "\n",
              [M, F, Args, Culprit, ExpectedType, FoundType]);
   message_to_string({bin_construction, [Culprit, Size, Seg, Type]}) ->
  -    format("Binary construction will fail since the ~s field ~s in"
  -           " segment ~s has type ~s\n", [Culprit, Size, Seg, Type]);
  +    format(?BW "Binary construction will fail since the"?NB" ~s "?BW"field"?R
  +           " ~s"?BW" in segment"?R" ~s"?BW" has type"?R" ~s\n",
  +           [Culprit, Size, Seg, Type]);
   message_to_string({call, [M, F, Args, ArgNs, FailReason,
                             SigArgs, SigRet, Contract]}) ->
       format(?BW "The call" ?R " ~w:~w~s ", [M, F, bad_arg(ArgNs, Args)]) ++
           call_or_apply_to_string(ArgNs, FailReason, SigArgs, SigRet, Contract);
   message_to_string({call_to_missing, [M, F, A]}) ->
  -    format("Call to missing or unexported function ~w:~w/~w\n", [M, F, A]);
  +    format(?BW"Call to missing or unexported function "?R"~w:~w/~w\n",
  +           [M, F, A]);
   message_to_string({exact_eq, [Type1, Op, Type2]}) ->
  -    format("The test ~s ~s ~s can never evaluate to 'true'\n",
  +    format(?BW"The test "?R"~s ~s ~s"?BW" can never evaluate to 'true'\n",
              [Type1, Op, Type2]);
   message_to_string({fun_app_args, [Args, Type]}) ->
  -    format("Fun application with arguments ~s will fail"
  -           " since the function has type ~s\n", [Args, Type]);
  +    format(?BW"Fun application with arguments "?R"~s"?BW" will fail"
  +           " since the function has type "?R"~s\n", [Args, Type]);
   message_to_string({fun_app_no_fun, [Op, Type, Arity]}) ->
  -    format("Fun application will fail since ~s :: ~s"
  -           " is not a function of arity ~w\n", [Op, Type, Arity]);
  +    format(?BW"Fun application will fail since "?R"~s "?BW"::"?R" ~s"
  +           " is not a function of arity "?R"~w\n", [Op, Type, Arity]);
   message_to_string({guard_fail, []}) ->
       ?BW "Clause guard cannot succeed.\n" ?R;
   message_to_string({guard_fail, [Arg1, Infix, Arg2]}) ->
  -    format(?BW "Guard test "?R"~s ~s ~s"?BW" can never succeed\n", [Arg1, Infix, Arg2]);
  +    format(?BW "Guard test "?R"~s ~s ~s"?BW" can never succeed\n",
  +           [Arg1, Infix, Arg2]);
   message_to_string({neg_guard_fail, [Arg1, Infix, Arg2]}) ->
  -    format("Guard test not(~s ~s ~s) can never succeed\n",
  +    format(?BW "Guard test not("?R"~s ~s ~s"?BW") can never succeed\n",
              [Arg1, Infix, Arg2]);
   message_to_string({guard_fail, [Guard, Args]}) ->
  -    format("Guard test ~w~s can never succeed\n", [Guard, Args]);
  +    format(?BW "Guard test "?R"~w~s"?BW" can never succeed\n",
  +           [Guard, Args]);
   message_to_string({neg_guard_fail, [Guard, Args]}) ->
  -    format("Guard test not(~w~s) can never succeed\n", [Guard, Args]);
  +    format(?BW"Guard test not("?R"~w~s"?BW") can never succeed\n",
  +           [Guard, Args]);
   message_to_string({guard_fail_pat, [Pat, Type]}) ->
  -    format("Clause guard cannot succeed. The ~s was matched"
  -           " against the type ~s\n", [Pat, Type]);
  +    format(?BW"Clause guard cannot succeed. The "?R"~s"?BW" was matched"
  +           " against the type "?R"~s\n", [Pat, Type]);
   message_to_string({improper_list_constr, [TlType]}) ->
       format(?BW "Cons will produce an improper list"
              " since its "?NB"2"?R"nd"?BW" argument is"?R" ~s\n", [TlType]);
  
positive.code: %%----- Warnings for general discrepancies ----------------
  message_to_string({apply, [Args, ArgNs, FailReason,
                             SigArgs, SigRet, Contract]}) ->
      format("Fun application with arguments ~s ", [Args]) ++
          call_or_apply_to_string(ArgNs, FailReason, SigArgs, SigRet, Contract);
  message_to_string({app_call, [M, F, Args, Culprit, ExpectedType, FoundType]}) ->
      format(?BW "The call" ?R " ~s:~s~s " ?BW "requires that"
  
negative.code:         both -> NameString ++ ?BW "has no local return\n" ?R
      end;
  message_to_string({record_constr, [RecConstr, FieldDiffs]}) ->
      format(?BW"Record construction "?R"~s"?BW" violates the"
             " declared type of field "?R"~s\n", [RecConstr, FieldDiffs]);
  message_to_string({record_constr, [Name, Field, Type]}) ->
      format(?BW"Record construction violates the declared type for "?R"#~w{}" ?BW
             " since "?R"~s"?BW" cannot be of type "?R"~s\n",
             [Name, Field, Type]);
  message_to_string({record_matching, [String, Name]}) ->
      format(?BW"The "?R"~s"?BW" violates the"
             " declared type for "?R"#~w{}\n", [String, Name]);
  message_to_string({record_match, [Pat, Type]}) ->
      format(?BW"Matching of "?R"~s"?BW" tagged with a record name violates the"
             " declared type of "?R"~s\n", [Pat, Type]);
  message_to_string({pattern_match, [Pat, Type]}) ->
      format(?BW"The ~s"?BW" can never match the type "?NG"~s\n",
             [bad_pat(Pat), Type]);
  