anchor.diff:              {'Args@', Args} = lists:keyfind('Args@', 1, Bind),
               case lists:member(fun_define_info(Fun), special_funs()) of 
                   true ->
  -                    Args1 = case wrangler_syntax:type(Args) of 
  -                                list ->
  -                                    wrangler_syntax:list_elements(Args);
  -                                _ ->
  -                                    Args
  -                            end,
  +                    Args1 = convert_args(Args),
                       #fun_app{mod_name=M, fun_name=F, args=Args1};
                   false ->
                       match_app_node_1(AppNode)
  
positive.code:                     #fun_app{mod_name=none, fun_name=Fun, args=Args}
              end;
          _ ->
              #fun_app{}
      end.
           
  update_app_node(AppNode, {Tag, Node}) ->
      case match(?T("Fun@(N@@, M@, F@, Args@)"), AppNode) of
          {true, Bind} ->
  
negative.code:            "strategy can only be a list of collectors."}).
          
  
  %%@doc Returns the start and end locations of the code represented  
  %%     by `Tree' in the source file.
  -spec start_end_loc([syntaxTree()]|syntaxTree()) ->{pos(), pos()}.
  start_end_loc(Tree) ->
      wrangler_misc:start_end_loc(Tree).
  
  
  %%=====================================================================
  %% To provide a unified way to manipluate function applications.
  %%=====================================================================
  -record(fun_app, {mod_name ::syntaxTree()|none,
                    fun_name ::syntaxTree(),
                    args     ::[syntaxTree()]|syntaxTree()}).
  
  %% @doc For a function application node that matches `?FUN_APPY(M,F,A)', 
  %%     get the part that represents the module name if M appears in 
  %%     the application; otherwise returns `none'.
  -spec get_app_mod(syntaxTree()) ->syntaxTree()|none.
  get_app_mod(AppNode) ->
      FunApp=match_app_node(AppNode),
      FunApp#fun_app.mod_name.
  
  %% @doc For a function application node that matches `?FUN_APPY(M,F,A)', 
  %%     get the part that represents the function name.
  -spec get_app_fun(syntaxTree()) ->syntaxTree().
  get_app_fun(AppNode) ->
      FunApp=match_app_node(AppNode),
      FunApp#fun_app.fun_name.
  
  %% @doc For a function application node that matches `?FUN_APPY(M,F,A)', 
  %%     get the part that represents the arguments to which the function `F' 
  %%     is applied. This function returns the arguments as a list of AST 
  %%     nodes if the the function application matches one of those templates"
  %%     with `Args@'`@', as specified in the documentation of `?FUN_APPY(M,F,A)'; 
  %%     otherwise a single AST node.
  -spec get_app_args(syntaxTree()) ->[syntaxTree()]|syntaxTree().
  get_app_args(AppNode) ->
      FunApp=match_app_node(AppNode),
      FunApp#fun_app.args.
  
  %% @doc Replaces the module name part of a function application node with `Modname'.
  %%     The node `AppNode' should match one of the templates specified by`?FUN_APPY(M,F,A)'.
  -spec update_app_mod(syntaxTree(), syntaxTree()) ->syntaxTree().
  update_app_mod(AppNode, ModName) ->
      AppNode1=update_app_node(AppNode, {mod_name, ModName}),
      wrangler_misc:rewrite(AppNode, AppNode1).
  
  %% @doc Replaces the function name part of a function application node with `FunName'.
  %%     The node `AppNode' should match one of the templates specified `?FUN_APPY(M,F,A)'.
  -spec update_app_fun(syntaxTree(), syntaxTree()) ->syntaxTree().
  update_app_fun(AppNode, FunName) ->
      AppNode1=update_app_node(AppNode, {fun_name, FunName}),
      wrangler_misc:rewrite(AppNode, AppNode1).
     
  %% @doc Replaces the arguments of a function application node with `Args'.
  %%     The node `AppNode' should match one of the templates specified `?FUN_APPY(M,F,A)'.
  -spec update_app_args(syntaxTree(), [syntaxTree()]|syntaxTree())->syntaxTree().
  update_app_args(AppNode, Args) ->
      AppNode1=update_app_node(AppNode, {args, Args}),
      wrangler_misc:rewrite(AppNode, AppNode1).
  
  -spec match_app_node(syntaxTree()) -> #fun_app{}.                            
  match_app_node(AppNode) ->
      case match(?T("Fun@(N@@, M@, F@, Args@)"), AppNode) of
          {true, Bind} ->
  