 
     defp to_condition(current, [:'||', operator, version | rest]) do
       to_condition({ :orelse, current, to_condition([operator, version]) }, rest)
+    end
+
+    defp parse_condition(version, approximate? // false) do
+      case parse_version(version, approximate?) do
+        { :ok, version } -> version
+        :error -> throw :invalid_matchspec
+      end
     end
 
     defp matchable_to_string({ major, minor, patch, pre }) do


  """
  @spec match?(t, requirement) :: boolean
  def match?(version, requirement) when is_binary(requirement) do
    try do
      match?(version, Version.Parser.parse_requirement(requirement))
    catch
      :throw, _ -> raise InvalidRequirement, message: requirement
    end
  end

  def match?(version, Requirement[matchspec: spec]) do
    try do
      { :ok, result } = :ets.test_ms(to_matchable(version), spec)
      result != false
    catch
      :throw, _ -> raise InvalidVersion, message: version
    end
  end

  @doc """

    end

    defp to_condition([:'<=', version | _]) do
      matchable = parse_condition(version)

      { :orelse, { :andalso, { :not, { :is_binary, :'$1' } },
                             { :'==', :'$_', { :const, matchable } } },
