How to declare type variables using elixir/dialyixir?

Maybe @spec id(t) :: t. T seems to be considered as an atom :"Elixir.T" by dializer, and not a variable.

No that doesn’t work either.

Is the error the same?

What about

@spec id(t) :: t when t: any

Close… when a: var, or t

Thanks, I know longer get a compiler error but i’m not sure what it’s doing.
I would have expected the following to give an error

defmodule TypeVariables do
  @spec id(t) :: t when t: var
  def id(x) do
    Atom.to_string(x)
  end

  def run() do
    id(:foo)
  end
end

It’s a function taking an atom and returning a string

Defining a specification

Type variables with no restriction can also be defined.

That reads as if it is simply unconstrained rather than unified.

In my experience dialyzer wants specifics, e.g.

  @type my_t(t) :: list(t)
  @type my_int_t :: my_t(integer())
  @spec id(t) :: t when t: my_int_t
  @spec id(t) :: t when t: integer()
  @spec id(atom()) :: atom()
  def id(x) do
    x
  end

  @spec run() :: r when r: atom()
  def run() do
    id(:foo)
  end

  @spec run2() :: r when r: integer()
  def run2() do
    id(10)
  end

  @spec run3() :: r when r: my_int_t
  def run3() do
    id([10])
  end

Does equivalent Erlang code produce the same not-warning?

Even in Erlang the error isn’t detected on id/1 - it is only caught if you spec run/0

-spec id(T) -> T.
id(X) ->
    X,
    10.

-spec run() -> atom().
run() ->
    id(foo).

$ dialyzer frequency.erl
  Checking whether the PLT /Users/wheatley/.dialyzer_plt is up-to-date... yes
  Proceeding with analysis...
frequency.erl:250: Function id/1 will never be called
frequency.erl:254: Invalid type specification for function frequency:run/0. The success typing is () -> 10
frequency.erl:255: Function run/0 will never be called
 done in 0m0.14s
done (warnings were emitted)

The Erlang documentation sets the expectation that it should work

Type variables can be used in specifications to specify relations for the input and output arguments of a function.

Edit: I suspect that we are overlooking the “success typing” aspect. Strictly speaking any type is a term() so:

• @spec id(atom()) :: String.t()
• satisfies @spec id(t) :: t when t: term()
• therefore @spec id(t) :: t when t: var is satisfied.

Type variables are not unified by dialyzer. In the spec @spec id(t) :: t when t: var, the t as arg and t as return may as well be different type variables entirely.

Does anyone do this or similar.
Here I am using a spec’d identity function to “cast” a binary to an opaque type which will instruct dialyzer to warn when I try to use it in normal strip operation.

defmodule MyID do
  @opaque t(x) :: x

  @spec id(binary) :: t(binary)
  def id(x) do
    x
  end

  def run do
    id = id("alice")
    String.upcase(id)
  end
end