A pure Elixir implementation of Google's Common Expression Language (CEL).

CEL is a non-Turing-complete expression language designed for simplicity, speed, and safety. It is commonly used in security policies, protocol buffers, and configuration validation.

Quick Start

iex> Celixir.eval("1 + 2")
{:ok, 3}

iex> Celixir.eval("name.startsWith('hello')", %{name: "hello world"})
{:ok, true}

iex> Celixir.eval("x > 10 ? 'big' : 'small'", %{x: 42})
{:ok, "big"}

Compile Once, Evaluate Many

{:ok, program} = Celixir.compile("x * 2 + y")

Celixir.Program.eval(program, %{x: 5, y: 1})   # => {:ok, 11}
Celixir.Program.eval(program, %{x: 10, y: 3})   # => {:ok, 23}

Create Reusable Functions

validator = Celixir.to_fun!("age >= 18 && status == 'active'")

validator.(%{age: 25, status: "active"})   # => {:ok, true}
validator.(%{age: 15, status: "active"})   # => {:ok, false}

Supported Features

• Types: int, uint, double, bool, string, bytes, list, map, null, timestamp, duration, optional, type
• Operators: arithmetic (+, -, *, /, %), comparison (==, !=, <, <=, >, >=), logical (&&, ||, !), ternary (?:), membership (in)
• String functions: contains, startsWith, endsWith, matches, size, charAt, indexOf, lastIndexOf, lowerAscii, upperAscii, replace, split, substring, trim, join, reverse
• Math functions: math.least, math.greatest, math.ceil, math.floor, math.round, math.abs, math.sign, math.isNaN, math.isInf, math.isFinite
• List functions: size, sort, slice, flatten, reverse, lists.range
• Set functions: sets.contains, sets.intersects, sets.equivalent
• Comprehension macros: all, exists, exists_one, filter, map
• Type conversions: int(), uint(), double(), string(), bool(), bytes(), timestamp(), duration(), dyn(), type()
• Optional values: optional.of(), optional.none(), optional.ofNonZeroValue(), .hasValue(), .value(), .orValue(), .or()
• Encoding: base64.encode(), base64.decode()
• Custom functions: register your own via Celixir.Environment.put_function/3 or declaratively with Celixir.API and defcel
• Reusable functions: to_fun/1 compiles to a plain anonymous function
• File loading: load_file/1 loads expressions from files
• Value encoding: encode/1 converts Elixir values to CEL internal types
• Protobuf integration: field access, has() checks, well-known type conversion via Celixir.ProtobufAdapter
• Static type checking: optional pre-evaluation validation via Celixir.Checker
• Compile-time sigil: ~CEL|expr| for zero-cost parsed ASTs

Custom Functions

Register Elixir functions to call from CEL expressions. Functions receive plain Elixir values and should return plain Elixir values.

# Simple function
env = Celixir.Environment.new(%{name: "world"})
      |> Celixir.Environment.put_function("greet", fn name -> "Hello, #{name}!" end)

Celixir.eval("greet(name)", env)
# => {:ok, "Hello, world!"}

# Multi-argument
env = Celixir.Environment.new()
      |> Celixir.Environment.put_function("clamp", fn val, lo, hi ->
        val |> max(lo) |> min(hi)
      end)

Celixir.eval("clamp(150, 0, 100)", env)
# => {:ok, 100}

# Module function reference
env = Celixir.Environment.new()
      |> Celixir.Environment.put_function("factorial", &MyMath.factorial/1)

# Namespaced functions (dot-separated names)
env = Celixir.Environment.new()
      |> Celixir.Environment.put_function("str.reverse", &MyString.reverse/1)
      |> Celixir.Environment.put_function("str.repeat", &MyString.repeat/2)

To build a reusable function library, group registrations in a module:

defmodule MyApp.CelLibrary do
  def register(env \\ Celixir.Environment.new()) do
    env
    |> Celixir.Environment.put_function("slugify", &slugify/1)
    |> Celixir.Environment.put_function("format.currency", &format_currency/2)
  end

  defp slugify(s), do: s |> String.downcase() |> String.replace(~r/[^a-z0-9]+/, "-")
  defp format_currency(amount, cur), do: "#{cur} #{:erlang.float_to_binary(amount / 1.0, decimals: 2)}"
end