How to use the 'in' operator in guard clauses?

Question

I am trying to write an anagram checker in Elixir. It takes 2 words, the first one is a reference, the second is to be tested as a possible anagram of the first.

I am trying to write it with recursion and pattern matching. I get an error about using the inoperator in a guard clause:

(ArgumentError) invalid args for operator in, it expects a compile time list or range on the right side when used in guard expressions

I don't know what to do to fix it. Here is the code (error is in 4th definition):

defmodule MyAnagram do
  def anagram?([], []), do: true

  def anagram?([], word) do
    IO.puts 'Not an anagram, the reference word does not contain enough letters'
    false
  end

  def anagram?(reference, []) do
    IO.puts 'Not an anagram, some letters remain in the reference word'
    false
  end

  def anagram?(reference, [head | tail]) when head in reference do
    anagram?(reference - head, tail)
  end

  def anagram?(_, [head | _]) do
    IO.puts 'Not an anagram, #{head} is not in the reference word.'
    false
  end
end

score 23 · Accepted Answer · edited Jan 09 '20 at 22:45

This is caused by the following code (as you identified):

def anagram?(reference, [head | tail]) when head in reference do
  anagram?(reference - head, tail)
end

You can find the definition of the in macro in the source code, but I have copied it here for convenience - it also contains the following in the documentation:

Guards

The in operator can be used in guard clauses as long as the right-hand side is a range or a list. In such cases, Elixir will expand the operator to a valid guard expression. For example:
  when x in [1, 2, 3] 
translates to:
  when x === 1 or x === 2 or x === 3

The code that defines the macro:

  defmacro left in right do
    in_module? = (__CALLER__.context == nil)

    right = case bootstraped?(Macro) and not in_module? do
      true  -> Macro.expand(right, __CALLER__)
      false -> right
    end

    case right do
      _ when in_module? ->
        quote do: Elixir.Enum.member?(unquote(right), unquote(left))
      [] ->
        false
      [h|t] ->
        :lists.foldr(fn x, acc ->
          quote do
            unquote(comp(left, x)) or unquote(acc)
          end
        end, comp(left, h), t)
      {:%{}, [], [__struct__: Elixir.Range, first: first, last: last]} ->
        in_range(left, Macro.expand(first, __CALLER__), Macro.expand(last, __CALLER__))
      _ ->
        raise ArgumentError, <<"invalid args for operator in, it expects a compile time list ",
                                        "or range on the right side when used in guard expressions, got: ",
                                        Macro.to_string(right) :: binary>>
    end
  end

Your code block is hitting the last part in the case statement because it can't be guaranteed at compile time that your variable reference is of type list (or range.)

You can see what value is being passed to the macro by calling:

iex(2)> quote do: head in reference                                       
{:in, [context: Elixir, import: Kernel],
 [{:head, [], Elixir}, {:reference, [], Elixir}]}

Here, the atom :reference is being passed to the in macro, which doesn't match any of the previous clauses so it falls through to the _ clause (which raises the error.)

To fix this, you will need to combine your last two clauses into one function:

  def anagram?(reference, [head | tail]) do
    case head in reference do
      false ->
        IO.puts 'Not an anagram, #{head} is not in the reference word.'
        false
      true ->
        anagram?(reference - head, tail)
    end
  end

It is also worth noting that you probably want to use "strings" instead of 'char_lists' http://elixir-lang.org/getting-started/binaries-strings-and-char-lists.html#char-lists

The other thing is that calling reference - head won't work (it will raise an ArithmeticError). You might want to look at List.delete/2 to remove an item from a list.

Thanks ! Can you elaborate on your last 2 points. Why would I want to use "strings" instead of char lists ? good catch for the `-`, my intention was to use `--` but my fingers poorly interpreted the plan. This works with char lists, not strings. — svarlet, Jul 02 '15 at 15:17
@svarlet Generally, char_lists are only used to maintain support with Erlang libraries. Elixir libraries usually prefer strings as they have fantastic UTF-8 support. I tried to find a solid reference for you, but unfortunately most resources stop at "you should use strings unless interfacing with Erlang." — Gazler, Jul 02 '15 at 16:01
Although char lists work on IO, you should have the habit of using double quotes, otherwise it will certainly bite you later. For example, the String module only works with strings, which are double quoted. — José Valim, Jul 03 '15 at 05:52

How to use the 'in' operator in guard clauses?

1 Answers1

Guards