Nested blocks with direct AST manipulation

I would just leave the block’s in, I do that anyway and have not noticed anything odd in the final code generation that could affect speed.

/me uses lots and lots of __block__'s in their macro’s, mostly to add line and typing information to constants like integers and such that have malformed non 3-tuple AST nodes

Your example is just this code anyway.

(
  x = 1

  (
    x = 2
    x
  )
)

You’re right… Didn’t think of it. Unless someone else knows about any real problem with nested blocks I’ll mark your answer as a solution.

EDIT: which can be written even more concisely like this:

(x=1; (x=2; x))

I literally took your AST and parsed and formatted it:

iex(2)> q = {:__block__, [], [
...(2)>       quote(do: x = 1),
...(2)>       {:__block__, [], [
...(2)>         quote(do: x = 2),
...(2)>         quote(do: x)
...(2)>       ]}
...(2)>     ]}
{
  :__block__,
  [],
  [
    {:=, [], [{:x, [], Elixir}, 1]},
    {:__block__, [], [{:=, [], [{:x, [], Elixir}, 2]}, {:x, [], Elixir}]}
  ]
}
iex(3)> q |> Macro.prewalk(&Macro.expand(&1, __ENV__)) |> Macro.to_string() |> Code.format_string!() |> IO.puts()
x = 1

(
  x = 2
  x
)
:ok

^.^

The formatter breaks it up. ^.^

wow! thats cool. Thanks for sharing.I found a lot of interesting information here. A really good post, very thankful and hopeful that you will write many more posts like this one.
with regards
miles smith