FazBrowse GitHub Viewer | Trending |
URL:
| Home
Tools: [Download Repo ZIP]   [Original HTTPS Page]

expr package - github.com/expr-lang/expr - Go Packages

  1. Discover Packages
  2. github.com/expr-lang/expr

expr

package module
v1.17.8 Latest Latest

This package is not in the latest version of its module.

 Go to latest Published: Feb 14, 2026 License: MIT Imports: 14 Imported by: 494
Main Versions Licenses Imports Imported By

Details

Repository

github.com/expr-lang/expr

Links

README

README

Expr

Expr is a Go-centric expression language designed to deliver dynamic configurations with unparalleled accuracy, safety, and speed. Expr combines simple syntax with powerful features for ease of use:

// Allow only admins and moderators to moderate comments.
user.Group in ["admin", "moderator"] || user.Id == comment.UserId

// Determine whether the request is in the permitted time window.
request.Time - resource.Age < duration("24h")

// Ensure all tweets are less than 240 characters.
all(tweets, len(.Content) <= 240)

Features

Expr is a safe, fast, and intuitive expression evaluator optimized for the Go language. Here are its standout features:

Safety and Isolation

  • Memory-Safe: Expr is designed with a focus on safety, ensuring that programs do not access unrelated memory or introduce memory vulnerabilities.
  • Side-Effect-Free: Expressions evaluated in Expr only compute outputs from their inputs, ensuring no side-effects that can change state or produce unintended results.
  • Always Terminating: Expr is designed to prevent infinite loops, ensuring that every program will conclude in a reasonable amount of time.

Go Integration

  • Seamless with Go: Integrate Expr into your Go projects without the need to redefine types.

Static Typing

  • Ensures type correctness and prevents runtime type errors. 
    out, err := expr.Compile(`name + age`)
// err: invalid operation + (mismatched types string and int)
// | name + age
// | .....^

User-Friendly

  • Provides user-friendly error messages to assist with debugging and development.

Flexibility and Utility

  • Rich Operators: Offers a reasonable set of basic operators for a variety of applications.
  • Built-in Functions: Functions like all, none, any, one, filter, and map are provided out-of-the-box.

Performance

  • Optimized for Speed: Expr stands out in its performance, utilizing an optimizing compiler and a bytecode virtual machine. Check out these benchmarks for more details.

Install

go get github.com/expr-lang/expr

Documentation

Examples

Play Online

package main

import (
	"fmt"
	"github.com/expr-lang/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)
}

Play Online

package main

import (
	"fmt"
	"github.com/expr-lang/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?

  • Google uses Expr as one of its expression languages on the Google Cloud Platform.
  • Uber uses Expr to allow customization of its Uber Eats marketplace.
  • GoDaddy employs Expr for the customization of its GoDaddy Pro product.
  • ByteDance incorporates Expr into its internal business rule engine.
  • Aviasales utilizes Expr as a business rule engine for its flight search engine.
  • Alibaba uses Expr in a web framework for building recommendation services.
  • Argo integrates Expr into Argo Rollouts and Argo Workflows for Kubernetes.
  • Wish.com employs Expr in its decision-making rule engine for the Wish Assistant.
  • OpenTelemetry integrates Expr into the OpenTelemetry Collector.
  • Philips Labs employs Expr in Tabia, a tool designed to collect insights on their code bases.
  • CrowdSec incorporates Expr into its security automation tool.
  • CoreDNS uses Expr in CoreDNS, which is a DNS server.
  • qiniu implements Expr in its trade systems.
  • Junglee Games uses Expr for its in-house marketing retention tool, Project Audience.
  • Faceit uses Expr to enhance customization of its eSports matchmaking algorithm.
  • Chaos Mesh incorporates Expr into Chaos Mesh, a cloud-native Chaos Engineering platform.
  • Visually.io employs Expr as a business rule engine for its personalization targeting algorithm.
  • Akvorado utilizes Expr to classify exporters and interfaces in network flows.
  • keda.sh uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
  • Span Digital uses Expr in its Knowledge Management products.
  • Xiaohongshu combining yaml with Expr for dynamically policies delivery.
  • Melrōse uses Expr to implement its music programming language.
  • Tork integrates Expr into its workflow execution.
  • Critical Moments uses Expr for its mobile realtime conditional targeting system.
  • WoodpeckerCI uses Expr for filtering workflows/steps.
  • FastSchema - A BaaS leveraging Expr for its customizable and dynamic Access Control system.
  • WunderGraph Cosmo - GraphQL Federeration Router uses Expr to customize Middleware behaviour
  • SOLO uses Expr interally to allow dynamic code execution with custom defined functions.
  • Naoma.AI uses Expr as a part of its call scoring engine.
  • GlassFlow.dev uses Expr to do realtime data transformation in ETL pipelines

Add your company too

License

MIT

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Compile added in v1.15.6 

func Compile(input string, ops ...Option) (*vm.Program, error)

Compile parses and compiles given input expression to bytecode program.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	env := map[string]any{
		"foo": 1,
		"bar": 99,
	}

	program, err := expr.Compile("foo in 1..99 and bar in 1..99", expr.Env(env))
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output)

}

Output:
true

func Eval 

func Eval(input string, env any) (any, error)

Eval parses, compiles and runs given input.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	output, err := expr.Eval("greet + name", map[string]any{
		"greet": "Hello, ",
		"name":  "world!",
	})
	if err != nil {
		fmt.Printf("err: %v", err)
		return
	}

	fmt.Printf("%v", output)

}

Output:
Hello, world!
Example (Bytes_literal) 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	// Bytes literal returns []byte.
	output, err := expr.Eval(`b"abc"`, nil)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output)

}

Output:
[97 98 99]
Example (Runtime_error) 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	_, err := expr.Eval(`map(1..3, {1 % (# - 3)})`, nil)
	fmt.Print(err)

}

Output:
runtime error: integer divide by zero (1:14)
 | map(1..3, {1 % (# - 3)})
 | .............^

func Run 

func Run(program *vm.Program, env any) (any, error)

Run evaluates given bytecode program.

Types

type Option added in v1.15.6 

type Option func(c *conf.Config)

Option for configuring config.

func AllowUndefinedVariables added in v1.15.6 

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.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	code := `name == nil ? "Hello, world!" : sprintf("Hello, %v!", name)`

	env := map[string]any{
		"sprintf": fmt.Sprintf,
	}

	options := []expr.Option{
		expr.Env(env),
		expr.AllowUndefinedVariables(), // Allow to use undefined variables.
	}

	program, err := expr.Compile(code, options...)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}
	fmt.Printf("%v\n", output)

	env["name"] = "you" // Define variables later on.

	output, err = expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}
	fmt.Printf("%v\n", output)

}

Output:
Hello, world!
Hello, you!
Example (Zero_value) 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	code := `name == "" ? foo + bar : foo + name`

	// If environment has different zero values, then undefined variables
	// will have it as default value.
	env := map[string]string{}

	options := []expr.Option{
		expr.Env(env),
		expr.AllowUndefinedVariables(), // Allow to use undefined variables.
	}

	program, err := expr.Compile(code, options...)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	env = map[string]string{
		"foo": "Hello, ",
		"bar": "world!",
	}

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}
	fmt.Printf("%v", output)

}

Output:
Hello, world!
Example (Zero_value_functions) 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
	"github.com/expr-lang/expr/test/mock"
)

func main() {
	code := `words == "" ? Split("foo,bar", ",") : Split(words, ",")`

	// Env is map[string]string type on which methods are defined.
	env := mock.MapStringStringEnv{}

	options := []expr.Option{
		expr.Env(env),
		expr.AllowUndefinedVariables(), // Allow to use undefined variables.
	}

	program, err := expr.Compile(code, options...)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}
	fmt.Printf("%v", output)

}

Output:
[foo bar]

func AsAny added in v1.15.6 

func AsAny() Option

AsAny tells the compiler to expect any result.

func AsBool added in v1.15.6 

func AsBool() Option

AsBool tells the compiler to expect a boolean result.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	env := map[string]int{
		"foo": 0,
	}

	program, err := expr.Compile("foo >= 0", expr.Env(env), expr.AsBool())
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output.(bool))

}

Output:
true
Example (Error) 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	env := map[string]any{
		"foo": 0,
	}

	_, err := expr.Compile("foo + 42", expr.Env(env), expr.AsBool())

	fmt.Printf("%v", err)

}

Output:
expected bool, but got int

func AsFloat64 added in v1.15.6 

func AsFloat64() Option

AsFloat64 tells the compiler to expect a float64 result.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	program, err := expr.Compile("42", expr.AsFloat64())
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	output, err := expr.Run(program, nil)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output.(float64))

}

Output:
42
Example (Error) 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	_, err := expr.Compile(`!!true`, expr.AsFloat64())

	fmt.Printf("%v", err)

}

Output:
expected float64, but got bool

func AsInt added in v1.15.6 

func AsInt() Option

AsInt tells the compiler to expect an int result.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	program, err := expr.Compile("42", expr.AsInt())
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	output, err := expr.Run(program, nil)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%T(%v)", output, output)

}

Output:
int(42)

func AsInt64 added in v1.15.6 

func AsInt64() Option

AsInt64 tells the compiler to expect an int64 result.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	env := map[string]any{
		"rating": 5.5,
	}

	program, err := expr.Compile("rating", expr.Env(env), expr.AsInt64())
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output.(int64))

}

Output:
5

func AsKind added in v1.15.6 

func AsKind(kind reflect.Kind) Option

AsKind tells the compiler to expect kind of the result.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/expr-lang/expr"
)

func main() {
	program, err := expr.Compile("{a: 1, b: 2}", expr.AsKind(reflect.Map))
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	output, err := expr.Run(program, nil)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output)

}

Output:
map[a:1 b:2]

func ConstExpr added in v1.15.6 

func ConstExpr(fn string) Option

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.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func fib(n int) int {
	if n <= 1 {
		return n
	}
	return fib(n-1) + fib(n-2)
}

func main() {
	code := `[fib(5), fib(3+3), fib(dyn)]`

	env := map[string]any{
		"fib": fib,
		"dyn": 0,
	}

	options := []expr.Option{
		expr.Env(env),
		expr.ConstExpr("fib"), // Mark fib func as constant expression.
	}

	program, err := expr.Compile(code, options...)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	// Only fib(5) and fib(6) calculated on Compile, fib(dyn) can be called at runtime.
	env["dyn"] = 7

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v\n", output)

}

Output:
[5 8 13]

func DisableAllBuiltins added in v1.15.6 

func DisableAllBuiltins() Option

DisableAllBuiltins disables all builtins.

func DisableBuiltin added in v1.15.6 

func DisableBuiltin(name string) Option

DisableBuiltin disables builtin function.

func DisableIfOperator added in v1.17.7 

func DisableIfOperator() Option

DisableIfOperator disables the `if ... else ...` operator syntax so a custom function named `if(...)` can be used without conflicts.

func DisableShortCircuit added in v1.17.7 

func DisableShortCircuit() Option

DisableShortCircuit turns short circuit off.

func EnableBuiltin added in v1.15.6 

func EnableBuiltin(name string) Option

EnableBuiltin enables builtin function.

func Env added in v1.0.7 

func Env(env any) 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.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	type Segment struct {
		Origin string
	}
	type Passengers struct {
		Adults int
	}
	type Meta struct {
		Tags map[string]string
	}
	type Env struct {
		Meta
		Segments   []*Segment
		Passengers *Passengers
		Marker     string
	}

	code := `all(Segments, {.Origin == "MOW"}) && Passengers.Adults > 0 && Tags["foo"] startsWith "bar"`

	program, err := expr.Compile(code, expr.Env(Env{}))
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	env := Env{
		Meta: Meta{
			Tags: map[string]string{
				"foo": "bar",
			},
		},
		Segments: []*Segment{
			{Origin: "MOW"},
		},
		Passengers: &Passengers{
			Adults: 2,
		},
		Marker: "test",
	}

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output)

}

Output:
true
Example (Hidden_tagged_field_names) 
package main

import (
	"fmt"
	"strings"

	"github.com/expr-lang/expr"
)

func main() {
	type Internal struct {
		Visible string
		Hidden  string `expr:"-"`
	}
	type environment struct {
		Visible         string
		Hidden          string   `expr:"-"`
		HiddenInternal  Internal `expr:"-"`
		VisibleInternal Internal
	}

	env := environment{
		Hidden: "First level secret",
		HiddenInternal: Internal{
			Visible: "Second level secret",
			Hidden:  "Also hidden",
		},
		VisibleInternal: Internal{
			Visible: "Not a secret",
			Hidden:  "Hidden too",
		},
	}

	hiddenValues := []string{
		`Hidden`,
		`HiddenInternal`,
		`HiddenInternal.Visible`,
		`HiddenInternal.Hidden`,
		`VisibleInternal["Hidden"]`,
	}
	for _, expression := range hiddenValues {
		output, err := expr.Eval(expression, env)
		if err == nil || !strings.Contains(err.Error(), "cannot fetch") {
			fmt.Printf("unexpected output: %v; err: %v\n", output, err)
			return
		}
		fmt.Printf("%q is hidden as expected\n", expression)
	}

	visibleValues := []string{
		`Visible`,
		`VisibleInternal`,
		`VisibleInternal["Visible"]`,
	}
	for _, expression := range visibleValues {
		_, err := expr.Eval(expression, env)
		if err != nil {
			fmt.Printf("unexpected error: %v\n", err)
			return
		}
		fmt.Printf("%q is visible as expected\n", expression)
	}

	testWithIn := []string{
		`not ("Hidden" in $env)`,
		`"Visible" in $env`,
		`not ("Hidden" in VisibleInternal)`,
		`"Visible" in VisibleInternal`,
	}
	for _, expression := range testWithIn {
		val, err := expr.Eval(expression, env)
		shouldBeTrue, ok := val.(bool)
		if err != nil || !ok || !shouldBeTrue {
			fmt.Printf("unexpected result; value: %v; error: %v\n", val, err)
			return
		}
	}

}

Output:
"Hidden" is hidden as expected
"HiddenInternal" is hidden as expected
"HiddenInternal.Visible" is hidden as expected
"HiddenInternal.Hidden" is hidden as expected
"VisibleInternal[\"Hidden\"]" is hidden as expected
"Visible" is visible as expected
"VisibleInternal" is visible as expected
"VisibleInternal[\"Visible\"]" is visible as expected
Example (Tagged_field_names) 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	env := struct {
		FirstWord  string
		Separator  string `expr:"Space"`
		SecondWord string `expr:"second_word"`
	}{
		FirstWord:  "Hello",
		Separator:  " ",
		SecondWord: "World",
	}

	output, err := expr.Eval(`FirstWord + Space + second_word`, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output)

}

Output:
Hello World

func Function added in v1.15.6 

func Function(name string, fn func(params ...any) (any, error), types ...any) Option

Function adds function to list of functions what will be available in expressions.

func MaxNodes added in v1.17.5 

func MaxNodes(n uint) Option

MaxNodes sets the maximum number of nodes allowed in the expression. By default, the maximum number of nodes is conf.DefaultMaxNodes. If MaxNodes is set to 0, the node budget check is disabled.

func Operator added in v1.15.6 

func Operator(operator string, fn ...string) Option

Operator allows to replace a binary operator with a function.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/expr-lang/expr"
)

func main() {
	code := `
		Now() > CreatedAt &&
		(Now() - CreatedAt).Hours() > 24
	`

	type Env struct {
		CreatedAt time.Time
		Now       func() time.Time
		Sub       func(a, b time.Time) time.Duration
		After     func(a, b time.Time) bool
	}

	options := []expr.Option{
		expr.Env(Env{}),
		expr.Operator(">", "After"),
		expr.Operator("-", "Sub"),
	}

	program, err := expr.Compile(code, options...)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	env := Env{
		CreatedAt: time.Date(2018, 7, 14, 0, 0, 0, 0, time.UTC),
		Now:       func() time.Time { return time.Now() },
		Sub:       func(a, b time.Time) time.Duration { return a.Sub(b) },
		After:     func(a, b time.Time) bool { return a.After(b) },
	}

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output)

}

Output:
true
Example (With_decimal) 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	type Decimal struct{ N float64 }
	code := `A + B - C`

	type Env struct {
		A, B, C Decimal
		Sub     func(a, b Decimal) Decimal
		Add     func(a, b Decimal) Decimal
	}

	options := []expr.Option{
		expr.Env(Env{}),
		expr.Operator("+", "Add"),
		expr.Operator("-", "Sub"),
	}

	program, err := expr.Compile(code, options...)
	if err != nil {
		fmt.Printf("Compile error: %v", err)
		return
	}

	env := Env{
		A:   Decimal{3},
		B:   Decimal{2},
		C:   Decimal{1},
		Sub: func(a, b Decimal) Decimal { return Decimal{a.N - b.N} },
		Add: func(a, b Decimal) Decimal { return Decimal{a.N + b.N} },
	}

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output)

}

Output:
{4}

func Optimize added in v1.15.6 

func Optimize(b bool) Option

Optimize turns optimizations on or off.

func Patch added in v1.15.6 

func Patch(visitor ast.Visitor) Option

Patch adds visitor to list of visitors what will be applied before compiling AST to bytecode.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
	"github.com/expr-lang/expr/ast"
)

type patcher struct{}

func (p *patcher) Visit(node *ast.Node) {
	switch n := (*node).(type) {
	case *ast.MemberNode:
		ast.Patch(node, &ast.CallNode{
			Callee:    &ast.IdentifierNode{Value: "get"},
			Arguments: []ast.Node{n.Node, n.Property},
		})
	}
}

func main() {
	program, err := expr.Compile(
		`greet.you.world + "!"`,
		expr.Patch(&patcher{}),
	)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	env := map[string]any{
		"greet": "Hello",
		"get": func(a, b string) string {
			return a + ", " + b
		},
	}

	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}
	fmt.Printf("%v", output)

}

Output:
Hello, you, world!

func Timezone added in v1.16.6 

func Timezone(name string) Option

Timezone sets default timezone for date() and now() builtin functions.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	program, err := expr.Compile(`now().Location().String()`, expr.Timezone("Asia/Kamchatka"))
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	output, err := expr.Run(program, nil)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output)
}

Output:
Asia/Kamchatka

func WarnOnAny added in v1.16.0 

func WarnOnAny() Option

WarnOnAny tells the compiler to warn if expression return any type.

Example 
package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

func main() {
	// Arrays always have []any type. The expression return type is any.
	// AsInt() instructs compiler to expect int or any, and cast to int,
	// if possible. WarnOnAny() instructs to return an error on any type.
	_, err := expr.Compile(`[42, true, "yes"][0]`, expr.AsInt(), expr.WarnOnAny())

	fmt.Printf("%v", err)

}

Output:
expected int, but got interface {}

func WithContext added in v1.15.6 

func WithContext(name string) Option

WithContext passes context to all functions calls with a context.Context argument.

Example 
package main

import (
	"context"
	"fmt"
	"time"

	"github.com/expr-lang/expr"
)

func main() {
	env := map[string]any{
		"fn": func(ctx context.Context, _, _ int) int {
			// An infinite loop that can be canceled by context.
			for {
				select {
				case <-ctx.Done():
					return 42
				}
			}
		},
		"ctx": context.TODO(), // Context should be passed as a variable.
	}

	program, err := expr.Compile(`fn(1, 2)`,
		expr.Env(env),
		expr.WithContext("ctx"), // Pass context variable name.
	)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	// Cancel context after 100 milliseconds.
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
	defer cancel()

	// After program is compiled, context can be passed to Run.
	env["ctx"] = ctx

	// Run will return 42 after 100 milliseconds.
	output, err := expr.Run(program, env)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}

	fmt.Printf("%v", output)
}

Output:
42

Source Files

View all Source files

Directories

Path Synopsis
nature
debug module
internal
deref
difflib
Package difflib is a partial port of Python difflib module.
 Package difflib is a partial port of Python difflib module.
ring
spew
Package spew implements a deep pretty printer for Go data structures to aid in debugging.
 Package spew implements a deep pretty printer for Go data structures to aid in debugging.
testify/assert
Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
 Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
testify/assert/internal/unsafetests
This package exists just to isolate tests that reference the unsafe package.
 This package exists just to isolate tests that reference the unsafe package.
testify/require
Package require implements the same assertions as the `assert` package but stops test execution when a test fails.
 Package require implements the same assertions as the `assert` package but stops test execution when a test fails.
lexer
operator
utils
value
Package value provides a Patcher that uses interfaces to allow custom types that can be represented as standard go values to be used more easily in expressions.
 Package value provides a Patcher that uses interfaces to allow custom types that can be represented as standard go values to be used more easily in expressions.
repl module
test
coredns
crowdsec
examples command
fuzz
gen command
mock
playground
func_types command
runtime
runtime/helpers command
Back | FazBrowse Home | New Git URL