Create @behaviour and @type with macro

Questions / Help
,
1

Hi, I have Elixir macro that I want to use it as @behaviour in my project. but there is a problem I can not be able to use a @type as a parameters of a macro.

My macro

defmodule MishkaPub.ActivityStream.Validator do
  defmacro __using__(opts) do
    quote(bind_quoted: [opts: opts]) do
      type = Keyword.get(opts, :type)
      module = Keyword.get(opts, :module)

      @type t :: unquote(type)
      @type action() :: :build | :validate

      @callback build(t()) :: {:ok, action(), t()} | {:error, action(), any()}
      @callback build(t(), list(String.t())) ::
                  {:ok, action(), t()} | {:error, action(), any()}

      @callback validate(t()) :: {:ok, action(), t()} | {:error, action(), any()}
      @callback validate(t(), list(String.t())) ::
                  {:ok, action(), t()} | {:error, action(), any()}

      @behaviour unquote(module)
    end
  end
end

And the Elixir file I want to use it

defmodule MishkaPub.ActivityStream.Type.Object do
  alias MishkaPub.ActivityStream.Validator

  @type tt :: %__MODULE__{
          id: String.t(),
          type: String.t(),
          name: String.t(),
          replies: list(String.t())
        }

  defstruct [
    :id,
    :type,
    ..
  ]

  use Validator, module: __MODULE__, type: tt()

  def build(%__MODULE__{} = params) do
    {:ok, :build, Map.merge(%__MODULE__{}, params)}
  rescue
    _e ->
      {:ok, :build, :unexpected}
  end

  ...
end

but I have this error

** (CompileError) lib/activity_stream/validator.ex:3: undefined function type/0 (there is no such import)

How can fix this error?

Another problem if this is fixed! I have 2 duplicated types. (tt(), t()) but I just want to have one type which should be t()

Thank you in advance :rose: :pray:

2

  1. Please note that @callback attribute is set in the module which defines the interface. While @behaviour is set in the module which implements the interface.

  2. So you’ll actually need something like this

defmodule MishkaPub.ActivityStream.Validator do
  @type action() :: :build | :validate
  @type t :: any() # Or what kind of argument Validator generally wants

  @callback build(t()) :: {:ok, action(), t()} | {:error, action(), any()}
  @callback build(t(), list(String.t())) ::
            {:ok, action(), t()} | {:error, action(), any()}

  @callback validate(t()) :: {:ok, action(), t()} | {:error, action(), any()}
  @callback validate(t(), list(String.t())) ::
            {:ok, action(), t()} | {:error, action(), any()}
end

defmodule MishkaPub.ActivityStream.Type.Object do
  alias MishkaPub.ActivityStream.Validator

  @type t :: %__MODULE__{
          id: String.t(),
          type: String.t(),
          name: String.t(),
          replies: list(String.t())
        }

  defstruct [
    :id,
    :type,
    ..
  ]

  @behaviour Validator

  @impl true
  @spec build(t()) :: {:ok, Validator.action(), t()} | {:error, Validator.action(), any()}
  def build(%__MODULE__{} = params) do
    {:ok, :build, Map.merge(%__MODULE__{}, params)}
  rescue
    _e ->
      {:ok, :build, :unexpected}
  end

  ...
end
3 Likes
3

+1 to what @hst337 said, the behaviour and the implementation need to be separate modules.

Some other thoughts:

  • passing __MODULE__ isn’t required, the module that said use is available as __MODULE__ inside the quote block.

    defmodule MacroDemo do
  defmacro __using__(opts) do
    IO.inspect(__MODULE__, label: "outside")

    quote(bind_quoted: [opts: opts]) do
      IO.inspect(__MODULE__, label: "inside")
    end
  end
end

defmodule Foo do
  use MacroDemo
end

# prints
outside: MacroDemo
inside: Foo

  • apart from failing to compile, the only thing that type in Validator does is define t. What about just expecting the user to write @type t :: etc etc etc outside of the use and then using it in the @callbacks?

2 Likes
4

I just wanted to create a structure to force programer to do something I want and prevent duplicating code!! so I figured out I have some duplicated @callback in many modules like:

@callback build(t()) :: {:ok, action(), t()} | {:error, action(), any()}

The only thing is different in each modules of my project the first entry of my type I mean t(), first of all I could use struct() for all of them but it is kind of of using any like and I want to have a specific one.

5

The folk in this thread are providing solid advice to improve your approach, which I would recommend following and would resolve your issues.

However, to address the specific cause of this error the way you are doing things today, for learning about Elixir metaprogramming:

You have an unquoting issue in your macro. Take just the lines here:

You have a variable, opts, inside of your macro’s context, containing a keyword list. To make that available to your generated code, you have to unquote it—which you have implicitly via bind_quoted, no problem!

That means that the variable you next introduce, type, is only available in the generated code. So when you proceed to unquote(type), you are getting the equivalent of variable type does not exists—since it does not exist inside the macro’s context.

You have 3 options:

  1. Unquote opts and extract the type exclusively in the generated code context:

    defmacro(__using__(opts) do
  quote(bind_quoted: [opts: opts]) do
    type = Keyword.get(opts, :type)
    @type t :: type
  end
end

  2. Extract the type exclusively in the macro context and unquote in the generate code:

    defmacro(__using__(opts) do
  type = Keyword.fetch!(opts, :type)
  quote do
    @type t :: unquote(type)
  end
end

  3. Extract the type exclusively in the macro context and bind_quoted:

    defmacro(__using__(opts) do
  type = Keyword.fetch!(opts, :type)
  quote [bind_quoted: [type: type]] do
    @type t :: type
  end
end

I believe the 3rd option is popular, although personally I tend to prefer the second, as I like to be explicit about my opts munging and unquote-ing.

2 Likes
6

Thank you it is very good to know how to do.

1 Like