anchor.diff:  map_args(one_or_more, F, _D, A) ->
       L = lists:append(A),
       case length(L) of
  -    0 -> erlang:error(one_or_more);
  -    _ -> F(L)
  +        0 -> erlang:error(one_or_more);
  +        _ -> F(L)
       end;
   map_args(many, F, _D, A) -> F(lists:append(A));
   map_args(multiple, F, _D, A) -> F(A);
   map_args(N, F, _D, A) when is_function(F, N) ->
       L = lists:append(A),
       case length(L) of
  -    N -> apply(F, L);
  -    X -> erlang:error({wrong_number_of_args, X, N})
  +        N -> apply(F, L);
  +        X -> erlang:error({wrong_number_of_args, X, N})
       end;
   map_args(N, F, _D, A) when is_function(F, 1) ->
       L = lists:append(A),
  
positive.code: map_args(K, N, F, D, A) ->
      try map_args(N, F, D, A)
      catch error:Reason ->
          erlang:error({parse_error, Reason, K, A})
      end.
  
  map_args(_N, _F, D, []) -> D;
  
negative.code: map_types(TypeStrings) ->
      Types = lists:map(fun list_to_atom/1, TypeStrings),
      case lists:all(fun (T) -> lists:member(T, ?report_types) end, Types) of
          true -> Types;
          false -> usage("argument to -t must be one or more of ~w~n",
                         [?report_types])
      end.
  
  start() ->
      Options = case parse_arguments([{h, 0, undefined, false},
                                      {n, 1, fun list_to_integer/1, all},
                                      {e, 1, undefined, undefined},
                                      {t, one_or_more, fun map_types/1, all},
                                      {report_dir, 1, undefined}],
                                     init:get_arguments()) of
                    {ok, O} ->
                        O;
                    {parse_error, badarg, n, _} ->
                        usage("-n requires a single integer argument~n", []);
                    {missing_option, K} ->
                        usage("option ~p is required~n", [K]);
                    {parse_error, {wrong_number_of_args, _, N}, K, _} ->
                        usage("option ~p requires ~p arguments~n", [K, N]);
                    Error -> usage("parse error: ~p~n", [Error])
                end,
      case proplists:get_value(h, Options) of
          true -> usage();
          false -> ok
      end,
      Dir = proplists:get_value(report_dir, Options),
      Types = proplists:get_value(t, Options),
  