How to define Macro for a new Type?

That’s not possible with the uppercase first letter. Any call to a macro or function needs to start with a non uppercase letter.

Non-qualified calls, such as add(1, 2) , must start with an underscore or a Unicode letter that is not in uppercase or titlecase.

Qualified calls, such as Math.add(1, 2) , must start with an underscore or a Unicode letter that is not in uppercase or titlecase.

Syntax reference

Can’t a Macro generate a Module’s Name dynamically?

Let’s say, if I have a struct, couldn’t a Macro deftype, given an Uppercase name, dynamically generate this struct for me?

You can generate modules, but you cannot “call” modules. You can only call macros or functions. So Name("…") is not valid elixir syntax – Name.new("…") is.

Right!
A revision of my basic idea is needed !

defmodule Test do
  alias User
  import User.Name

  @spec run :: User.t
  def run do
    name = Name.new("John")
    IO.puts(Name.extract(name)) # Prints "John"
    User.new(name, 25)
  end
end

This should possible, right ?

Yes.

Start by writing the Name module by hand. That will show you what your macro would have to generate.

Here, I have defined a couple of hypothetical types, Name and Age. Their respective modules would be:

name

defmodule Name do
  @opaque t :: {:name, String.t()}

  @spec new(val :: String.t()) :: t
  def new(val) when is_binary(val), do: {:name, val}

  @spec extract(name :: t) :: String.t()
  def extract({:name, val}), do: val

  @spec name?(data :: any) :: boolean()
  def name?({:name, val}) when is_binary(val), do: true
  def name?(_data), do: false

  @spec is_name(data :: any) ::
          {:__block__ | {:., [], [:andalso | :erlang, ...]}, [],
           [{:= | {any, any, any}, [], [...]}, ...]}
  defguard is_name(value)
           when is_tuple(value) and elem(value, 0) == :name and is_binary(elem(value, 1))
end

which would be generated by invoking:

deftype Name, String.t() 

age

defmodule Age do
  @opaque t :: {:age, non_neg_integer()}

  @spec new(val :: non_neg_integer()) :: t
  def new(val) when is_integer(val), do: {:age, val}

  @spec extract(name :: t) :: non_neg_integer()
  def extract({:age, val}), do: val

  @spec age?(data :: any) :: boolean()
  def age?({:age, val}) when is_integer(val), do: true
  def age?(_data), do: false

  @spec is_age(data :: any) ::
          {:__block__ | {:., [], [:andalso | :erlang, ...]}, [],
           [{:= | {any, any, any}, [], [...]}, ...]}
  defguard is_age(value)
           when is_tuple(value) and elem(value, 0) == :age and is_integer(elem(value, 1))
end

which would be generated by using:

deftype Age, non_neg_integer() 

Do note a few things:

• The name of the module is used to create functions and guards
• We pass the value of the type in the macro

Would it be possible to achieve this, using macros?
If so, how?

Probably. Mutually recursive types however may well be difficult to do with this.

A lot of macro work. I’d start with the Metaprogramming Elixir book.

As an aside though: I’d seriously consider looking at Gleam. It’s a BEAM language w/ static types. If you want to push forward the boundaries of what will be possible with types on the BEAM I imagine that work in that ecosystem is going to be more fruitful than attempting to make it work in Elixir. If Jose tried to make it work and failed, I would think long and hard about taking it on yourself.

Can you elaborate more on this?

I was hoping there was a quicker way to achieve this goal, one that does not involve reading a full book. My read list is already big enough

I absolutely like the idea of Gleam, however the ecosystem is not there yet. You might say that Gleam is compatible with Elixir and Erlang libraries, but then if half of my project is in Gleam and the other half in Elixir, I just don’t see how that can end up well.

I don’t compare myself with people in general, but I was always under the impression that Jose never intended Elixir to be statically typed, or to even have many of the features static type languages have (please correct me if I am wrong).

While I am not trying to one up anyone, I am also not trying to re-invent the wheel. I am, from my humble point of view, trying to bring a concept generalized and well known in many other functional languages into Elixir, adapting it to what some could consider to be “in an Elixir way”.

At the end, there is a good chance you might be correct, and that I am in a fool’s errand. However I will never find out if I don’t try.

My Answer

After reading more about macros in Elixir, talking to the community and reading about NewType, I have refined my ideas. While the exact implementation of my original idea is not possible, with some changes you can still get the core benefit of NewType.

Changes to original idea

• No usage of Name("John") syntax. As explained in this post this syntax is not valid in Elixir.
• No defguard. Because the type is @opaque it is not possible to have a guard that analyses the internal structure of the data without having dialyzer complaining. Since the main goal here is to have Dialyzer help me detect issues, and since the internal structure of the opaque data can only be analyzed by functions that belong to the module itself, this means this idea is not possible.
• No verification on data type when invoking new. Originally I thought about having some verification mechanism, but this is not necessary, since dialyzer will let the user know if the user is invoking new with an incorrect parameter.
• No self-generated functions. Instead of having Age.age? or Name.name? I have opted for the more general NewType.is_type?/2, which will accomplish the same and is more general.

Code

With these changes in mind, this is the macro I came up with:

defmodule NewType do
  defmacro deftype(name, type) do
    quote do
      defmodule unquote(name) do
        @opaque t :: {unquote(name), unquote(type)}

        @spec new(value :: unquote(type)) :: t
        def new(value), do: {unquote(name), value}

        @spec extract(new_type :: t) :: unquote(type)
        def extract({unquote(name), value}), do: value
      end
    end
  end

  @spec is_type?(data :: {atom, any}, new_type :: atom) :: boolean
  def is_type?({type, _data}, new_type) when type == new_type, do: true
  def is_type?(_data, _new_type), do: false
end

Which can be used like:

type.ex:

defmodule Type do
  import NewType

  deftype Name, String.t()
end

test.ex:

defmodule Test do
  alias Type.Name

  @spec print(Name.t()) :: binary
  def print(name), do: Name.extract(name)

  def run do
    arg = 1
    name = Name.new(arg) # dialyzer detects error !
    {:ok, name}
  end
end