   end
 
   def get_module_name(module_name) do
-    get_module_name(module_name, get)
+    Agent.get(__MODULE__, fn(state) ->
+      do_get_module_name(module_name, state)
+    end)
   end
 
-  def get_module_name(module_name, state) do
+  defp do_get_module_name(module_name, state) do
     std_lib_map = state.std_lib_map
     case Map.get(std_lib_map, module_name) do
       nil ->


  def add_protocol_impl(protocol, type, impl) do
    Agent.update(__MODULE__, fn state ->
      proto = do_get_module(state, protocol)

      if proto == nil do
        proto = %ElixirScript.Module{ name: protocol, impls: HashDict.new, type: :protocol }

  end

  def get_module(module) when is_atom(module) do
    do_get_module(module)
  end

  def get_module({:__aliases__, _, _} = name) do
    do_get_module(name)
  end

  def get_module(module_name_list) when is_list(module_name_list) do
    do_get_module(Utils.quoted_to_name({:__aliases__, [], module_name_list}))
  end

  defp do_get_module(name) do
    Agent.get(__MODULE__, fn(state) ->
      Map.get(state.modules, do_get_module_name(name, state))
    end)
  end

  def add_module_reference(module_name, module_ref) do
    Agent.update(__MODULE__, fn(state) ->
      case Map.get(state.modules, do_get_module_name(module_name, state)) do
        nil ->
          state
        module ->
          module = %{ module | module_refs: Enum.uniq(module.module_refs ++ [module_ref]) }
          %{ state | modules: Map.put(state.modules, module.name, module) }
      end
    end)
  end

  def get_module_references(module_name) do
