refactor: define Expr interface

Instead of exporting Expr struct directly,
define Expr interface and hide impl.

Pros.
* Does not allow `Expr{ ... }` construction
* No need to write a lots of useless GoDoc comments on exported struct methods

Cons.
* Little bit bothersome, but it's better than Java :p

Author: tyru

dsl/deparse.go

@@ -8,9 +8,9 @@ import (
 	"github.com/vim-volt/volt/dsl/types"
 )
 
-// Deparse deparses *types.Expr.
+// Deparse deparses types.Expr.
 // ["@", 1, 2, 3] becomes [1, 2, 3]
-func Deparse(expr *types.Expr) (interface{}, error) {
+func Deparse(expr types.Expr) (interface{}, error) {
 	value, err := deparse(expr)
 	if err != nil {
 		return nil, err
@@ -38,7 +38,7 @@ func deparse(value types.Value) (interface{}, error) {
 			m[k] = v
 		}
 		return m, nil
-	case *types.Expr:
+	case types.Expr:
 		a := make([]interface{}, 0, len(val.Args())+1)
 		// Do not include "@" in array literal
 		if val.Op().String() != ops.ArrayOp.String() {

dsl/execute.go

@@ -24,7 +24,7 @@ const (
 )
 
 // Execute executes given expr with given ctx.
-func Execute(ctx context.Context, expr *types.Expr) (val types.Value, rollback func(), err error) {
+func Execute(ctx context.Context, expr types.Expr) (val types.Value, rollback func(), err error) {
 	for _, required := range []struct {
 		key      CtxKeyType
 		validate func(interface{}) error

dsl/ops/func_do.go

@@ -26,7 +26,7 @@ func (*doOp) IsMacro() bool {
 	return false
 }
 
-func (*doOp) Bind(args ...types.Value) (*types.Expr, error) {
+func (*doOp) Bind(args ...types.Value) (types.Expr, error) {
 	sig := make([]types.Type, 0, len(args))
 	for i := 0; i < len(args); i++ {
 		sig = append(sig, types.AnyValue)

dsl/ops/macro_array.go

@@ -21,7 +21,7 @@ func (op *arrayOp) InvertExpr(args []types.Value) (types.Value, error) {
 	return op.macroInvertExpr(op.EvalExpr(context.Background(), args))
 }
 
-func (*arrayOp) Bind(args ...types.Value) (*types.Expr, error) {
+func (*arrayOp) Bind(args ...types.Value) (types.Expr, error) {
 	expr := types.NewExpr(ArrayOp, args, types.NewArrayType(types.AnyValue))
 	return expr, nil
 }

dsl/ops/macro_eval.go

@@ -22,7 +22,7 @@ func (op *evalOp) InvertExpr(args []types.Value) (types.Value, error) {
 	return op.macroInvertExpr(op.EvalExpr(context.Background(), args))
 }
 
-func (*evalOp) Bind(args ...types.Value) (*types.Expr, error) {
+func (*evalOp) Bind(args ...types.Value) (types.Expr, error) {
 	expr := types.NewExpr(ArrayOp, args, types.NewArrayType(types.AnyValue))
 	return expr, nil
 }

dsl/ops/macro_invert.go

@@ -22,7 +22,7 @@ func (op *invertOp) InvertExpr(args []types.Value) (types.Value, error) {
 	return op.macroInvertExpr(op.EvalExpr(context.Background(), args))
 }
 
-func (*invertOp) Bind(args ...types.Value) (*types.Expr, error) {
+func (*invertOp) Bind(args ...types.Value) (types.Expr, error) {
 	expr := types.NewExpr(ArrayOp, args, types.NewArrayType(types.AnyValue))
 	return expr, nil
 }

dsl/parse.go

@@ -14,7 +14,7 @@ import (
 // 1. Split to operation and its arguments
 // 2. Do semantic analysis recursively for its arguments
 // 3. Convert to *Expr
-func Parse(content []byte) (*types.Expr, error) {
+func Parse(content []byte) (types.Expr, error) {
 	var value interface{}
 	if err := json.Unmarshal(content, value); err != nil {
 		return nil, err
@@ -29,7 +29,7 @@ func Parse(content []byte) (*types.Expr, error) {
 	}
 	// If expression's operator is a macro, return value may not be an array
 	// (e.g. ["macro", 1, 2])
-	expr, ok := arrayValue.(*types.Expr)
+	expr, ok := arrayValue.(types.Expr)
 	if !ok {
 		return nil, errors.New("the result must be an expression")
 	}

dsl/types/expr.go

@@ -3,44 +3,58 @@ package types
 import "context"
 
 // Expr has an operation and its arguments
-type Expr struct {
+type Expr interface {
+	// Op returns operator of Expr
+	Op() Op
+
+	// Args returns arguments of Expr
+	Args() []Value
+
+	// RetType returns return type of Expr
+	RetType() Type
+
+	// Eval evaluates given expression expr with given transaction ID trxID.
+	Eval(ctx context.Context) (val Value, rollback func(), err error)
+
+	// Invert inverts this expression.
+	// This just calls Op().InvertExpr() with saved arguments.
+	Invert() (Value, error)
+
+	// Type returns the type.
+	Type() Type
+}
+
+// NewExpr creates Expr instance
+func NewExpr(op Op, args []Value, retType Type) Expr {
+	return &expr{op: op, args: args, retType: retType}
+}
+
+type expr struct {
 	op      Op
 	args    []Value
 	retType Type
 }
 
-// Op returns operator of Expr
-func (expr *Expr) Op() Op {
+func (expr *expr) Op() Op {
 	return expr.op
 }
 
-// Args returns arguments of Expr
-func (expr *Expr) Args() []Value {
+func (expr *expr) Args() []Value {
 	return expr.args
 }
 
-// RetType returns return type of Expr
-func (expr *Expr) RetType() Type {
+func (expr *expr) RetType() Type {
 	return expr.retType
 }
 
-// NewExpr creates Expr instance
-func NewExpr(op Op, args []Value, retType Type) *Expr {
-	return &Expr{op: op, args: args, retType: retType}
-}
-
-// Eval evaluates given expression expr with given transaction ID trxID.
-func (expr *Expr) Eval(ctx context.Context) (val Value, rollback func(), err error) {
+func (expr *expr) Eval(ctx context.Context) (val Value, rollback func(), err error) {
 	return expr.op.EvalExpr(ctx, expr.args)
 }
 
-// Invert inverts this expression.
-// This just calls Op().InvertExpr() with saved arguments.
-func (expr *Expr) Invert() (Value, error) {
+func (expr *expr) Invert() (Value, error) {
 	return expr.op.InvertExpr(expr.args)
 }
 
-// Type returns the type.
-func (expr *Expr) Type() Type {
+func (expr *expr) Type() Type {
 	return expr.retType
 }

dsl/types/op.go

@@ -11,7 +11,7 @@ type Op interface {
 	InvertExpr(args []Value) (Value, error)
 
 	// Bind binds its arguments, and check if the types of values are correct
-	Bind(args ...Value) (*Expr, error)
+	Bind(args ...Value) (Expr, error)
 
 	// EvalExpr evaluates expression (this operator + given arguments).
 	// If this operator is a function, it executes the operation and returns its