     quote do: (var!(op) == :! or var!(op) == :not)
   end
 
-  defp translate_assertion({ :==, _, [left, right] }) do
+  defp translate_assertion({ :==, _, [left, right] }, _else) do
     { expected, actual } = guess_expected_and_actual(left, right)
     assert_operator :==, expected, actual, "equal to (==)"
   end
 
-  defp translate_assertion({ :<, _, [left, right] }) do
+  defp translate_assertion({ :<, _, [left, right] }, _else) do
     assert_operator :<, left, right, "less than"
   end
 
-  defp translate_assertion({ :>, _, [left, right] }) do
+  defp translate_assertion({ :>, _, [left, right] }, _else) do
     assert_operator :>, left, right, "more than"
   end
 
-  defp translate_assertion({ :<=, _, [left, right] }) do
+  defp translate_assertion({ :<=, _, [left, right] }, _else) do
     assert_operator :<=, left, right, "less than or equal to"
   end
 
-  defp translate_assertion({ :>=, _, [left, right] }) do
+  defp translate_assertion({ :>=, _, [left, right] }, _else) do
     assert_operator :>=, left, right, "more than or equal to"
   end
 
-  defp translate_assertion({ :===, _, [left, right] }) do
+  defp translate_assertion({ :===, _, [left, right] }, _else) do
     { expected, actual } = guess_expected_and_actual(left, right)
     assert_operator :===, expected, actual, "equal to (===)"
   end
 
-  defp translate_assertion({ :!==, _, [left, right] }) do
+  defp translate_assertion({ :!==, _, [left, right] }, _else) do
     { expected, actual } = guess_expected_and_actual(left, right)
     assert_operator :!==, expected, actual, "not equal to (!==)"
   end
 
-  defp translate_assertion({ :!=, _, [left, right] }) do
+  defp translate_assertion({ :!=, _, [left, right] }, _else) do
     { expected, actual } = guess_expected_and_actual(left, right)
     assert_operator :!=, expected, actual, "not equal to (!=)"
   end
 
-  defp translate_assertion({ :access, _, [container, base] }) do
+  defp translate_assertion({ :access, _, [container, base] }, _else) do
     quote do
       container = unquote(container)
       base = unquote(base)

    end
  end

  defp translate_assertion({ op, _, [{ :access, _, [container, base] }] }) when negation?(op) do
    quote do
      container = unquote(container)
      base = unquote(base)


  """
  defmacro assert(expected) do
    translate_assertion(expected, fn ->
      quote do
        value = unquote(expected)
        assert value, "Expected #{inspect value} to be true"
      end
    end)
  end

  @doc """
  Refutes the `expected` value is true.

  `refute` in general tries to be smart and provide a good
  reporting whenever there is a failure.

  ## Examples

      refute false

  """
  defmacro refute(expected) do
    contents = translate_assertion({ :!, 0, [expected] }, fn ->
      quote do
        value = unquote(expected)
        assert !value, "Expected #{inspect value} to be false"
      end
    end)

    { :!, 0, [contents] }
  end

  @doc """
