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


    defp to_condition([:!=, version | _]) do
      matchable = parse_condition(version)
      main_condition(:'/=', matchable)
    end

    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
      {major, minor, patch, pre} = parse_condition(version)

      {:andalso, {:orelse, main_condition(:>, {major, minor, patch}),
                           {:andalso, main_condition(:==, {major, minor, patch}),
                                      pre_condition(:>, pre)}},
                  no_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}),
                           pre_condition(:<, pre)}}
    end

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

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

    defp to_condition(current, []) do

      {"!=", :!=},
      {"!", :!=},
      {" or ", :||},
      {" and ", :&&}
    ]

    for {string_op, atom_op} <- operators do
      def lexer(unquote(string_op) <> rest, acc) do
        lexer(rest, [unquote(atom_op) | acc])
