google/cel-go
Cel Go
cel-go is a Go implementation of the Common Expression Language, providing a type-safe engine for the evaluation of non-Turing complete, side-effect-free expressions. It functions as an embedded expression engine that converts human-readable strings into type-checked abstract syntax trees to ensure safe execution.
The system utilizes a compile-once evaluate-many model, parsing and validating expressions into cached programs for repeated execution across different datasets. It further distinguishes itself as a partial state evaluator, using commutative logic to compute results and return residual expressions when certain input variables are missing.
The engine covers high-level capabilities for dynamic policy enforcement and data filtering by validating structured data against boolean predicates. It supports the creation of custom domain-specific languages through the extension of evaluation logic with specific functions and restricted operators.
Features
- Expression Evaluators - Integrates a fast and safe expression evaluator into applications to execute user-defined logic without side effects.
- Expression Engines - Provides an embedded engine for integrating programmable, side-effect-free logic into applications via a C-like syntax.
- Abstract Syntax Tree Parsing - Converts human-readable expression strings into a structured tree for safe and efficient evaluation.
- Compiled Expression Programs - Parses and type-checks expressions into a reusable program to avoid redundant overhead during repeated execution.
- Evaluation Environments - Allows declaring available variables and functions to ensure expressions remain type-safe and context-aware.
- High-Performance Expression Evaluators - Uses a compile-once evaluate-many workflow to process large datasets through reusable and type-checked expressions.
- Program Caching Strategies - Parses expressions into cached programs for repeated high-performance execution across different input datasets.
- Residual Expression Evaluation - Computes results using commutative logic to return residual expressions when input variables are incomplete.
- Residual State Evaluation - Computes results with missing variables using commutative logic to return residual expressions.
- Policy Enforcement - Evaluates boolean predicates against structured data to enforce authorization rules and request filters.
- Safe Execution Environments - Runs human-readable expressions in a sandboxed environment that prevents arbitrary code execution.
- Abstract Syntax Tree Parsing - Converts human-readable expression strings into a structured tree for safe and efficient evaluation.
- Environment Type Validation - Validates expression types against a declared schema of variables and functions to ensure context-aware type safety.
- Pure Expression Execution - Executes pre-compiled expressions against input variables to produce results without modifying state.
- Stateless Expression Evaluation - Executes expressions in a stateless manner to ensure thread safety and predictable results across concurrent calls.
- Static Type Checking - Validates expression types against a declared environment at compile time to prevent runtime type errors.
- Expression Type Resolution - Validates expression types against a declared environment before evaluation to catch errors early.
- AST Type Validation - Converts expression strings into type-checked abstract syntax trees to catch errors before evaluation.
- Data Type Definitions - Represents information using JSON objects or typed schemas to provide context for expression evaluation.
- Application-Embedded Evaluators - Allows integrating a fast and safe expression evaluator into applications using domain-specific extensions.
- Domain Specific Languages - Allows building tailored expression engines with specific functions and operators for specialized applications.
- Expression Languages - Provides a lightweight expression language to reshape or extract fields from data sets.
- Expression Tree Compilation - Stores parsed and type-checked expression trees as executable programs to maximize performance across repeated evaluations.
- Partial Evaluation - Implements partial evaluation to compute results and return residual expressions when some input variables are missing.
- Evaluator Logic Extensions - Enables customizing evaluation logic by adding specific functions and restricting operators to match application requirements.
- Predicate-Based Authorization - Checks structured data against boolean conditions to enforce authorization rules or request filters.
- Compilers and Interpreters - Common Expression Language implementation.
- Scripting Languages - Fast, portable expression evaluation engine.
