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 check(string :: binary(), bindings :: keyword(), options :: options()) ::
  boolean()

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 combinations(list :: list(), count :: non_neg_integer()) :: [list()]

Generated clauses for n ∈ [1..42] to be used with dynamic number

@spec compile(t() | binary(), options :: options()) :: t()

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 compiled?(binary() | t(), options :: options()) :: boolean()

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 curry(input :: t() | binary(), binding :: keyword(), options :: options()) ::
  t()

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 ensure_compiled(binary() | t(), options :: options()) ::
  {:module, module()}
  | {:error,
     :embedded
     | :badfile
     | :nofile
     | :on_load_failure
     | :unavailable
     | {:already_taken, module()}
     | {:external_module, module()}}

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 eval(input :: binary() | t(), bindings :: keyword(), options :: options()) ::
  term() | {:error, any()}

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.

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 evaluate(
  input :: binary() | tuple(),
  binding :: keyword(),
  options :: options()
) ::
  boolean() | no_return()

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 formulas(include_internals? :: boolean()) :: %{optional(binary()) => module()}

Lists all the compiled formulas.

Returns a normalized representation for the formula given.

@spec permutations(list :: list(), count :: non_neg_integer()) :: [list()]

Generated clauses for n ∈ [1..12] to be used with dynamic number

@spec purge(t() | binary(), options()) ::
  :ok | {:error, :not_compiled} | {:error, :code_delete}

Purges and discards the module for the formula given (if exists.)

Produces the normalized representation of formula. If the rho is an instance of Integer or Float, 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"]}}