Well,

while migrating to elixir 1.11.3 (from 1.10.4) I’ve a new warning about a somewhat complex guard expression that has incompatible types.

An example code triggering that is something like:

  @allowed_types [
    :any,
    :atom,
    :boolean,
    false,
    :float,
    :integer,
    :keyword,
    :list,
    :map,
    nil,
    :number,
    :string,
    :struct,
    true,
    :tuple
  ]

  defguardp is_complex(param)
            when (is_tuple(param) and
                    elem(param, 0) in @allowed_types) or
                   param in @allowed_types

  def hello(param) when is_atom(param) and is_complex(param) do
    "1st guard: #{inspect(param)}"
  end

  def hello(param) when is_complex(param) do
    "2nd guard: #{inspect(param)}"
  end

The warning is pretty long, only on the first hello/1

warning: incompatible types:

    atom() !~ tuple()

in expression:

    # lib/foo.ex:38
    is_atom(param) and (is_tuple(param) and (elem(param, 0) === :any or elem(param, 0) === :atom or elem(param, 0) === :boolean or elem(param, 0) === false or elem(param, 0) === :float or elem(param, 0) === :integer or elem(param, 0) === :keyword or elem(param, 0) === :list or elem(param, 0) === :map or elem(param, 0) === nil or elem(param, 0) === :number or elem(param, 0) === :string or elem(param, 0) === :struct or elem(param, 0) === true or elem(param, 0) === :tuple) or (param === :any or param === :atom or param === :boolean or param === false or param === :float or param === :integer or param === :keyword or param === :list or param === :map or param === nil or param === :number or param === :string or param === :struct or param === true or param === :tuple))

where "param" was given the type atom() in:

    # lib/foo.ex:38
    is_atom(param)

where "param" was given the type tuple() in:

    # lib/foo.ex:38
    is_tuple(param) and (elem(param, 0) === :any or elem(param, 0) === :atom or elem(param, 0) === :boolean or elem(param, 0) === false or elem(param, 0) === :float or elem(param, 0) === :integer or elem(param, 0) === :keyword or elem(param, 0) === :list or elem(param, 0) === :map or elem(param, 0) === nil or elem(param, 0) === :number or elem(param, 0) === :string or elem(param, 0) === :struct or elem(param, 0) === true or elem(param, 0) === :tuple) or (param === :any or param === :atom or param === :boolean or param === false or param === :float or param === :integer or param === :keyword or param === :list or param === :map or param === nil or param === :number or param === :string or param === :struct or param === true or param === :tuple)

Conflict found at
  lib/foo.ex:38: Foo.hello/1

The expression works perfectly as expected and while it can be simplified to avoid the compiler warning, I’m really curious on what’s wrong here, if is something related to elixir 1.11 or the author.

In the example code the custom guard does not make a lot of sense, but in the original one is used to avoid creating different guards and reusing the same one everywhere.

Any suggestion ?