defmodule Formulae do
@moduledoc ~S"""
A set of functions to deal with analytical formulae.
The typical way of using this module would be to call `Formulae.compile/1`
on the binary representing the string.
```elixir
iex|1 ▶ f = Formulae.compile "a + :math.sin(3.14 * div(b, 2)) - c"
#ℱ<[
sigil: "~F[a + :math.sin(3.14 * div(b, 2)) - c]",
eval: &:"Elixir.Formulae.a + :math.sin(3.14 * div(b, 2)) - c".eval/1,
formula: "a + :math.sin(3.14 * div(b, 2)) - c",
guard: nil,
module: :"Elixir.Formulae.a + :math.sin(3.14 * div(b, 2)) - c",
variables: [:a, :b, :c],
options: [defaults: [], imports: [:...], evaluator: :function, alias: nil]
]>
```
Now the formula is compiled and might be invoked by calling `Formulae.eval/2`
passing a formula _and_ bindings. First call to `eval/2` would lazily compile
the module if needed.
```elixir
iex|2 ▶ f.eval.(a: 3, b: 4, c: 2)
0.9968146982068622
```
Whether one needs to use external modules in formulas, these modules
must be explicitly imported via `imports: [Mod1, Mod2]`. In case of clash
against `Kernel` functions, the latter might be “unimported” explicitly.
```elixir
iex|3 ▶ Formulae.compile("div(100, 2)", imports: [Decimal], unimports: [div: 2])
Decimal.new("50")
```
The formulae might be curried.
```elixir
iex|4 ▶ Formulae.curry(f, a: 3, b: 4)
#ℱ<[
sigil: "~F[3 + :math.sin(3.14 * div(4, 2)) - c]",
eval: &:"Elixir.Formulae.3 + :math.sin(3.14 * div(4, 2)) - c".eval/1,
formula: "3 + :math.sin(3.14 * div(4, 2)) - c",
guard: nil,
module: :"Elixir.Formulae.3 + :math.sin(3.14 * div(4, 2)) - c",
variables: [:c],
options: [defaults: [], imports: [:...], evaluator: :function, alias: nil]
]>
```
Since `v0.10.0` there is an ability to pass `defaults` via `options`.
_Examples:_
iex> "z + t" |> Formulae.compile(defaults: [t: 5]) |> Formulae.eval(t: 10, z: 3)
13
iex> "z + t" |> Formulae.compile(defaults: [t: 5]) |> Formulae.eval(z: 3)
8
"""
@typedoc false
@type option ::
{:eval, :function | :guard}
| {:alias, module()}
| {:imports, :none | :all | [module()] | [{module(), keyword()}] | [list()]}
| {:defaults, keyword()}
@typedoc false
@type options :: [option()]
@options_schema NimbleOptions.new!(
alias: [
required: false,
default: nil,
doc: "The alias to be used as a generated module name",
type: :atom
],
evaluator: [
required: false,
default: :function,
doc: "The type of the evaluation to generate",
type: {:in, [:function, :guard]}
],
imports: [
required: false,
default: nil,
doc: "The list of modules to allow remote calls from, or `:all | :none`",
type: {:or, [{:in, [nil, :none, :all]}, {:list, :any}, :atom]}
],
unimports: [
required: false,
default: [],
doc:
"The list of functions from `Kernel` module to *not* import automatically",
type: {:or, [{:in, [nil, :none, :all]}, :keyword_list]}
],
defaults: [
required: false,
default: [],
doc:
"The default values to be used with formula when not suppled in binding"
]
)
@typedoc """
The formulae is internally represented as struct, exposing the original
binary representing the formula, AST, the module this formula was compiled
into, variables (bindings) this formula has _and_ the evaluator, which is
the function of arity one, accepting the bindings as a keyword list and
returning the result of this formula application.
"""
@type t :: %{
__struct__: atom(),
formula: binary(),
ast: nil | Macro.t(),
eval: nil | (keyword() -> any()),
guard: nil | Macro.t(),
module: nil | atom(),
variables: nil | [atom()],
options: options()
}
defstruct formula: nil,
ast: nil,
eval: nil,
guard: nil,
module: nil,
variables: nil,
options: NimbleOptions.validate!([], @options_schema)
@doc """
Lists all the compiled formulas.
"""
@spec formulas(include_internals? :: boolean()) :: %{optional(binary) => module()}
def formulas(include_internals? \\ false) do
host_modules = [
Formulae,
Formulae.Combinators,
Formulae.Combinators.H,
Formulae.Combinators.Stream,
Formulae.Compiler,
Formulae.Compiler.AST,
Formulae.MixProject,
Formulae.RunnerError,
Formulae.Sigils,
Formulae.SyntaxError
]
:code.all_loaded()
|> Enum.map(&elem(&1, 0))
|> Enum.filter(&match?("Elixir.Formulae." <> _, to_string(&1)))
|> Kernel.--(host_modules)
|> Map.new(&{&1, Macro.to_string(&1.ast())})
|> then(fn result ->
if include_internals?, do: Map.merge(result, Map.new(host_modules, &{&1, &1})), else: result
end)
end
@doc """
Evaluates the formula returning the result back.
_Examples:_
iex> Formulae.eval("rem(a, 5) + rem(b, 4) == 0", a: 20, b: 20)
true
iex> Formulae.eval("rem(a, 5) == 0", a: 21)
false
iex> Formulae.eval("rem(a, 5) + rem(b, 4)", a: 21, b: 22)
3
iex> Formulae.eval("rem(a, 5) == b", [a: 8], defaults: [b: 3])
true
iex> Formulae.eval("rem(a, 5) == c", [a: 8, c: 3], defaults: [b: 3])
true
iex> Formulae.eval("to_integer(s) == i", [s: "42", i: 42], imports: [String])
true
Binary input is deprecated, create a formula explicitly with `Formulae.compile/2`
and then pass it as the first argument to `eval/2`".
The call to `eval/3` would compile the formulae with default options.
"""
@spec eval(input :: binary() | Formulae.t(), bindings :: keyword(), options :: options()) ::
term() | {:error, any()}
def eval(input, bindings \\ [], options \\ [imports: :none])
def eval(%Formulae{eval: eval, options: options} = formula, bindings, _options) do
options[:defaults] |> Keyword.merge(bindings) |> eval.()
rescue
UndefinedFunctionError ->
eval(formula.formula, bindings, formula.options)
end
def eval(input, bindings, options) when is_binary(input) do
input |> Formulae.compile(options) |> eval(bindings, options)
end
@doc """
Evaluates the formula returning the result back; throws in a case of unseccessful processing.
_Examples:_
iex> Formulae.eval!("rem(a, 5) == 0", a: 20)
true
iex> Formulae.eval!("rem(a, 5) == 0")
** (Formulae.RunnerError) Formula ~F[rem(a, 5) == 0] failed to run (compile): [:missing_arguments], wrong or incomplete evaluator call: [given_keys: [], expected_keys: [:a]].
"""
@spec eval!(input :: binary() | Formulae.t(), bindings :: keyword()) :: term() | no_return()
def eval!(input, bindings \\ [], options \\ []) do
with {:error, {error, data}} <- Formulae.eval(input, bindings, options) do
raise(
Formulae.RunnerError,
formula: input,
error:
{:compile, "[#{inspect(error)}], wrong or incomplete evaluator call: #{inspect(data)}"}
)
end
end
@spec dry_ast(binary() | {:ok, Macro.t()} | {:error, tuple()} | Macro.t()) ::
{:ok, Macro.t()} | {:error, tuple()}
defp dry_ast(input) when is_binary(input), do: input |> Code.string_to_quoted() |> dry_ast()
defp dry_ast({:error, _} = error), do: error
defp dry_ast({:ok, input}) when is_tuple(input) do
result =
Macro.prewalk(input, fn
{arg, [_ | _], content} -> {arg, [], content}
other -> other
end)
{:ok, result}
end
defp dry_ast(input) when is_tuple(input), do: dry_ast({:ok, input})
@doc """
Checks whether the formula was already compiled into module.
Typically one does not need to call this function, since this check would be
nevertheless transparently performed before the evaluation.
_Examples:_
iex> Formulae.compiled?("foo > 42")
false
iex> Formulae.compile("foo > 42")
iex> Formulae.compiled?("foo > 42")
true
"""
@spec compiled?(binary() | Formulae.t(), options :: options()) :: boolean()
def compiled?(input, options \\ [])
def compiled?(input, options) when is_binary(input) and is_list(options) do
module = module_name(input, options)
sanitized = Map.get(formulas(true), module)
is_binary(sanitized) and
match?([{:ok, quoted}, {:ok, quoted}], Enum.map([sanitized, input], &dry_ast/1)) and
Code.ensure_loaded?(module)
end
def compiled?(%Formulae{module: nil}, _), do: false
def compiled?(%Formulae{module: _}, _), do: true
@doc """
Checks whether the formula was already compiled into module.
Similar to `compiled?/1`, but returns what `Code.ensure_compiled/1` returns.
Typically one does not need to call this function, since this check would be
nevertheless transparently performed before the evaluation.
_Examples:_
iex> Formulae.ensure_compiled("bar > 42")
{:error, :nofile}
iex> Formulae.compile("bar > 42")
iex> Formulae.ensure_compiled("bar > 42")
{:module, :"Elixir.Formulae.bar > 42"}
"""
@spec ensure_compiled(binary() | Formulae.t(), options :: options()) ::
{:module, module()}
| {:error,
:embedded
| :badfile
| :nofile
| :on_load_failure
| :unavailable
| {:already_taken, module()}
| {:external_module, module()}}
def ensure_compiled(input, options \\ [])
def ensure_compiled(input, options) when is_binary(input) and is_list(options) do
module = module_name(input, options)
cond do
function_exported?(module, :ast, 0) ->
if {:ok, module.ast()} == Code.string_to_quoted(input),
do: {:module, module},
else: {:error, {:already_taken, module}}
Code.ensure_loaded?(module) ->
{:error, {:external_module, module}}
true ->
{:error, :nofile}
end
end
def ensure_compiled(%Formulae{module: nil}, _), do: {:error, :unavailable}
def ensure_compiled(%Formulae{module: module}, _), do: {:module, module}
@doc """
Compiles the formula into module.
The allowed imports must be specified explicitly with `imports: :all` or
a list of allowed imports `imports: [DateTime, Range]`.
_Examples:_
iex> f = Formulae.compile("rem(a, 5) - b == 0")
iex> f.formula
"rem(a, 5) - b == 0"
iex> f.variables
[:a, :b]
iex> f.module
:"Elixir.Formulae.rem(a, 5) - b == 0"
iex> f.module.eval(a: 12, b: 2)
true
iex> f = Formulae.compile("rem(a, 5) + b == a")
iex> f.variables
[:a, :b]
iex> f.eval.(a: 7, b: 5)
true
iex> f.eval.(a: 7, b: 0)
false
"""
@spec compile(Formulae.t() | binary(), options :: options()) :: Formulae.t()
def compile(input, options \\ [])
def compile(input, options) when is_binary(input) and is_list(options) do
input
|> ensure_compiled(options)
|> maybe_create_module(input, options)
end
def compile(%Formulae{formula: input}, options), do: compile(input, options)
@doc """
Purges and discards the module for the formula given (if exists.)
"""
@spec purge(Formulae.t() | binary(), options()) ::
:ok | {:error, :not_compiled} | {:error, :code_delete}
def purge(input, options \\ [])
def purge(input, options) when is_binary(input) and is_list(options),
do: input |> module_name(options) |> do_purge()
def purge(%Formulae{module: nil}, _), do: {:error, :not_compiled}
def purge(%Formulae{module: mod}, _), do: do_purge(mod)
@spec do_purge(atom()) :: :ok | {:error, :not_compiled} | {:error, :code_delete}
defp do_purge(mod) do
:code.purge(mod)
if :code.delete(mod), do: :ok, else: {:error, :code_delete}
end
@doc ~S"""
Curries the formula by substituting the known bindings into it.
## Example
iex> Formulae.curry("(temp - foo * 4) > speed / 3.14", temp: 7, speed: 3.14).formula
"7 - foo * 4 > 3.14 / 3.14"
"""
@spec curry(input :: Formulae.t() | binary(), binding :: keyword(), options :: options()) ::
Formulae.t()
def curry(input, binding \\ [], options \\ [])
def curry(input, binding, options) when is_binary(input) do
curry(Formulae.compile(input, options), binding, options)
end
def curry(%Formulae{} = input, binding, options) do
{ast, vars} = ast_and_variables(input, binding, options)
%Formulae{variables: ^vars} = Formulae.compile(Macro.to_string(ast), options)
end
@spec maybe_create_module(
{:module, atom()} | {:error, any()},
input :: binary(),
options :: options()
) ::
Formulae.t()
defp maybe_create_module({:module, module}, input, options) do
with {:error, ex} <- validate_compatibility(module, options), do: raise(ex)
unless {:ok, module.ast()} == Code.string_to_quoted(input) do
raise Formulae.RunnerError,
formula: input,
error: {:incompatible, "Existing: " <> inspect(Macro.to_string(module.ast()))}
end
%Formulae{
formula: input,
module: module,
ast: module.ast(),
guard: module.guard_ast(),
variables: module.variables(),
options: module.options(),
eval: &module.eval/1
}
end
defp maybe_create_module({:error, {:already_taken, module}}, input, options) do
IO.warn(
"Redefining Formulae for alias " <>
inspect(options[:alias]) <>
", formula: ~F[#{Macro.to_string(module.ast())}] → ~F[#{input}] (module: " <>
inspect(module) <> ")",
[]
)
maybe_create_module({:error, :redefining}, input, options)
end
defp maybe_create_module({:error, {:external_module, module}}, input, options) do
IO.warn(
"Alias given for Formulae (" <>
inspect(options[:alias]) <>
") will overwrite existing module " <>
inspect(module),
[]
)
maybe_create_module({:error, :redefining}, input, options)
end
# credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity
defp maybe_create_module({:error, _}, input, options) do
options =
options
|> NimbleOptions.validate!(@options_schema)
|> Keyword.update(:imports, [], &fix_imports/1)
imports =
case Keyword.fetch!(options, :imports) do
[] ->
nil
[:...] ->
nil
imports ->
Enum.map(imports, fn
[mod, {_, _} = arg] -> quote do: import(unquote(mod), unquote([arg]))
{mod, [{_, _} | _] = args} -> quote do: import(unquote(mod), unquote(args))
mod -> quote do: import(unquote_splicing(List.wrap(mod)))
end)
end
unimports =
case Keyword.fetch!(options, :unimports) do
nil -> []
:none -> []
:all -> Kernel.__info__(:functions)
list when is_list(list) -> list
end
unimports =
Enum.uniq(
unimports ++
[
apply: 3,
exit: 1,
raise: 1,
raise: 2,
reraise: 2,
reraise: 3,
spawn: 3,
spawn_link: 3,
spawn_monitor: 3,
throw: 1
]
)
{macro, variables} = reduce_ast!(input, options)
escaped = Macro.escape(macro)
variables = variables |> Enum.reverse() |> Enum.uniq()
guard = do_guard(options[:evaluator], variables, macro, input)
guard_ast = Macro.escape(guard)
eval = do_eval(options[:evaluator], variables, macro)
ast = [
guard,
quote generated: true do
@variables unquote(variables)
import Kernel, except: unquote(unimports)
unquote(imports)
def ast, do: unquote(escaped)
def guard_ast, do: unquote(guard_ast)
def options, do: unquote(options)
def variables, do: @variables
end,
eval
]
{:module, module, _, _} = input |> module_name(options) |> Module.create(ast, __ENV__)
%Formulae{
formula: input,
ast: macro,
module: module,
guard: guard,
variables: variables,
options: options,
eval: &module.eval/1
}
end
##############################################################################
@doc deprecated: "Use `Formulae.eval/2` instead"
@doc ~S"""
Revalidates the formula with bindings given. Returns true if the formula
strictly evaluates to `true`, `false` otherwise. Compiles the formula
before evaluation if needed.
"""
@spec check(string :: binary(), bindings :: keyword(), options :: options()) :: boolean()
def check(string, bindings \\ [], options \\ []) do
Formulae.eval(string, bindings, options)
rescue
Formulae.RunnerError -> false
end
@doc deprecated: "Use `Formulae.compile/1` and `%Formulae{}.variables` instead"
@doc ~S"""
Returns a normalized representation for the formula given.
"""
def normalize(input) when is_binary(input) do
with {normalized, {operation, _env, [formula, value]}} <- unit(input),
bindings <- bindings?(formula) do
{normalized, {operation, formula, value}, bindings}
else
_ -> raise(Formulae.SyntaxError, formula: input, error: {:unknown, inspect(input)})
end
end
@spec ast_and_variables(
input :: binary() | Formulae.t(),
binding :: keyword(),
options :: options()
) ::
{tuple(), keyword()}
defp ast_and_variables(input, binding, options) when is_binary(input) do
input
|> Formulae.compile(Keyword.delete(options, :alias))
|> ast_and_variables(binding, options)
end
defp ast_and_variables(
%Formulae{ast: nil, formula: input, options: options},
binding,
new_options
) do
options = Keyword.merge(new_options, options)
# [AM] FIX
ast_and_variables(input, binding, options)
end
defp ast_and_variables(%Formulae{ast: ast}, binding, _options) do
{ast, vars} =
Macro.prewalk(ast, [], fn
{var, _, nil} = v, acc when is_atom(var) ->
if Keyword.has_key?(binding, var),
do: {Keyword.fetch!(binding, var), acc},
else: {v, [var | acc]}
v, acc ->
{v, acc}
end)
{ast, vars |> Enum.reverse() |> Enum.uniq()}
end
@doc deprecated:
"Use `Formulae.compile/1` and `%Formulae{}.variables` or `Formula.curry/2` instead"
@doc ~S"""
Returns the binding this formula requires.
## Examples
iex> "a > 5" |> Formulae.bindings?()
~w|a|a
iex> ":math.sin(a / (3.14 * b)) > c" |> Formulae.bindings?([], imports: [:math])
~w|a b c|a
iex> "a + b * 4 - :math.pow(c, 2) / d > 1.0 * e" |> Formulae.bindings?([], imports: :math)
~w|a b c d e|a
"""
@spec bindings?(formula :: Formulae.t() | binary() | tuple(), binding :: keyword()) :: keyword()
def bindings?(formula, bindings \\ [], options \\ [imports: :none])
def bindings?(%Formulae{variables: variables}, [], _options),
do: variables
def bindings?(formula, bindings, options) when is_binary(formula),
do: with(f <- Formulae.curry(formula, bindings, options), do: f.variables)
def bindings?(formula, bindings, options) when is_tuple(formula),
do: bindings?(Macro.to_string(formula), bindings, options)
def bindings?(%Formulae{formula: formula}, bindings, options),
do: bindings?(formula, bindings, options)
##############################################################################
# @comparison [:<, :>, :=] # Damn it, José! :≠
# @booleans [:&, :|]
##############################################################################
@deprecated "Use `Formulae.eval/2` instead"
@doc ~S"""
Produces the normalized representation of formula. If the _rho_ is
an instance of [`Integer`](http://elixir-lang.org/docs/stable/elixir/Integer.html#content)
or [`Float`](http://elixir-lang.org/docs/stable/elixir/Float.html#content),
it’s left intact, otherwise it’s moved to the left side with negation.
## Examples
iex > Formulae.unit("3 > 2")
{"3 > 2", {:>, [], [3, 2]}}
iex > Formulae.unit("3 - a > 2")
{"3 - a > 2", {:>, [], [{:-, [line: 1], [3, {:a, [line: 1], nil}]}, 2]}}
iex > Formulae.unit("3 > A + 2")
{"3 > a + 2",
{:>, [],
[{:-, [context: Formulae, import: Kernel],
[3, {:+, [line: 1], [{:a, [line: 1], nil}, 2]}]}, 0]}}
iex > Formulae.unit("3 >= a + 2")
{"3 >= a + 2",
{:>=, [],
[{:-, [context: Formulae, import: Kernel],
[3, {:+, [line: 1], [{:a, [line: 1], nil}, 2]}]}, 0]}}
iex > Formulae.unit("3 a > A + 2")
** (Formulae.SyntaxError) Formula [3 a > A + 2] syntax is incorrect (parsing): syntax error before: “a”.
iex > Formulae.unit("a + 2 = 3")
{"a + 2 = 3", {:==, [], [{:+, [line: 1], [{:a, [line: 1], nil}, 2]}, 3]}}
iex > Formulae.unit(~S|A = "3"|)
{"a = \"3\"", {:==, [], [{:a, [line: 1], nil}, "3"]}}
"""
# credo:disable-for-lines:50
def unit(input, env \\ []) when is_binary(input) do
normalized = String.downcase(input)
{
normalized,
case Code.string_to_quoted(normalized) do
{:ok, {:>, _, [lh, rh]}} when is_integer(rh) or is_float(rh) ->
{:>, env, [lh, rh]}
{:ok, {:>, _, [lh, rh]}} ->
{:>, env, [quote(do: unquote(lh) - unquote(rh)), 0]}
{:ok, {:>=, _, [lh, rh]}} when is_integer(rh) or is_float(rh) ->
{:>=, env, [lh, rh]}
{:ok, {:>=, _, [lh, rh]}} ->
{:>=, env, [quote(do: unquote(lh) - unquote(rh)), 0]}
{:ok, {:<, _, [lh, rh]}} when is_integer(rh) or is_float(rh) ->
{:<, env, [lh, rh]}
{:ok, {:<, _, [lh, rh]}} ->
{:<, env, [quote(do: unquote(lh) - unquote(rh)), 0]}
{:ok, {:<=, _, [lh, rh]}} when is_integer(rh) or is_float(rh) ->
{:<=, env, [lh, rh]}
{:ok, {:<=, _, [lh, rh]}} ->
{:<=, env, [quote(do: unquote(lh) - unquote(rh)), 0]}
{:ok, {:=, _, [lh, rh]}} ->
{:==, env, [lh, rh]}
{:ok, {:==, _, [lh, rh]}} ->
{:==, env, [lh, rh]}
{:ok, {op, _, _}} ->
raise(Formulae.SyntaxError, formula: input, error: {:operation, double_quote(op)})
{:error, {_, message, op}} ->
raise(
Formulae.SyntaxError,
formula: input,
error: {:parsing, message <> double_quote(op)}
)
other ->
raise(Formulae.SyntaxError, formula: input, error: {:unknown, inspect(other)})
end
}
end
@deprecated "Use `Formulae.eval/2` instead"
@doc ~S"""
Evaluates normalized representation of formula.
## Examples
iex> Formulae.eval("3 > 2")
true
iex> Formulae.eval("3 < 2")
false
iex> Formulae.eval("a < 2", a: 1)
true
iex> Formulae.eval("a > 2", a: 1)
false
iex> Formulae.eval("a < 2", [])
{:error, {:missing_arguments, [given_keys: [], expected_keys: [:a]]}}
iex> Formulae.eval!("a < 2", [])
** (Formulae.RunnerError) Formula ~F[a < 2] failed to run (compile): [:missing_arguments], wrong or incomplete evaluator call: [given_keys: [], expected_keys: [:a]].
iex> Formulae.eval("a + 2 == 3", a: 1)
true
iex> Formulae.eval("a + 2 == 3", a: 2)
false
iex> Formulae.eval(~S|a == "3"|, a: "3")
true
iex> Formulae.eval(~S|a == "3"|, a: 3)
false
iex> Formulae.eval(~S|a == "3"|, a: "hello")
false
iex> Formulae.eval("a + 2 == 3", a: 2)
false
iex> Formulae.eval(~S|a == "3"|, a: "3")
true
iex> Formulae.eval("a_b_c_490000 > 2", a_b_c_490000: 3)
true
"""
@spec evaluate(input :: binary() | tuple(), binding :: keyword(), options :: options()) ::
boolean() | no_return()
def evaluate(input, binding \\ [], options \\ [])
def evaluate({_original, ast}, binding, options),
do: evaluate(ast, binding, options)
def evaluate(input, binding, options) when is_binary(input),
do: evaluate(unit(input), binding, options)
def evaluate(input, binding, options) when is_tuple(input) do
unresolved = bindings?(input, binding)
if Enum.empty?(unresolved) do
do_evaluate(input, binding, options)
else
raise(
Formulae.RunnerError,
formula: input,
error:
{:compile, "incomplete binding to evaluate a formula, lacking: #{inspect(unresolved)}"}
)
end
end
defp do_evaluate(input, binding, options) when is_tuple(input) do
binding = Enum.reject(binding, fn {_, v} -> is_nil(v) end)
try do
case Code.eval_quoted(input, binding, options) do
{false, ^binding} -> false
{true, ^binding} -> true
other -> raise(Formulae.RunnerError, formula: input, error: {:weird, inspect(other)})
end
rescue
e in CompileError ->
reraise(
Formulae.RunnerError,
[formula: input, error: {:compile, e.description}],
__STACKTRACE__
)
end
end
##############################################################################
:formulae
|> Application.compile_env(:generate_combinators, true)
|> if do
@max_combinations Application.compile_env(:formulae, :max_combinations, 42)
@max_permutations Application.compile_env(:formulae, :max_permutations, 12)
require Formulae.Combinators
@spec combinations(list :: list(), count :: non_neg_integer()) :: [list()]
@doc "Generated clauses for `n ∈ [1..#{@max_combinations}]` to be used with dynamic number"
Enum.each(1..@max_combinations, fn n ->
def combinations(l, unquote(n)), do: Formulae.Combinators.combinations(l, unquote(n))
end)
def combinations(_l, n),
do: raise(Formulae.RunnerError, formula: :combinations, error: {:too_high, inspect(n)})
@spec permutations(list :: list(), count :: non_neg_integer()) :: [list()]
@doc "Generated clauses for `n ∈ [1..#{@max_permutations}]` to be used with dynamic number"
Enum.each(1..@max_permutations, fn n ->
def permutations(l, unquote(n)), do: Formulae.Combinators.permutations(l, unquote(n))
end)
def permutations(_l, n),
do: raise(Formulae.RunnerError, formula: :permutations, error: {:too_high, inspect(n)})
end
##############################################################################
defp double_quote(string) when is_binary(string), do: "“" <> string <> "”"
defp double_quote(string), do: double_quote(to_string(string))
defp module_name(input, options) when is_binary(input) and is_list(options) do
safe_name =
case input do
<<_::binary-size(240), _::binary>> ->
"SHA_" <> (:sha256 |> :crypto.hash(input) |> Base.encode16())
_ ->
String.replace(input, <<?/>>, "÷")
end
Keyword.get(options, :alias) || Module.concat(Formulae, safe_name)
end
defp do_guard(:guard, variables, macro, _input) do
vars = Enum.map(variables, &Macro.var(&1, nil))
quote generated: true do
# @doc guard: true
defguard guard(unquote_splicing(vars)) when unquote(macro)
end
end
defp do_guard(:function, _variables, _macro, _input), do: nil
Enum.each(1..5, fn len ->
defp do_eval(:guard, variables, _macro) when length(variables) == unquote(len) do
vars = Enum.map(variables, &Macro.var(&1, nil))
varsnames = variables |> Enum.zip(vars)
require Formulae.Combinators
varsnames
|> Formulae.Combinators.permutations(unquote(len))
|> Enum.map(fn varsnames ->
quote generated: true do
def eval(unquote(varsnames)) when guard(unquote_splicing(vars)), do: true
end
end)
|> Kernel.++([
quote generated: true do
def eval(_), do: false
end
])
end
end)
defp do_eval(:guard, variables, macro), do: do_eval(:function, variables, macro)
defp do_eval(:function, variables, macro) do
vars = Enum.map(variables, &Macro.var(&1, nil))
varsnames = Enum.zip(variables, vars)
quote generated: true do
def eval(unquote(varsnames)), do: unquote(macro)
def eval(%{} = args) do
bindings = for k <- @variables, v = Map.get(args, k), not is_nil(v), do: {k, v}
if length(bindings) == length(@variables),
do: eval(bindings),
else:
{:error,
{:missing_arguments, [given_keys: Keyword.keys(bindings), expected_keys: @variables]}}
end
def eval(args) do
if Keyword.keyword?(args),
do: args |> Map.new() |> eval(),
else: {:error, {:invalid_argument, [given: args, expected_keys: @variables]}}
end
end
end
defp fix_imports(imports) do
case imports do
nil -> fix_imports_warn()
:none -> []
:all -> [:...]
alias when is_atom(alias) -> [alias]
aliases when is_list(aliases) -> aliases
end
end
# [AM] Remove this when we disallow default value for it
defp fix_imports_warn do
IO.warn(
"Default value for `imports: :all` argument in a call to `Formulae.compile/2` is deprecated, " <>
"and will be changed to `:none` in v1.0.0",
[]
)
[:...]
end
defp validate_compatibility(module, options) do
with {:ok, validated} <- NimbleOptions.validate(options, @options_schema),
{:imports, true} <-
{:imports, validate_imports(module.options()[:imports], validated[:imports])},
{:alias, true} <- {:alias, module == Keyword.get(validated, :alias, module)},
{:defaults, true} <-
{:defaults, Keyword.equal?(module.options()[:defaults], validated[:defaults])},
{:evaluator, true} <- {:evaluator, validate_evaluator(validated[:evaluator], module)} do
{:ok, validated}
end
end
defp validate_imports(:..., _), do: true
defp validate_imports(imports, :...),
do:
{:error,
%Formulae.RunnerError{
error: :imports,
message: "Existing module has imports restricted to " <> inspect(imports)
}}
defp validate_imports(from_module, from_options) do
[from_module, from_options]
|> Enum.map(&fix_imports/1)
|> Enum.reduce(&Kernel.--/2)
|> Enum.empty?()
|> Kernel.||(
{:error,
%Formulae.RunnerError{
error: :imports,
message:
"Incompatible imports: " <> inspect(existing: from_module, supplied: from_options)
}}
)
end
defp validate_evaluator(:guard, module), do: is_nil(module.guard_ast())
defp validate_evaluator(:function, module), do: not is_nil(module.guard_ast())
# [AM] maybe warn
defp validate_evaluator(_, module), do: not is_nil(module.guard_ast())
if Version.match?(System.version(), ">= 1.17.0-dev") do
defp expand_or_concat(alias) do
{:__aliases__, meta, [_ | _] = list} = alias
:elixir_aliases.expand_or_concat(meta, list, __ENV__, nil)
end
else
defp expand_or_concat(alias) do
:elixir_aliases.expand_or_concat(alias, __ENV__)
end
end
defp reduce_ast!(input, options) do
macro = Code.string_to_quoted!(input)
imports = Keyword.fetch!(options, :imports)
{^macro, {^imports, issues, variables}} =
Macro.postwalk(macro, {imports, [], []}, fn
{var, _, nil} = v, {imports, issues, acc} ->
{v, {imports, issues, [var | acc]}}
v, {[:...], _, _} = acc ->
{v, acc}
{:__aliases__, _, [_ | _]} = alias, {imports, issues, acc} ->
wanna_import = expand_or_concat(alias)
do_wanna_import(:alias, wanna_import, alias, {imports, issues, acc})
{:., _, [{:__aliases__, _, [_ | _]} = alias, _fun]} = call, {imports, issues, acc} ->
wanna_import = expand_or_concat(alias)
do_wanna_import(:alias, wanna_import, call, {imports, issues, acc})
{:., _, [wanna_import, _fun]} = call, {imports, issues, acc} ->
do_wanna_import(:erlang, wanna_import, call, {imports, issues, acc})
{:import, _, wanna_import} = alias, {imports, issues, acc} ->
do_wanna_import(:import, wanna_import, alias, {imports, issues, acc})
v, acc ->
{v, acc}
end)
unless Enum.empty?(issues) do
raise %Formulae.SyntaxError{
formula: input,
error: "Restricted: " <> inspect(Enum.uniq(issues))
}
end
{macro, variables}
end
defp do_wanna_import(kind, wanna_import, alias, {imports, issues, acc}) do
if wanna_import in imports do
{alias, {imports, issues, acc}}
else
if Version.match?(System.version(), ">= 1.14.1") do
{alias, {imports, [{kind, Macro.expand_literals(wanna_import, __ENV__)} | issues], acc}}
else
{alias, {imports, [{kind, wanna_import} | issues], acc}}
end
end
end
defimpl String.Chars do
@moduledoc false
def to_string(%Formulae{formula: formula}) do
"~F[" <> formula <> "]"
end
end
defimpl Inspect do
@moduledoc false
import Inspect.Algebra
def inspect(%Formulae{} = f, opts) do
if Keyword.get(opts.custom_options, :sigil, false) do
"~F[" <> f.formula <> "]"
else
inner = [
sigil: "~F[" <> Macro.to_string(f.ast) <> "]",
eval: f.eval,
formula: f.formula,
guard: if(f.guard, do: Macro.to_string(f.guard)),
module: f.module,
variables: f.variables,
options: f.options
]
concat(["#ℱ<", to_doc(inner, opts), ">"])
end
end
end
end
