Create @behaviour and @type with macro

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

+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?

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.

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.

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