anchor.diff:  -module(rebar_dialyzer_format).
   
  --export([format/1, bad_arg/2, seperate_args/1]).
  +-include("rebar.hrl").
  +
  +-export([format/1]).
   
   -define(NR, "\033[0;31m").
   -define(NG, "\033[0;32m").
  
positive.code: message_to_string({apply, [Args, ArgNs, FailReason,
                             SigArgs, SigRet, Contract]}) ->
      fmt("~!WFun application with arguments ~!!~s ",
             [bad_arg(ArgNs, Args)]) ++
          call_or_apply_to_string(ArgNs, FailReason, SigArgs, SigRet, Contract);
  message_to_string({app_call, [M, F, Args, Culprit, ExpectedType, FoundType]}) ->
      fmt("~!WThe call~!! ~s:~s~s ~!Wrequires that"
             "~!! ~s ~!Wis of type ~!g~s~!W not ~!r~s"
             "~!!\n",
             [M, F, Args, Culprit, ExpectedType, FoundType]);
  message_to_string({bin_construction, [Culprit, Size, Seg, Type]}) ->
      fmt("~!WBinary construction will fail since the ~!b~s~!W field~!!"
             " ~s~!W in segment~!! ~s~!W has type~!! ~s\n",
             [Culprit, Size, Seg, Type]);
  message_to_string({call, [M, F, Args, ArgNs, FailReason,
                            SigArgs, SigRet, Contract]}) ->
      fmt("~!WThe call~!! ~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]}) ->
      fmt("~!WCall to missing or unexported function ~!!~w:~w/~w\n",
             [M, F, A]);
  message_to_string({exact_eq, [Type1, Op, Type2]}) ->
      fmt("~!WThe test ~!!~s ~s ~s~!W can never evaluate to 'true'\n",
             [Type1, Op, Type2]);
  message_to_string({fun_app_args, [Args, Type]}) ->
      fmt("~!WFun application with arguments ~!!~s~!W will fail"
             " since the function has type ~!!~s\n", [Args, Type]);
  message_to_string({fun_app_no_fun, [Op, Type, Arity]}) ->
      fmt("~!WFun application will fail since ~!!~s ~!W::~!! ~s"
             " is not a function of arity ~!!~w\n", [Op, Type, Arity]);
  message_to_string({guard_fail, []}) ->
      "~!WClause guard cannot succeed.\n~!!";
  message_to_string({guard_fail, [Arg1, Infix, Arg2]}) ->
      fmt("~!WGuard test ~!!~s ~s ~s~!W can never succeed\n",
             [Arg1, Infix, Arg2]);
  message_to_string({neg_guard_fail, [Arg1, Infix, Arg2]}) ->
      fmt("~!WGuard test not(~!!~s ~s ~s~!W) can never succeed\n",
             [Arg1, Infix, Arg2]);
  message_to_string({guard_fail, [Guard, Args]}) ->
      fmt("~!WGuard test ~!!~w~s~!W can never succeed\n",
             [Guard, Args]);
  message_to_string({neg_guard_fail, [Guard, Args]}) ->
      fmt("~!WGuard test not(~!!~w~s~!W) can never succeed\n",
             [Guard, Args]);
  message_to_string({guard_fail_pat, [Pat, Type]}) ->
      fmt("~!WClause guard cannot succeed. The ~!!~s~!W was matched"
             " against the type ~!!~s\n", [Pat, Type]);
  message_to_string({improper_list_constr, [TlType]}) ->
      fmt("~!WCons will produce an improper list"
             " since its ~!b2~!!nd~!W argument is~!! ~s\n", [TlType]);
  message_to_string({no_return, [Type|Name]}) ->
      NameString =
          case Name of
  
negative.code: 
  join_args(Args) ->
      [$(, string:join(Args, ", "), $)].
  