       ** (Version.InvalidRequirementError) == ==1.0.0
 
   """
-  @spec match?(version, requirement) :: boolean
-  def match?(version, requirement) when is_binary(requirement) do
+  @spec match?(version, requirement, Keyword.t) :: boolean
+  def match?(version, requirement, opts \\ [])
+
+  def match?(version, requirement, opts) when is_binary(requirement) do
     case parse_requirement(requirement) do
       {:ok, requirement} ->
-        match?(version, requirement)
+        match?(version, requirement, opts)
       :error ->
         raise InvalidRequirementError, message: requirement
     end
   end
 
-  def match?(version, %Requirement{matchspec: spec}) do
-    {:ok, result} = :ets.test_ms(to_matchable(version), spec)
+  def match?(version, %Requirement{matchspec: spec}, opts) do
+    allow_pre = Keyword.get(opts, :allow_pre, true)
+    {:ok, result} = :ets.test_ms(to_matchable(version, allow_pre), spec)
     result != false
   end
 

      if valid_requirement?(lexed) do
        first = to_condition(lexed)
        rest  = Enum.drop(lexed, 2)
        {:ok, [{{:'$1', :'$2', :'$3', :'$4'}, [to_condition(first, rest)], [:'$_']}]}
      else
        :error
      end

    defp to_condition([:'>', version | _]) do
      {major, minor, patch, pre} = parse_condition(version)

      {:orelse, main_condition(:'>', {major, minor, patch}),
                {:andalso, main_condition(:'==', {major, minor, patch}),
                           {:andalso, no_pre_condition(pre),
                                      pre_condition(:'>', pre)}}}
    end

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

      {:orelse, main_condition(:'==', matchable),
                to_condition([:'>', version])}
    end

    defp to_condition([:'<', version | _]) do
      {major, minor, patch, pre} = parse_condition(version)

      {:orelse, main_condition(:'<', {major, minor, patch}),
                {:andalso, main_condition(:'==', {major, minor, patch}),
                           {:andalso, no_pre_condition(pre),
                                      pre_condition(:'<', pre)}}}
    end

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

      {:orelse, main_condition(:'==', matchable),
                to_condition([:'<', version])}
    end

