Boost PHP Performance with CEL-PHP: A Fast, Safe Expression Engine

Overview

Common Expression Language (CEL) is a simple, safe, non‑Turing‑complete expression language designed for embedding in high‑performance applications. It avoids loops, supports operator precedence, and is suited for API authorization, data validation, and configuration‑driven logic.

CEL‑PHP

CEL‑PHP is a PHP 8+ implementation that provides a fast, portable evaluator. The library passes more than 1,000 compliance tests and can evaluate complex expressions in sub‑millisecond time.

Installation

Install the package with Composer: composer require carthage-software/cel-php Include the Composer autoloader in your script:

require_once 'vendor/autoload.php';

Basic Evaluation

Create a Cel instance and evaluate an expression:

<?php
use CarthageSoftware\CelPhp\Cel;

$cel = new Cel();
$result = $cel->evaluate('1 + 2 * 3');
echo $result->toNativeValue(); // 7

new Cel()

– constructs the evaluator. evaluate($expr) – parses and evaluates the expression, returning a Receipt object. toNativeValue() – converts the CEL value to a native PHP type.

Evaluation with Context

Pass an associative array as context to reference variables inside the expression:

<?php
$context = [
    'user' => [
        'age'  => 25,
        'name' => 'Alice',
    ],
];
$cel = new Cel();
$result = $cel->evaluate('user.age >= 18 ? "adult" : "minor"', $context);
echo $result->toNativeValue(); // adult

Parsing, Optimizing, and Error Handling

For production workloads you can separate parsing, optimization, and evaluation, which enables AST caching and more precise error reporting:

<?php
use CarthageSoftware\CelPhp\Cel;
use CarthageSoftware\CelPhp\Exception\ParserException;
use CarthageSoftware\CelPhp\Exception\EvaluationException;

$expression = 'user.balance > 1000 && has(user.vip)';
$context = ['user' => ['balance' => 1500, 'vip' => true]];
$cel = new Cel();

try {
    $ast = $cel->parse($expression);          // produce AST
    $ast = $cel->optimize($ast);            // constant folding, short‑circuiting
    $receipt = $cel->evaluate($ast, $context);
    if ($receipt->result->toNativeValue()) {
        echo "VIP service unlocked!";
    }
} catch (ParserException $e) {
    echo "Parse error: " . $e->getMessage() . " (position: " . $e->getPosition() . ")";
} catch (EvaluationException $e) {
    echo "Evaluation error: " . $e->getMessage();
}

parse()

– returns an abstract syntax tree (AST) that can be cached. optimize() – performs constant folding and short‑circuit evaluation. ParserException and EvaluationException provide detailed diagnostics. has() – built‑in macro that checks field existence.

Performance Optimizations – Caching and Extensions

Integrate a PSR‑16 cache (e.g., Symfony’s FilesystemAdapter) to store parsed ASTs and avoid repeated parsing:

<?php
use Symfony\Component\Cache\Adapter\FilesystemAdapter;
use CarthageSoftware\CelPhp\Cache\Psr16Cache;
use CarthageSoftware\CelPhp\Cel;

$cacheAdapter = new FilesystemAdapter(); // or ApcuAdapter, etc.
$cache = new Psr16Cache($cacheAdapter);
$cel = Cel::withCache($cache); // evaluator that uses the cache

Register custom functions to extend CEL with application‑specific logic:

<?php
use CarthageSoftware\CelPhp\Cel;
use CarthageSoftware\CelPhp\Value\CelFunction;

$cel = new Cel();
$cel->registerFunction('myCustomFn', new CelFunction(function($args) {
    return count($args);
}));

$result = $cel->evaluate('myCustomFn([1, 2, 3])');
echo $result->toNativeValue(); // 3

Best Practices

Type safety : Ensure PHP arrays match CEL list/map expectations; verify results with toNativeValue().

Performance : Pre‑parse complex expressions into ASTs and keep the evaluation context shallow.

Debugging : Enable tracing with $cel->setDebug(true) to see evaluation steps.

Testing : Run the library’s test suite via vendor/bin/phpunit to confirm correct integration.

Repository

For full documentation, source code, and release information, see the official repository: https://github.com/carthage-software/cel-php