Incompatible types warning on complex defguard within elixir 1.11.3

Questions / Help
1

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 ?

1 Like
3

It is related to Elixir. We already have something in the issues tracker to handle this case. :slight_smile:

2 Likes
4

Great! I did a quick search in the issues and the most similar is this one "Incompatible types in guard" warning · Issue #10611 · elixir-lang/elixir · GitHub which is closed but does not apply here ( tested also with latest master of today and still happens ), so must be some different issue which I did not noticed.

Thanks, I’ll take a look on the issues so.

5

It is this one: Doctest generates an incompatible type warning · Issue #10485 · elixir-lang/elixir · GitHub :slight_smile:

2 Likes
6

Here’s a reduced test case.

defmodule Warning do
  defguardp is_tuple_or_nil(param) when is_nil(param) or is_tuple(param)
                   
  def hello(param) when is_atom(param) and is_tuple_or_nil(param) do
    :is_atom_or_nil
  end
end
3 Likes