anchor.diff:      {noreply, #state{}} | {reply, term(), #state{}} |
       {stop, Reason::term(), #state{}} | {stop, Reason::term(), Reply::term(), #state{}}.
   
  -handle_call({register_type, Class, Type, Module}, _From, State) ->
  +handle_call({register_type, Class, Type, Module, Meta}, _From, State) ->
       AllModules1 = get_all_modules(Class),
       AllModules2 = lists:usort([Module|AllModules1]),
       AllTypes1 = get_all_types(Class),
       AllTypes2 = lists:usort([Type|AllTypes1]),
       ets:insert(?MODULE, [
  +        {{type, Class, Type}, Module},
  +        {{module, Class, Module}, Type},
  +        {{meta, Class, Type}, Meta},
           {{all_modules, Class}, AllModules2},
  -        {{all_types, Class}, AllTypes2},
  -        {{type, Class, Type}, Module},
  -        {{module, Class, Module}, Type}
  +        {{all_types, Class}, AllTypes2}
       ]),
       {reply, ok, State};
   
  
positive.code:             {reply, {error, function_error, State}}
      catch
          error:Error ->
          lager:warning("NkLIB Types: invalid meta respose (~p ~p): ~p", [Class, Type, Error]),
          {reply, {error, function_error, State}}
      end;
  
  handle_call(Msg, _From, State) ->
  
negative.code:     lookup({all_types, Class}, []).
  
  
  %% @doc Finds a type's metadata
  -spec get_meta(class(), type()) ->
      meta() | undefined.
  
  get_meta(Class, Type) ->
      lookup({meta, Class, to_bin(Type)}).
  
  
  %% @doc Registers a type with a module
  -spec register_type(class(), type(), module()) ->
      ok.
  
  register_type(Class, Type, Module) ->
      register_type(Class, Type, Module, #{}).
  
  
  %% @doc Registers a type with a module and some metadata
  -spec register_type(class(), type(), module(), meta()) ->
      ok.
  
  register_type(Class, Type, Module, Meta) when is_atom(Module), is_map(Meta) ->
      code:ensure_loaded(Module),
      gen_server:call(?MODULE, {register_type, Class, to_bin(Type), Module, Meta}).
  
  
  %% @doc Updates meta for a type
  