           case :binary.split(codepoints, "..") do
             [<<codepoint::4-binary, _::binary>>] ->
               [String.to_integer(codepoint, 16)]
+
             [first, <<last::4-binary, _::binary>>] ->
               Enum.to_list(String.to_integer(last, 16)..String.to_integer(first, 16))
           end
+
         put_elem(acc, pos, entries ++ elem(acc, pos))
       else
         acc
       end
-    end
+    end)
 
   id_upper = letter_uptitlecase -- patterns
   id_start = start -- patterns
   id_continue = continue -- patterns
 
-  unicode_upper = Enum.filter(id_upper, & &1 > 127)
-  unicode_start = Enum.filter(id_start, & &1 > 127)
-  unicode_continue = Enum.filter(id_continue, & &1 > 127)
+  unicode_upper = Enum.filter(id_upper, &(&1 > 127))
+  unicode_start = Enum.filter(id_start, &(&1 > 127))
+  unicode_continue = Enum.filter(id_continue, &(&1 > 127))
 
   rangify = fn [head | tail] ->
     {first, last, acc} =
       Enum.reduce(tail, {head, head, []}, fn
         number, {first, last, acc} when number == first - 1 ->
           {number, last, acc}
+
         number, {first, last, acc} ->
           {number, number, [{first, last} | acc]}
       end)
+
     [{first, last} | acc]
   end
 

      defp ascii_pattern?(entry) when entry in unquote(first)..unquote(last), do: true
    end
  end
  defp ascii_pattern?(_), do: false

  def tokenize([head | tail]) do
    cond do
      ascii_upper?(head) ->
        validate(continue(tail, [head], 1, true, []), :alias)
      ascii_start?(head) ->
        validate(continue(tail, [head], 1, true, []), :identifier)
      unicode_upper?(head) ->
        validate(continue(tail, [head], 1, false, []), :atom)
      unicode_start?(head) ->
        validate(continue(tail, [head], 1, false, []), :identifier)
      true ->
        {:error, :empty}
    end
  end
  def tokenize([]) do
    {:error, :empty}
  end

      defp unicode_start?(entry) when entry in unquote(first)..unquote(last), do: true
    end
  end

  defp unicode_start?(_), do: false

  unless {13312, 19893} in range do
