anchor.diff:  %% Create an instance of a given class, passing the arguments on to its 
   %% initialize function
   inst(Class, Arguments, _Block) ->
  -  apply(Class, 'start_link', Arguments).
  +  Obj = Class:spawn_link(),
  +  call(Obj, {'initialize', Arguments}),
  +  Obj.
   
   %% Call a method on a Reia object at the given Pid
  -call(Pid, {_Method, _Arguments} = Request) ->
  +call({object, {Pid, _Class}}, Request) ->
  +  call(Pid, Request);
  +call(Pid, {_Method, _Arguments} = Request) when is_pid(Pid) ->
     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
  +%% Process incoming methods and build the functions for the resulting module
  +build_functions(Module, Methods) ->  
  +  lists:flatten([
  +    start_functions(Module), 
  +    default_functions(), 
  +    method_functions(merge_methods(Module, Methods))
  +  ]).
  +  
  +%% Merge default methods with the user-defined ones
  +merge_methods(Module, Methods) -> 
  +  MethodDict = lists:foldr(
  +    fun(Function, Dict) -> 
  +      {function, _Line, Name, _Arity, _Clauses} = Function,
  +      dict:store(Name, Function, Dict)
  +    end,
  +    dict:from_list(default_methods(Module)), 
  +    Methods
     ),
  -    
  -  % 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.
  +  [Method || {_, Method} <- dict:to_list(MethodDict)].
     
   %% Construct the initialize method (as a function call for now, ugh)
   initialize_method({function, Line, Name, _Arity, Clauses}) ->
  
positive.code: 
  %% Convert a Reia class definition into a Reia module which conforms to the
  %% gen_server behavior, then load it into the code server
  build({class, Line, Name, Functions}) ->
    Functions2 = process_functions(Name, Functions),
    % [io:format(erl_pp:form(Function)) || Function <- Functions2],
    Module = {module, Line, Name, Functions2},
    % io:format("~p~n", [Module]),
  
negative.code: parse_function(String) ->
    {ok, Scanned, _} = erl_scan:string(String),
    {ok, Form} = erl_parse:parse_form(Scanned),
    Form.