Imaginemos una implementación de módulo Scaffold
que genera una estructura con campos personalizados predefinidos y la inyecta en el módulo llamado usando use Scaffold
. Cuando se llama use Scaffold, fields: foo: [custom_type()], ...
, queremos implementar el tipo correcto en el Consumer
módulo ( common_field
en el ejemplo siguiente, se define dentro Scaffold
o en otro lugar desde el exterior).
@type t :: %Consumer{
common_field: [atom()],
foo: [custom_type()],
...
}
Sería genial si pudiéramos generar con precisión el tipo Consumer.t()
para uso futuro y crear la documentación adecuada para los usuarios de nuestro nuevo módulo.
Un ejemplo más complicado se vería así:
defmodule Scaffold do
defmacro __using__(opts) do
quote do
@fields unquote(opts[:fields])
@type t :: %__MODULE__{
version: atom()
# magic
}
defstruct @fields
end
end
end
defmodule Consumer do
use Scaffold, fields: [foo: integer(), bar: binary()]
end
y, después de la compilación:
defmodule Consumer do
@type t :: %Consumer{
version: atom(),
foo: integer(),
bar: binary()
}
defstruct ~w|version foo bar|a
end
Parece fácil, ¿verdad?
Enfoque ingenuo
Comencemos analizando en qué AST ingresamos Scaffold.__using__/1
.
defmacro __using__(opts) do
IO.inspect(opts)
end
#⇒ [fields: [foo: {:integer, [line: 2], []},
# bar: {:binary, [line: 2], []}]]
Excelente. Parece que estamos a un paso del éxito.
quote do
custom_types = unquote(opts[:fields])
...
end
#⇒ == Compilation error in file lib/consumer.ex ==
# ** (CompileError) lib/consumer.ex:2: undefined function integer/0
¡Bams! Los tipos son algo especial, como dicen en la zona de Privoz; no podemos simplemente tomarlos y obtenerlos del AST en cualquier lugar. ¿Quizás unquote
funcionará localmente?
@type t :: %__MODULE__{
unquote_splicing([{:version, atom()} | opts[:fields]])
}
#⇒ == Compilation error in file lib/scaffold.ex ==
# ** (CompileError) lib/scaffold.ex:11: undefined function atom/0
No importa como sea. Los tipos son fastidiosos; pregúntele a cualquiera que se gane la vida con un Haskell (y estos siguen siendo tipos de fumadores en Haskell; los tipos reales, dependientes, son cien veces más útiles, pero doscientas veces más difíciles).
, , AST , , .
AST
, , . , , , - . , . , , AST ( unquote
binary()
, CompileError
.
, quote do
, , quote
, — AST.
quote do
Enum.map([:foo, :bar], & &1)
end
#⇒ {
# {:., [], [{:__aliases__, [alias: false], [:Enum]}, :map]}, [],
# [[:foo, :bar], {:&, [], [{:&, [], [1]}]}]}
? , AST, Enum
, :map
, . , AST quote
. .
, AST AST, . ? — , .
defmacro __using__(opts) do
fields = opts[:fields]
keys = Keyword.keys(fields)
type = ???
quote location: :keep do
@type t :: unquote(type)
defstruct unquote(keys)
end
end
, , — AST, . , ruby !
iex|1 quote do
...|1 %Foo{version: atom(), foo: binary()}
...|1 end
#⇒ {:%, [],
# [
# {:__aliases__, [alias: false], [:Foo]},
# {:%{}, [], [version: {:atom, [], []}, foo: {:binary, [], []}]}
# ]}
?
iex|2 quote do
...|2 %{__struct__: Foo, version: atom(), foo: binary()}
...|2 end
#⇒ {:%{}, [],
# [
# __struct__: {:__aliases__, [alias: false], [:Foo]},
# version: {:atom, [], []},
# foo: {:binary, [], []}
# ]}
, , . .
defmacro __using__(opts) do
fields = opts[:fields]
keys = Keyword.keys(fields)
type =
{:%{}, [],
[
{:__struct__, {:__MODULE__, [], ruby}},
{:version, {:atom, [], []}}
| fields
]}
quote location: :keep do
@type t :: unquote(type)
defstruct unquote(keys)
end
end
, Scaffold
, ( : Qqwy here). , , version: atom()
quote
.
defmacro __using__(opts) do
fields = opts[:fields]
keys = Keyword.keys(fields)
fields_with_struct_name = [__struct__: __CALLER__.module] ++ fields
quote location: :keep do
@type t :: %{unquote_splicing(fields_with_struct)}
defstruct unquote(keys)
end
end
(mix docs
):
: AST
, AST __using__/1
, ? , unquote
quote
? , , . , .
NB ,atom()
, , ,GenServer.on_start()
. .
, quote do
, - atom()
( CompileError
, ). , - :
keys = Keyword.keys(fields)
type =
{:%{}, [],
[
{:__struct__, {:__MODULE__, [], ruby}},
{:version, {:atom, [], []}}
| Enum.zip(keys, Stream.cycle([{:atom, [], []}]))
]}
, @type
? Quoted Fragment, :
defmodule Squares do
Enum.each(1..42, fn i ->
def unquote(:"squared_#{i}")(),
do: unquote(i) * unquote(i)
end)
end
Squares.squared_5
#⇒ 25
Quoted Fragments quote
, (bind_quoted:
). .
defmacro __using__(opts) do
keys = Keyword.keys(opts[:fields])
quote location: :keep, bind_quoted: [keys: keys] do
type =
{:%{}, [],
[
{:__struct__, {:__MODULE__, [], ruby}},
{:version, {:atom, [], []}}
| Enum.zip(keys, Stream.cycle([{:atom, [], []}]))
]}
# ⇓⇓⇓⇓⇓⇓⇓⇓⇓⇓⇓⇓⇓
@type t :: unquote(type)
defstruct keys
end
end
unquote/1
, bind_quoted:
quote/2
.
!