func Lte(field string, v interface{}) Matcher {
	return NewFieldMatcher(field, &cmp{value: v, token: token.LEQ})
}
Lte matcher, checks if the given field is lesser than or equal to the given value
package q
import (
	"go/token"
	"reflect"
)
type Matcher interface {
	Match(interface{}) (bool, error)
}
type ValueMatcher interface {
	MatchValue(*reflect.Value) (bool, error)
}
type cmp struct {
	value interface{}
	token token.Token
}
func (c *cmp) MatchField(v interface{}) (bool, error) {
	return compare(v, c.value, c.token), nil
}
type trueMatcher struct{}
func (*trueMatcher) Match(i interface{}) (bool, error) {
	return true, nil
}
func (*trueMatcher) MatchValue(v *reflect.Value) (bool, error) {
	return true, nil
}
type or struct {
	children []Matcher
}
func (c *or) Match(i interface{}) (bool, error) {
	v := reflect.Indirect(reflect.ValueOf(i))
	return c.MatchValue(&v)
}
func (c *or) MatchValue(v *reflect.Value) (bool, error) {
	for _, matcher := range c.children {
		if vm, ok := matcher.(ValueMatcher); ok {
			ok, err := vm.MatchValue(v)
			if err != nil {
				return false, err
			}
			if ok {
				return true, nil
			}
			continue
		}
		ok, err := matcher.Match(v.Interface())
		if err != nil {
			return false, err
		}
		if ok {
			return true, nil
		}
	}
	return false, nil
}
type and struct {
	children []Matcher
}
func (c *and) Match(i interface{}) (bool, error) {
	v := reflect.Indirect(reflect.ValueOf(i))
	return c.MatchValue(&v)
}
func (c *and) MatchValue(v *reflect.Value) (bool, error) {
	for _, matcher := range c.children {
		if vm, ok := matcher.(ValueMatcher); ok {
			ok, err := vm.MatchValue(v)
			if err != nil {
				return false, err
			}
			if !ok {
				return false, nil
			}
			continue
		}
		ok, err := matcher.Match(v.Interface())
		if err != nil {
			return false, err
		}
		if !ok {
			return false, nil
		}
	}
	return true, nil
}
type strictEq struct {
	field string
	value interface{}
}
func (s *strictEq) MatchField(v interface{}) (bool, error) {
	return reflect.DeepEqual(v, s.value), nil
}
type in struct {
	list interface{}
}
func (i *in) MatchField(v interface{}) (bool, error) {
	ref := reflect.ValueOf(i.list)
	if ref.Kind() != reflect.Slice {
		return false, nil
	}
	c := cmp{
		token: token.EQL,
	}
	for i := 0; i < ref.Len(); i++ {
		c.value = ref.Index(i).Interface()
		ok, err := c.MatchField(v)
		if err != nil {
			return false, err
		}
		if ok {
			return true, nil
		}
	}
	return false, nil
}
type not struct {
	children []Matcher
}
func (n *not) Match(i interface{}) (bool, error) {
	v := reflect.Indirect(reflect.ValueOf(i))
	return n.MatchValue(&v)
}
func (n *not) MatchValue(v *reflect.Value) (bool, error) {
	var err error
	for _, matcher := range n.children {
		vm, ok := matcher.(ValueMatcher)
		if ok {
			ok, err = vm.MatchValue(v)
		} else {
			ok, err = matcher.Match(v.Interface())
		}
		if err != nil {
			return false, err
		}
		if ok {
			return false, nil
		}
	}
	return true, nil
}
func Eq(field string, v interface{}) Matcher {
	return NewFieldMatcher(field, &cmp{value: v, token: token.EQL})
}
func StrictEq(field string, v interface{}) Matcher {
	return NewFieldMatcher(field, &strictEq{value: v})
}
func Gt(field string, v interface{}) Matcher {
	return NewFieldMatcher(field, &cmp{value: v, token: token.GTR})
}
func Gte(field string, v interface{}) Matcher {
	return NewFieldMatcher(field, &cmp{value: v, token: token.GEQ})
}
func Lt(field string, v interface{}) Matcher {
	return NewFieldMatcher(field, &cmp{value: v, token: token.LSS})
}