expression

Documentation

Index

• Variables
• func Register[T any](build func(b ExprBuilder) T, expr Expr) T
• func Stringify(e any) string
• func WithValueGetter(ctx context.Context, getter ValueGetter) context.Context
• type E
  • func (e *E) String() string
• type Expr
  • func From(expression Expression) (Expr, error)
• type ExprBuilder
• type ExprCreator
• type Expression
  • func Parse(b []byte) (Expression, error)
  • func ParseString(s string) (Expression, error)
• type Setter
• type ValueGetter
  • func ValueGetterFromContext(ctx context.Context) ValueGetter
  • func ValueGetterFunc(g func(name string) (any, bool)) ValueGetter

Variables

var AllOf = Register(func(b ExprBuilder) func(ex ...Expression) Expression {
	return func(rules ...Expression) Expression {
		args := make([]any, len(rules))
		for i := range rules {
			args[i] = rules[i]
		}
		return b.BuildExpression(args...)
	}
}, &allOf{})

AllOf

Syntax

allOf(gt(1), lt(10))

var AnyOf = Register(func(b ExprBuilder) func(ex ...any) Expression {
	return func(ex ...any) Expression {
		return b.BuildExpression(ex...)
	}
}, &anyOf{})

AnyOf

Syntax

anyOf(1, 2, 3)

var CharCount = Register(func(b ExprBuilder) func() Expression {
	return func() Expression {
		return b.BuildExpression()
	}
}, &charCount{})

CharCount

Syntax

charCount()

var Elem = Register(func(b ExprBuilder) func(ex Expression) Expression {
	return func(ex Expression) Expression {
		return b.BuildExpression(ex)
	}
}, &elem{})

Elem

Syntax

elem(eq(1))

var Eq = Register(func(b ExprBuilder) func(expect any) Expression {
	return func(expect any) Expression {
		return b.BuildExpression(expect)
	}
}, &eq{})

Eq

Syntax

eq(1)
eq(1.0)
eq("x")

var Every = Register(func(b ExprBuilder) func(ex Expression) Expression {
	return func(ex Expression) Expression {
		return b.BuildExpression(ex)
	}
}, &every{})

Every

Syntax

    every(
	        key(len(), gt(1)),
	        elem(len(), gt(1)),
    )

var Get = Register(func(b ExprBuilder) func(fieldName string) Expression {
	return func(fieldName string) Expression {
		return b.BuildExpression(fieldName)
	}
}, &get{})

Get

Syntax

get("x")

var Gt = Register(func(b ExprBuilder) func(expect any) Expression {
	return func(expect any) Expression {
		return b.BuildExpression(expect)
	}
}, &gt{})

Gt

Syntax

gt(10)

var Gte = Register(func(b ExprBuilder) func(expect any) Expression {
	return func(expect any) Expression {
		return b.BuildExpression(expect)
	}
}, &gte{})

Gte

Syntax

gte(10)

var Key = Register(func(b ExprBuilder) func(ex Expression) Expression {
	return func(ex Expression) Expression {
		return b.BuildExpression(ex)
	}
}, &key{})

Key

Syntax

key(eq(1))

var Len = Register(func(b ExprBuilder) func() Expression {
	return func() Expression {
		return b.BuildExpression()
	}
}, &lenExpr{})

Len

Syntax

len()

var Lt = Register(func(b ExprBuilder) func(expect any) Expression {
	return func(expect any) Expression {
		return b.BuildExpression(expect)
	}
}, &lt{})

Lt

Syntax

lt(10)

var Lte = Register(func(b ExprBuilder) func(expect any) Expression {
	return func(expect any) Expression {
		return b.BuildExpression(expect)
	}
}, &lte{})

Lte

Syntax

lte(10)

var Match = Register(func(b ExprBuilder) func(pattern string) Expression {
	return func(pattern string) Expression {
		return b.BuildExpression(pattern)
	}
}, &match{})

Match

Syntax

match("[a-z]+")

var Not = Register(func(b ExprBuilder) func(ex ...Expression) Expression {
	return func(rules ...Expression) Expression {
		args := make([]any, len(rules))
		for i := range rules {
			args[i] = rules[i]
		}
		return b.BuildExpression(args...)
	}
}, &not{})

Not

Syntax

not(gt(1))

var OneOf = Register(func(b ExprBuilder) func(ex ...any) Expression {
	return func(ex ...any) Expression {
		return b.BuildExpression(ex...)
	}
}, &oneOf{})

OneOf

Syntax

oneOf(1, 2, 3)

var Pipe = Register(func(b ExprBuilder) func(ex ...any) Expression {
	return func(ex ...any) Expression {
		return b.BuildExpression(ex...)
	}
}, &pipe{})

Pipe

Syntax

pipe(1, eq(1))

var Select = Register(func(b ExprBuilder) func(rules ...Expression) Expression {
	return func(rules ...Expression) Expression {
		args := make([]any, len(rules))
		for i := range rules {
			args[i] = rules[i]
		}
		return b.BuildExpression(args...)
	}
}, &selectExpr{})

Select

Syntax

select(
	when(
		pipe(get("x"), eq(1)),
		eq(2),
  	),
  	eq(1),
)

var Some = Register(func(b ExprBuilder) func(ex Expression) Expression {
	return func(ex Expression) Expression {
		return b.BuildExpression(ex)
	}
}, &some{})

Every

Syntax

    some(
	        key(len(), gt(1)),
	        elem(len(), gt(1)),
    )

var When = Register(func(b ExprBuilder) func(condition Expression, then Expression) Expression {
	return func(condition Expression, then Expression) Expression {
		return b.BuildExpression(condition, then)
	}
}, &when{})

When

Syntax

when(
	pipe(get("x"), eq(1)),
	eq(2),
)

Functions

func Register

func Register[T any](build func(b ExprBuilder) T, expr Expr) T

func Stringify

func Stringify(e any) string

func WithValueGetter

func WithValueGetter(ctx context.Context, getter ValueGetter) context.Context

Types

type E

type E struct {
	// contains filtered or unexported fields
}

func (*E) String

func (e *E) String() string

type Expr

type Expr interface {
	// Exec final exec
	Exec(ctx context.Context, input any) (any, error)

	String() string
}

func From

func From(expression Expression) (Expr, error)

type ExprBuilder

type ExprBuilder interface {
	BuildExpression(args ...any) Expression
}

type ExprCreator

type ExprCreator interface {
	// New expr
	New(ctx context.Context, args ...any) (Expr, error)
}

type Expression

type Expression = []any

func Parse

func Parse(b []byte) (Expression, error)

func ParseString

func ParseString(s string) (Expression, error)

type Setter

type Setter = func(rv reflect.Value, args []any) error

type ValueGetter

type ValueGetter interface {
	Get(name string) (any, bool)
}

func ValueGetterFromContext

func ValueGetterFromContext(ctx context.Context) ValueGetter

func ValueGetterFunc

func ValueGetterFunc(g func(name string) (any, bool)) ValueGetter