README
¶
Expr
Expr package provides an engine that can compile and evaluate expressions. An expression is a one-liner that returns a value (mostly, but not limited to, booleans). It is designed for simplicity, speed and safety.
The purpose of the package is to allow users to use expressions inside configuration for more complex logic. It is a perfect candidate for the foundation of a business rule engine. The idea is to let configure things in a dynamic way without recompile of a program:
# Get the special price if
user.Group in ["good_customers", "collaborator"]
# Promote article to the homepage when
len(article.Comments) > 100 and article.Category not in ["misc"]
# Send an alert when
product.Stock < 15
Features
- Seamless integration with Go (no need to redefine types)
- Static typing (example).
out, err := expr.Compile(`name + age`) // err: invalid operation + (mismatched types string and int) // | name + age // | .....^ - User-friendly error messages.
- Reasonable set of basic operators.
- Builtins
all,none,any,one,filter,map.all(Tweets, {.Size <= 280}) - Fast (benchmarks): uses bytecode virtual machine and optimizing compiler.
Install
go get github.com/oarkflow/expr
Documentation
- See Getting Started page for developer documentation.
- See Language Definition page to learn the syntax.
Expr Code Editor
Also, I have an embeddable code editor written in JavaScript which allows editing expressions with syntax highlighting and autocomplete based on your types declaration.
Examples
package main
import (
"fmt"
"github.com/oarkflow/expr"
)
func main() {
env := map[string]interface{}{
"greet": "Hello, %v!",
"names": []string{"world", "you"},
"sprintf": fmt.Sprintf,
}
code := `sprintf(greet, names[0])`
program, err := expr.Compile(code, expr.Env(env))
if err != nil {
panic(err)
}
output, err := expr.Run(program, env)
if err != nil {
panic(err)
}
fmt.Println(output)
}
package main
import (
"fmt"
"github.com/oarkflow/expr"
)
type Tweet struct {
Len int
}
type Env struct {
Tweets []Tweet
}
func main() {
code := `all(Tweets, {.Len <= 240})`
program, err := expr.Compile(code, expr.Env(Env{}))
if err != nil {
panic(err)
}
env := Env{
Tweets: []Tweet{{42}, {98}, {69}},
}
output, err := expr.Run(program, env)
if err != nil {
panic(err)
}
fmt.Println(output)
}
Who uses Expr?
- Aviasales uses Expr as a business rule engine for our flight search engine.
- Wish.com uses Expr for decision-making rule engine in the Wish Assistant.
- Argo uses Expr in Argo Rollouts and Argo Workflows for Kubernetes.
- Crowdsec uses Expr in a security automation tool.
- FACEIT uses Expr to allow customization of its eSports matchmaking algorithm.
- qiniu uses Expr in trade systems.
- Junglee Games uses Expr for an in house marketing retention tool Project Audience.
- OpenTelemetry uses Expr in the OpenTelemetry Collector.
- Philips Labs uses Expr in Tabia, a tool for collecting insights on the characteristics of our code bases.
- CoreDNS uses Expr in CoreDNS, a DNS server.
- Chaos Mesh uses Expr in Chaos Mesh, a cloud-native Chaos Engineering platform.
- Milvus uses Expr in Milvus, an open-source vector database.
- Visually.io uses Expr as a business rule engine for our personalization targeting algorithm.
- Akvorado uses Expr to classify exporters and interfaces in network flows.
License
Documentation
¶
Index ¶
- func AddFunction(name string, handler func(params ...any) (any, error))
- func Compile(input string, ops ...Option) (*vm.Program, error)
- func Eval(input string, env interface{}) (interface{}, error)
- func Parse(expr string) (*vm.Program, error)
- func Run(program *vm.Program, env interface{}) (interface{}, error)
- type Option
- func AllowUndefinedVariables() Option
- func AsBool() Option
- func AsFloat64() Option
- func AsInt() Option
- func AsInt64() Option
- func AsKind(kind reflect.Kind) Option
- func ConstExpr(fn string) Option
- func Env(env interface{}) Option
- func Function(name string, fn func(params ...interface{}) (interface{}, error), ...) Option
- func Operator(operator string, fn ...string) Option
- func Optimize(b bool) Option
- func Patch(visitor ast.Visitor) Option
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
Types ¶
type Option ¶
Option for configuring config.
func AllowUndefinedVariables ¶
func AllowUndefinedVariables() Option
AllowUndefinedVariables allows to use undefined variables inside expressions. This can be used with expr.Env option to partially define a few variables.
func ConstExpr ¶
ConstExpr defines func expression as constant. If all argument to this function is constants, then it can be replaced by result of this func call on compile step.
func Env ¶
func Env(env interface{}) Option
Env specifies expected input of env for type checks. If struct is passed, all fields will be treated as variables, as well as all fields of embedded structs and struct itself. If map is passed, all items will be treated as variables. Methods defined on this type will be available as functions.
func Function ¶
func Function(name string, fn func(params ...interface{}) (interface{}, error), types ...interface{}) Option
Function adds function to list of functions what will be available in expressions.
Source Files
Directories