antonmedv/expr
Expr
Expr is a high-performance expression evaluation engine and language for Go applications. It functions as a dynamic rule engine that parses and executes custom logic and data validations at runtime without requiring the application to be recompiled.
The system utilizes a sandboxed logic executor to run expressions without side effects. It ensures program termination by employing instruction-level loop detection to prevent infinite loops and isolates the evaluation process from the host system.
The engine employs a bytecode-based virtual machine and abstract syntax tree analysis to achieve execution. It includes static type resolution and runtime type validation to ensure data correctness, using reflection to map external object properties to expression identifiers.
Features
- Expression Evaluators - Provides a high-performance engine for parsing and executing custom logical expressions at runtime.
- Bytecode Virtual Machines - Compiles expressions into low-level bytecode for high-speed execution via a custom virtual machine.
- Embedded Logic Evaluation - Integrates an expression parser and evaluator to execute custom logic within Go applications without recompilation.
- Type Validation - Implements type correctness checks during expression evaluation to ensure consistent data handling.
- Expression Languages - Implements a custom expression language for defining dynamic logic within Go applications.
- Runtime Type Validation - Verifies that dynamic expressions adhere to specific data types during execution to ensure behavioral correctness.
- Abstract Syntax Tree Parsing - Converts source text into a structured tree for semantic validation and type checking before execution.
- Dynamic Rule Engines - Functions as a dynamic rule engine that parses and executes custom logic and data validations at runtime.
- Sandboxed Execution Environments - Isolates the expression evaluation process from the host system to prevent unauthorized side effects.
- Expression Type Resolution - Determines expected data types during compilation to avoid runtime type mismatches.
- Business Rule Engines - Enables the creation of systems where non-developers can define business logic using a simplified language.
- Logic Sandboxing - Safely runs untrusted user-provided logic within Go programs to prevent crashes and infinite loops.
- Execution Sandboxes - Restricts the execution environment of dynamic expressions to prevent unauthorized system access and infinite loops.
- Loop Detection - Employs instruction-level loop detection to ensure program termination and prevent infinite loops.
- Dynamic Property Mapping - Uses Go reflection to dynamically map external object properties and methods to expression identifiers.
- Compilers and Interpreters - Compiles and executes string-based expressions.
- Embedded Scripting - Engine for evaluating expressions.
- Scripting Languages - Dynamic expression evaluation engine.
