func (exp *BinaryExpr) All() []Node {
	return []Node{exp.Left, exp.Right}
}
All returns all the child Nodes in a BinaryExpr.
package parse
import "fmt"
type Expr interface {
	Node
}
type NameExpr struct {
	Pos
	Name string  
}
func NewNameExpr(name string, pos Pos) *NameExpr {
	return &NameExpr{pos, name}
}
func (exp *NameExpr) All() []Node {
	return []Node{}
}
func (exp *NameExpr) String() string {
	return fmt.Sprintf("NameExpr(%s)", exp.Name)
}
type NullExpr struct {
	Pos
}
func (exp *NullExpr) All() []Node {
	return []Node{}
}
func NewNullExpr(pos Pos) *NullExpr {
	return &NullExpr{pos}
}
func (exp *NullExpr) String() string {
	return "NULL"
}
type BoolExpr struct {
	Pos
	Value bool  
}
func NewBoolExpr(value bool, pos Pos) *BoolExpr {
	return &BoolExpr{pos, value}
}
func (exp *BoolExpr) All() []Node {
	return []Node{}
}
func (exp *BoolExpr) String() string {
	if exp.Value {
		return "TRUE"
	}
	return "FALSE"
}
type NumberExpr struct {
	Pos
	Value string  
}
func NewNumberExpr(val string, pos Pos) *NumberExpr {
	return &NumberExpr{pos, val}
}
func (exp *NumberExpr) All() []Node {
	return []Node{}
}
func (exp *NumberExpr) String() string {
	return fmt.Sprintf("NumberExpr(%s)", exp.Value)
}
type StringExpr struct {
	Pos
	Text string  
}
func NewStringExpr(text string, pos Pos) *StringExpr {
	return &StringExpr{pos, text}
}
func (exp *StringExpr) All() []Node {
	return []Node{}
}
func (exp *StringExpr) String() string {
	return fmt.Sprintf("StringExpr(%s)", exp.Text)
}
type FuncExpr struct {
	Pos
	Name string  
	Args []Expr  
}
func (exp *FuncExpr) All() []Node {
	res := make([]Node, len(exp.Args))
	for i, n := range exp.Args {
		res[i] = n
	}
	return res
}
func NewFuncExpr(name string, args []Expr, pos Pos) *FuncExpr {
	return &FuncExpr{pos, name, args}
}
func (exp *FuncExpr) String() string {
	return fmt.Sprintf("FuncExpr(%s, %s)", exp.Name, exp.Args)
}
type FilterExpr struct {
	*FuncExpr
}
func (exp *FilterExpr) String() string {
	return fmt.Sprintf("FilterExpr(%s, %s)", exp.Name, exp.Args)
}
func NewFilterExpr(name string, args []Expr, pos Pos) *FilterExpr {
	return &FilterExpr{NewFuncExpr(name, args, pos)}
}
type TestExpr struct {
	*FuncExpr
}
func (exp *TestExpr) String() string {
	return fmt.Sprintf("TestExpr(%s, %s)", exp.Name, exp.Args)
}
func NewTestExpr(name string, args []Expr, pos Pos) *TestExpr {
	return &TestExpr{NewFuncExpr(name, args, pos)}
}
type BinaryExpr struct {
	Pos
	Left  Expr    
	Op    string  
	Right Expr    
}
func NewBinaryExpr(left Expr, op string, right Expr, pos Pos) *BinaryExpr {
	return &BinaryExpr{pos, left, op, right}
}