anchor.diff:    
     add_ancestor(Methods, AncestorClass);
   add_ancestor(Methods, {class, _Line, {constant, _, AncestorName}, AncestorMethods}) ->
  -  lists:foldr(
  -    fun(Function, Dict) ->
  -      {function, _, {identifier, _, Name}, _, _} = Function,
  +  lists:foldl(
  +    fun({function, _, {identifier, _, Name}, _, _} = Function, Dict) ->
         dict:store(Name, {method, AncestorName, Function}, Dict) 
       end,
       Methods,
  
positive.code:   lists:flatten([
      start_functions(Module),
      default_functions(),
      method_functions(Module, Methods)
    ]).
    
  %% Build a dispatch_method function and functions for each of the mangled methods
  method_functions(Module, Methods) ->
    % Decompose the function clauses for methods into handle_call clauses
    {Clauses, Functions} = process_methods(Module, Methods),
    [build_method_dispatch_function(Clauses)|Functions].
   
  %% Process methods into a list of clauses for dispatch_method and functions
  %% with mangled names for each method
  process_methods(Module, Methods) ->
    FinalMethods = merge_methods(Module, Methods),
    {NewClauses, NewFunctions} = lists:foldl(fun(Method, {Clauses, Functions}) ->
      {Clause, Function} = process_method(Method),
      {[Clause|Clauses], [Function|Functions]}
    end, {[],[]}, FinalMethods),
    {lists:reverse(NewClauses), lists:reverse(NewFunctions)}.
    
  %% 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
    ),
    [Method || {_, Method} <- dict:to_list(MethodDict)].
    
  %% Extract a method into its dispatch_method clause and mangled form
  process_method({function, Line, Name, _Arity, Clauses}) ->
    MangledName = reia_mangle:method(Name),
    DispatcherClause = dispatcher_clause(Name, MangledName, Line),
    Function = {function, Line, MangledName, 3,
      [process_method_clause(Clause) || Clause <- Clauses]
  
negative.code:     "code_change(_OldVsn, State, _Extra) -> {ok, State}."
    ]].
    
  %% Functions for starting a new object
  start_functions(Module) ->
    [start_function(Module, Function) || Function <- [{"spawn", "start"}, {"spawn_link", "start_link"}]].
  