       :invalid_matchspec -> :error
     end
 
-    defp to_condition([:'==', version | _]) do
+    defp to_condition([:==, version | _]) do
       matchable = parse_condition(version)
-      main_condition(:'==', matchable)
-    end
-
-    defp to_condition([:'!=', version | _]) do
+      main_condition(:==, matchable)
+    end
+
+    defp to_condition([:!=, version | _]) do
       matchable = parse_condition(version)
       main_condition(:'/=', matchable)
     end
 
-    defp to_condition([:'~>', version | _]) do
+    defp to_condition([:~>, version | _]) do
       from = parse_condition(version, true)
       to   = approximate_upper(from)
 
-      {:andalso, to_condition([:'>=', matchable_to_string(from)]),
-                 to_condition([:'<', matchable_to_string(to)])}
-    end
-
-    defp to_condition([:'>', version | _]) do
+      {:andalso, to_condition([:>=, matchable_to_string(from)]),
+                 to_condition([:<, matchable_to_string(to)])}
+    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}),
+      {: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
+                                      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
+      {: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}),
+      {: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
+                                      pre_condition(:<, pre)}}}
+    end
+
+    defp to_condition([:<=, version | _]) do
       matchable = parse_condition(version)
 
-      {:orelse, main_condition(:'==', matchable),
-                to_condition([:'<', version])}
+      {:orelse, main_condition(:==, matchable),
+                to_condition([:<, version])}
     end
 
     defp to_condition(current, []) do
       current
     end
 
-    defp to_condition(current, [:'&&', operator, version | rest]) do
+    defp to_condition(current, [:&&, operator, version | rest]) do
       to_condition({:andalso, current, to_condition([operator, version])}, rest)
     end
 
-    defp to_condition(current, [:'||', operator, version | rest]) do
+    defp to_condition(current, [:||, operator, version | rest]) do
       to_condition({:orelse, current, to_condition([operator, version])}, rest)
     end
 

    @moduledoc false
    import Parser.DSL

    deflexer ">=",    do: :'>='
    deflexer "<=",    do: :'<='
    deflexer "~>",    do: :'~>'
    deflexer ">",     do: :'>'
    deflexer "<",     do: :'<'
    deflexer "==",    do: :'=='
    deflexer "!=",    do: :'!='
    deflexer "!",     do: :'!='
    deflexer " or ",  do: :'||'
    deflexer " and ", do: :'&&'
    deflexer " ",     do: :' '

    deflexer x, [] do

        is_binary h ->
          [h <> x | acc]

        h in [:||, :&&] ->
          [x, :==, h | acc]

        true ->
          [x, h | acc]
