 
         Registry.register(registry, "world", 1)
         assert Registry.lookup(registry, "world") == [{self(), 1}]
-        assert Registry.update_value(registry, "world", & &1 + 1) == {2, 1}
+        assert Registry.update_value(registry, "world", &(&1 + 1)) == {2, 1}
         assert Registry.lookup(registry, "world") == [{self(), 2}]
       end
 
       test "dispatches to a single key", %{registry: registry} do
-        assert Registry.dispatch(registry, "hello", fn _ ->
-          raise "will never be invoked"
-        end) == :ok
+        fun = fn _ -> raise "will never be invoked" end
+        assert Registry.dispatch(registry, "hello", fun) == :ok
 
         {:ok, _} = Registry.register(registry, "hello", :value)
 
-        assert Registry.dispatch(registry, "hello", fn [{pid, value}] ->
-          send(pid, {:dispatch, value})
-        end)
+        fun = fn [{pid, value}] -> send(pid, {:dispatch, value}) end
+        assert Registry.dispatch(registry, "hello", fun)
 
         assert_received {:dispatch, :value}
       end


      test "has unique registrations even if partition is delayed", %{registry: registry} do
        {owner, task} = register_task(registry, "hello", :value)
        assert Registry.register(registry, "hello", :other) ==
               {:error, {:already_registered, task}}

        :sys.suspend(owner)
        kill_and_assert_down(task)

      test "supports match patterns", %{registry: registry} do
        value = {1, :atom, 1}
        {:ok, _} = Registry.register(registry, "hello", value)
        assert Registry.match(registry, "hello", {1, :_, :_}) == [{self(), value}]
        assert Registry.match(registry, "hello", {1.0, :_, :_}) == []
        assert Registry.match(registry, "hello", {:_, :atom, :_}) == [{self(), value}]
        assert Registry.match(registry, "hello", {:"$1", :_, :"$1"}) == [{self(), value}]
        assert Registry.match(registry, "hello", :_) == [{self(), value}]
        assert Registry.match(registry, :_, :_) == []

        value2 = %{a: "a", b: "b"}
        {:ok, _} = Registry.register(registry, "world", value2)
        assert Registry.match(registry, "world", %{b: "b"}) == [{self(), value2}]
      end

      test "supports guard conditions", %{registry: registry} do
        value = {1, :atom, 2}
        {:ok, _} = Registry.register(registry, "hello", value)

        assert Registry.match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 1}]) ==
                 [{self(), value}]

        assert Registry.match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 2}]) == []

        assert Registry.match(registry, "hello", {:_, :"$1", :_}, [{:is_atom, :"$1"}]) ==
                 [{self(), value}]
      end

      test "unregister_match supports patterns", %{registry: registry} do
