anchor.diff:    {clause, Line, Arguments2, Guards, Expressions2}.
     
   %% Build a dispatch_method function and functions for each of the mangled methods
  -method_functions(Module, Methods) ->
  +method_functions(Methods) ->
     % Decompose the function clauses for methods into handle_call clauses
  -  {Clauses, Functions} = process_methods(Methods ++ default_methods(Module)),
  +  {Clauses, Functions} = process_methods(Methods),
     [build_method_dispatch_function(Clauses)|Functions].
   
   %% Generate Erlang forms for the class's method dispatch function
  
positive.code: %% Create an instance of a given class, passing the arguments on to its 
  %% initialize function
  inst(Class, Arguments, _Block) ->
    apply(Class, 'start_link', Arguments).
  
  %% Call a method on a Reia object at the given Pid
  call(Pid, {_Method, _Arguments} = Request) ->
    case gen_server:call(Pid, Request) of
      {ok, Value} -> Value;
      {error, Error} -> throw(Error)
    end.
  
  %% Process incoming functions, substituting custom versions for defaults  
  process_functions(Module, Functions) ->
    {FunctionDict, Methods} = lists:foldr(
      fun process_function/2, 
      {dict:from_list(default_functions()), []}, 
      Functions
    ),
      
    % Pull the initialize function out for special case processing
    {ok, InitializeMethod} = dict:find(initialize, FunctionDict),
    FunctionDict2 = dict:erase(initialize, FunctionDict),
    
    DefaultFunctions = start_functions(Module, function_arity(InitializeMethod)),
    ImmediateFunctions = [Function || {_, Function} <- dict:to_list(FunctionDict2)],
    lists:flatten([
      DefaultFunctions, 
      ImmediateFunctions, 
      initialize_method(InitializeMethod), 
      method_functions(Module, Methods)
    ]). 
    
  %% If a method name matches one of the default_functions(), then it has a
  %% special purpose and should be mapped to a function rather than a method.
  process_function({function, _Line, Name, _Arity, _Clauses} = Function, {Dict, Functions}) ->
    case dict:find(Name, Dict) of
      {ok, _} ->
        {dict:store(Name, Function, Dict), Functions};
      error ->
        {Dict, [Function|Functions]}
    end.
    
  %% Construct the initialize method (as a function call for now, ugh)
  initialize_method({function, Line, Name, _Arity, Clauses}) ->
  
negative.code: argument_list_cons([Element|Rest], Line) ->
    {cons, Line, Element, argument_list_cons(Rest, Line)}.
  
  %% These functions are required for the generated modules to implement the
  %% gen_server behavior
  default_functions() ->
    [parse_function(Function) || Function <- [
      "init([]) -> {ok, dict:new()}.",
      "handle_call(Request, From, State) -> try dispatch_method(Request, From, State) catch throw:Error -> {reply, {error, Error}, State} end.",
      "handle_cast(_Msg, State) -> {noreply, State}.",
      "handle_info(_Info, State) -> {noreply, State}.",
      "terminate(_Reason, _State) -> ok.",
      "code_change(_OldVsn, State, _Extra) -> {ok, State}.",
      "method_missing(_State, Method, _Args) -> throw({error, {Method, \"undefined\"}})."
    ]].
    
  %% Default methods that Reia objects respond to
  default_methods(Module) ->
    NameString = lists:concat(["reia_string:from_list(\"#<", Module, ">\")"]),
    [default_method(Function) || Function <- [
      "class() -> {constant, '" ++ atom_to_list(Module) ++ "'}.",
      "initialize() -> nil.",
      "to_s() -> " ++ NameString ++ ".",
      "inspect() -> " ++ NameString ++ "."
    ]].
    
  %% Parse a default function and return a dict entry for it  
  default_method(String) ->
    Form = parse_function(String),
    {function, _, Name, _, _} = Form,
    {Name, Form}.
    
  %% Functions for starting a new object
  start_functions(Module) ->
    [start_function(Module, Function) || Function <- [{"spawn", "start"}, {"spawn_link", "start_link"}]].
  
  start_function(Module, {ReiaFunc, OtpFunc}) ->
    String = [
      ReiaFunc, "() -> {ok, Pid} = gen_server:", OtpFunc, "('", Module, "', [], [])," ++ 
      "{object, {Pid, '", Module, "'}}."
    ],
    parse_function(lists:concat(String)).
    
  variable_list(0) ->
  