defmodule Exp do
@moduledoc """
Execute and inline expressions at compile time.
* In a regular code, all you need is `Exp.inline/1`.
* For usage inside of macros when you don't know if arguments are safe,
see `Exp.maybe_inline/1`.
* `Exp.abs/1` is a real-world example of using `Exp.maybe_inline/1`.
* `Exp.pure_func?/3` and `Exp.safe_node?/1` are utility function that
`Exp.maybe_inline/1` uses to make decision if expression is safe to inline.
Source: [github.com/orsinium-labs/exp](https://github.com/orsinium-labs/exp)
"""
@doc """
Macro to statically execute and inline an expression at compile time.
If the expression cannot be inlined, it will explode at compile time.
This is your responsibility to make sure the code can be inlined and is safe to inline.
## What to inline
There are requirements for a good candidate to be inlined:
* It doesn't make network requests.
* It doesn't depend on a service or ecto.
* For the same input, it always produces the same output.
* It's not too slow.
* Its result doesn't take too much memory.
A good example of such function is `Regex.compile!/2`.
## Examples
The usage is straightforward, just wrap whatever you want to inline:
iex> require Exp
iex> Exp.inline(1 + 2)
3
The difference is that the expression inside will be executed at compile time
(when expanding the AST) and included into the compiled code:
iex(21)> q = quote do: 1 + 2
iex(22)> {:+, _, [1, 2]} = Macro.expand(q, __ENV__)
iex(23)> q = quote do: Exp.inline(1 + 2)
iex(24)> 3 = Macro.expand(q, __ENV__)
"""
@spec inline(Macro.t()) :: Macro.t()
defmacro inline(call) do
{term, _} = Code.eval_quoted(call)
Macro.escape(term)
end
# list of pure BIFs
@pure_funcs [
{:is_atom, 1},
{:is_binary, 1},
{:is_bitstring, 1},
{:is_boolean, 1},
{:is_float, 1},
{:is_function, 1},
{:is_function, 2},
{:is_integer, 1},
{:is_list, 1},
{:is_map, 1},
{:is_map_key, 2},
{:is_number, 1},
{:is_pid, 1},
{:is_port, 1},
{:is_reference, 1},
{:is_tuple, 1},
{:<, 2},
{:"=<", 2},
{:>, 2},
{:>=, 2},
{:"/=", 2},
{:"=/=", 2},
{:==, 2},
{:"=:=", 2},
{:*, 2},
{:+, 1},
{:+, 2},
{:-, 1},
{:-, 2},
{:/, 2},
{:abs, 1},
{:ceil, 1},
{:floor, 1},
{:round, 1},
{:trunc, 1},
{:element, 2},
{:hd, 1},
{:length, 1},
{:map_get, 2},
{:map_size, 1},
{:tl, 1},
{:tuple_size, 1},
{:binary_part, 3},
{:bit_size, 1},
{:byte_size, 1},
{:size, 1},
{:div, 2},
{:rem, 2},
{:bnot, 1},
{:band, 2},
{:bor, 2},
{:bxor, 2},
{:bsl, 2},
{:bsr, 2},
{:or, 2},
{:and, 2},
{:xor, 2},
{:not, 1},
{:andalso, 2},
{:orelse, 2}
]
# List of modules that contain only pure functions
@pure_modules [
# basic types
Atom,
Base,
Bitwise,
Float,
Integer,
Kernel,
String,
Tuple,
URI,
Version,
# collections
Access,
Enum,
Keyword,
List,
Map,
MapSet,
Range,
Stream,
# popular third-party
Jason,
Poison
]
@doc """
Check if the function of given name and arity is pure.
## Examples
iex> Exp.pure_func?(:abs, 1)
true
iex> Exp.pure_func?(:abs, 2) # bad arity
false
iex> Exp.pure_func?(:send, 2)
false
"""
@spec pure_func?(atom(), non_neg_integer()) :: boolean()
def pure_func?(name, arity)
Enum.each(@pure_funcs, fn {name, arity} ->
def pure_func?(unquote(name), unquote(arity)), do: true
end)
def pure_func?(_, _), do: false
@doc """
Check if the function of given module, name, and arity is pure.
## Examples
iex> Exp.pure_func?(String, :upcase, 1)
true
iex> Exp.pure_func?(String, :upcase, 4) # bad arity
false
iex> Exp.pure_func?(File, :cwd, 0)
false
iex> Exp.pure_func?(Kernel, :abs, 1)
true
iex> Exp.pure_func?(:erlang, :abs, 1)
true
"""
@spec pure_func?(atom(), atom(), non_neg_integer()) :: boolean()
def pure_func?(module, function, arity)
Enum.each(@pure_modules, fn module ->
def pure_func?(m = unquote(module), f, a),
do: Code.ensure_loaded?(m) and function_exported?(m, f, a)
end)
def pure_func?(:Kernel, name, arity), do: pure_func?(name, arity)
def pure_func?(:erlang, name, arity), do: pure_func?(name, arity)
def pure_func?(_, _, _), do: false
@doc """
Check if the given AST node is safe to be statically executed.
This check is conservative. If it doesn't know anything about the function,
the result is `false`.
It's used be `Exp.maybe_inline/1` to make a decision if the code should be inlined.
## Examples
iex> Exp.safe_node?(quote do: 1)
true
iex> Exp.safe_node?(quote do: "hello")
true
iex> Exp.safe_node?(quote do: 1+2)
true
iex> Exp.safe_node?(quote do: div(2, 3))
true
iex> Exp.safe_node?(quote do: File.cwd())
false
"""
@spec safe_node?(Macro.t()) :: boolean()
def safe_node?(term)
def safe_node?({:__aliases__, _, args}), do: safe_node?(args)
def safe_node?({:%, _, [left, right]}), do: safe_node?(left) and safe_node?(right)
def safe_node?({:%{}, _, args}), do: safe_node?(args)
def safe_node?({:{}, _, args}), do: safe_node?(args)
def safe_node?({left, right}), do: safe_node?(left) and safe_node?(right)
def safe_node?(list) when is_list(list), do: Enum.all?(list, &safe_node?/1)
def safe_node?({{:., _, [{_, _, [mname]}, fname]}, [], list}) when is_list(list),
do: pure_func?(mname, fname, length(list)) and safe_node?(list)
def safe_node?({fname, _, list}) when is_list(list),
do: pure_func?(fname, length(list)) and safe_node?(list)
def safe_node?(term), do: is_atom(term) or is_number(term) or is_binary(term)
defp get_unquote({:unquote, _, [expr]}), do: [expr]
defp get_unquote(_), do: []
@doc """
A safe implementation of `inline/1` for macros.
It inlines the given quoted expression if and only if all `unquote` arguments
are safe to execute at compile time. The safety of the expression itself isn't checked.
The result is also a quoted expression.
It's supposed to be used from macros when you don't know if the macros
will be used for a safe to execute code or not.
## Examples
Here, `var` is safe and so the expression is inlined:
iex> var = quote do: 13
iex> 13 = Exp.maybe_inline(quote do: abs(unquote(var)))
Here, `var` is not safe and so the expression is left as-is:
iex> var = quote do: node()
iex> {:abs, _, _} = Exp.maybe_inline(quote do: abs(unquote(var)))
Here, the expression isn't safe but it's still inlined because `maybe_inline/2`
checks only safety of expressions inside `Kernel.SpecialForms.unquote/1`:
iex> Exp.maybe_inline(quote do: node())
:nonode@nohost
See also `Exp.abs/1` for a real-world usage example.
"""
@spec maybe_inline(Macro.t()) :: Macro.t()
defmacro maybe_inline(block) do
params = Enum.flat_map(Macro.prewalker(block), &get_unquote/1)
quote generated: true do
if Exp.safe_node?(unquote(params)) do
{term, _} = unquote(block) |> Code.eval_quoted()
Macro.escape(term)
else
unquote(block)
end
end
end
@doc """
Inlined version of `Kernel.abs/1`.
Returns the arithmetical absolute value of the `number`.
## Examples
iex> Exp.abs(-2)
2
iex> Exp.abs(2)
2
This is how you can check if it was inlined:
iex> # inlined:
iex> q = quote do: Exp.abs(-2)
iex> 2 = Macro.expand(q, __ENV__)
iex> # not inlined because unsafe:
iex> q = quote do: Exp.abs(node())
iex> {:abs, _, _} = Macro.expand(q, __ENV__)
"""
@spec abs(Macro.t()) :: Macro.t()
defmacro abs(number) do
maybe_inline(quote(do: abs(unquote(number))))
end
@doc false
@spec to_charlist(Macro.t()) :: Macro.t()
defmacro to_charlist(str) do
maybe_inline(quote(do: Kernel.to_charlist(unquote(str))))
end
@doc false
@spec to_string(Macro.t()) :: Macro.t()
defmacro to_string(str) do
maybe_inline(quote(do: Kernel.to_string(unquote(str))))
end
end
