Keyword.put in macro results in AST instead of keyword list

Questions / Help
,
1

I am currently stuck in implementing a macro :thinking: Here’s the code I currently have (without unnecessary code):

defmacro request(opts \\ [], do: expr) do
  quote
    typedstruct unquote(opts) do
      unquote(expr)
    end
  end
end

That macro works fine, but I would like to add some options that cannot be overwritten, so I tried this:

defmacro request(opts \\ [], do: expr) do
  quote
    typedstruct Keyword.put(unquote(opts), :module, Req) do
      unquote(expr)
    end
  end
end

Sadly, this fails with a compilation error:

** (FunctionClauseError) no function clause matching in Access.get/3    
    
    The following arguments were given to Access.get/3:
    
        # 1
        {{:., [line: 6], [{:__aliases__, [line: 6, counter: {ChangeUser, 8}, alias: false], [:Keyword]}, :put]}, [line: 6], [[], :module, {:__aliases__, [line: 6, counter: {ChangeUser, 8}, alias: false], [:Req]}]}
    
        # 2
        :enforce
    
        # 3
        nil
    
    Attempted function clauses (showing 6 out of 6):
    
        def get(%module{} = container, key, default)
        def get(map, key, default) when is_map(map)
        def get(list, key, default) when is_list(list) and is_atom(key)
        def get(list, key, _default) when is_list(list) and is_integer(key)
        def get(list, key, _default) when is_list(list)
        def get(nil, _key, default)

That error occurs, because an AST is passed to the typedstruct-macro instead of a keyword list and typed_struct then tries to call opts[:enforce] (tuples do not implement the Access-behaviour).

Is there anyone who can help me figure out what is happening and how to solve this issue? :slight_smile:

2

Move it outside of the quote:

defmacro request(opts \\ [], do: expr) do
  opts = Keyword.put(opts, :module, Req)

  quote do
    typedstruct unquote(opts) do
      unquote(expr)
    end
  end
end

Otherwise, as you pointed out, the code you end up with will literally be the same as typing out:

typedstruct Keyword.put([some: :user, provided: :opts], :module, Req) do
  # unquoted_expr
end

The reason you don’t have to do anything special with opts in the macro body is that lists are one of the constructs that return themselves when quoted.

EDIT: Just re-reading my answer after getting pinged about it:

For good measure you should call Macro.escape on the value you put in the keyword list:

opts = Keyword.put(opts, :module, Macro.escape(Req))

It won’t make any difference in this case (Macro.escape(Req) #=> Req) but if you put other values (like maps, for example) as value, you’ll need to do this so that you get the proper ast representation to be later unquoted.

1 Like
3

Yes, but no :confused: Let me give you more code/context! :wink:

That’s more or less what I currenlty have:

defmodule Operation do
  use TypedStruct

  defmacro request(opts \\ [], do: expr) do
    quote do
      typedstruct unquote(opts) do
        unquote(expr)
      end
    end
  end
end

defmodule ChangeUser do
  use Operation

  request do
    field :name, String.t()
    # ...
  end
end

This would create me a ChangeUser-struct, but that’s not what I want. I would like to have ChangeUser.Req. That can be done by passing module: Req as opts to typedstruct. I could change ChangeUser to this:

defmodule ChangeUser do
  use Operation

  request module: Req do     # <---- changed
    field :name, String.t()
    # ...
  end
end

But I would like to always have the [...].Req module. That’s why I moved it to the macro.

Here’s the code with your suggested change:

defmodule Operation do
  use TypedStruct

  defmacro request(opts \\ [], do: expr) do
   opts = Keyword.put(opts, :module, Req)     # <----- your suggestion

    quote do
      typedstruct unquote(opts) do
        unquote(expr)
      end
    end
  end
end

defmodule ChangeUser do
  use Operation

  request do
    field :name, String.t()
    # ...
  end
end

Using your suggested change, I would end up with a Req module, not a ChangeUser.Req, because the context is different. Outside of the quoted block, I am in the Operation-context, inside the quoted block in the ChangeUser-context.

Edit: FYI: When passing the module-option to the typedstruct-macro, a new module gets defined, inside the module where typedstruct is called.

4

Ah yes, that changes things!

So first thing, the way you’re doing use TypedStruct isn’t going to work. You actually want ChangeUser (or whatever module is useing Operation) to be using it. Perhaps you’ve left out some code, but basically you want something like this:

defmodule Operation do
  defmacro __using__(_) do
    quote do
      use TypedStruct
      import Operation
    end
  end

  defmacro request(opts \\ [], do: expr) do
    opts = Keyword.put(opts, :module, Module.concat([__CALLER__.module, Req]))
  
    quote do
      typedstruct unquote(opts) do
        unquote(expr)
      end
    end
  end
end
5

Great :partying_face: It works!

A few minutes ago, I found some code using __CALLER__, but I was unsure about it. Now I know it better.

Thank you!

1 Like
6

No prob!

You often don’t need to use __CALLER__ but in this case typedstruct is a macro itself, so of course its arguments get quoted so you need to grab the caller’s module name outside the quote block. But most of the time you can just use __MODULE__ inside the quote block:

defmodule Bar do
  defmarco __using__(_) do
    quote do
      dbg(__MODULE__)
    end
  end
end

defmodule Foo do
  use Bar
end

dbg here will be Foo.

1 Like