demo

This example demonstrates how an enhanced visitable type can be used as though it were a tree of nodes.

package main

import (
	"fmt"
	"reflect"

	"github.com/cockroachdb/walkabout/demo"
)

func main() {
	data, _ := demo.NewContainer(true)

	for i := 0; i < data.TargetCount(); i++ {
		child := data.TargetAt(i)
		if child == nil {
			fmt.Printf("%d: nil\n", i)
		} else {
			fmt.Printf("%d: %s %s\n", i, child.TargetTypeID(), reflect.TypeOf(child))
		}
	}

}

Output:

0: ByRefType *demo.ByRefType
1: ByRefType *demo.ByRefType
2: []ByRefType *demo.targetAbstract
3: []*ByRefType *demo.targetAbstract
4: ByValType *demo.ByValType
5: ByValType *demo.ByValType
6: []ByValType *demo.targetAbstract
7: []*ByValType *demo.targetAbstract
8: nil
9: ByValType *demo.ByValType
10: ByValType *demo.ByValType
11: ByValType *demo.ByValType
12: ByValType *demo.ByValType
13: []Target *demo.targetAbstract
14: []*Target *demo.targetAbstract
15: []Target *demo.targetAbstract

This example shows a toy calculator AST and how custom actions can be introduced into the visitation flow. We've decided to use a visitor to stringify the Calculation. It's not how one would generally approach this problem, but it's useful to demonstrate more advanced flow-control.

package main

import (
	"fmt"
	"strconv"
	"strings"
)

// This generation flow will find all types in this package that
// are reachable from the Calculation struct and create a
// Calc interface to unify them.
//go:generate -command walkabout go run ..
//go:generate walkabout --union Calc --reachable Calculation

// This example shows a toy calculator AST and how custom actions can be
// introduced into the visitation flow. We've decided to use a visitor
// to stringify the Calculation. It's not how one would generally
// approach this problem, but it's useful to demonstrate more advanced
// flow-control.
func main() {
	c := &Calculation{
		Expr: &Func{"Avg", []Expr{
			&BinaryOp{"+", &Scalar{1}, &Scalar{3}},
			&Func{"Sum", []Expr{
				&Scalar{10},
				&Func{"Random", []Expr{&Scalar{1}, &Scalar{10}}},
				&Scalar{99}}},
			&BinaryOp{"*", &Scalar{5}, &Scalar{3}},
		}},
	}

	var w strings.Builder
	_, _, err := WalkCalc(c, func(ctx CalcContext, x Calc) CalcDecision {
		switch t := x.(type) {
		case *BinaryOp:
			// With a BinaryOp, we want to visit left, print the operator,
			// then right. We'll generate a sequence of actions to be
			// executed.
			return ctx.Actions(
				ctx.ActionVisit(t.Left),
				ctx.ActionCall(func() error { w.WriteString(t.Operator); return nil }),
				ctx.ActionVisit(t.Right),
			)

		case *Func:
			// With a function, we want to print commas between the arguments.
			// Rather than creating an arbitrarily number of actions to
			// perform, an Intercept() function can be registered to
			// traverse a struct normally and receive a pre-visit for
			// the immediate children. We combine Intercept() and Post()
			// to print the closing parenthesis.
			w.WriteString(t.Fn)
			w.WriteString("(")

			comma := ""
			return ctx.Continue().Intercept(func(CalcContext, Calc) (ret CalcDecision) {
				w.WriteString(comma)
				comma = ", "
				return
			}).Post(func(CalcContext, Calc) (ret CalcDecision) {
				w.WriteString(")")
				return
			})

		case *Scalar:
			w.WriteString(strconv.Itoa(t.val))
		}
		return ctx.Continue()
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(w.String())

}

type Calculation struct{ Expr Expr }

type Expr interface {
	Calc
	isExpr()
}

type BinaryOp struct {
	Operator string
	Left     Expr
	Right    Expr
}

func (*BinaryOp) isExpr() {}

type Scalar struct{ val int }

func (*Scalar) isExpr() {}

type Func struct {
	Fn   string
	Args []Expr
}

func (*Func) isExpr() {}

Output:

Avg(1+3, Sum(10, Random(1, 10), 99), 5*3)

This example shows how an error can be returned from a visitor function.

package main

import (
	"errors"
	"fmt"

	"github.com/cockroachdb/walkabout/demo"
)

func main() {
	data, _ := demo.NewContainer(true)
	ret, changed, err := data.WalkTarget(
		func(ctx demo.TargetContext, x demo.Target) demo.TargetDecision {
			return ctx.Error(errors.New("an error"))
		})
	fmt.Println(ret, changed, err)

}

Output:

<nil> false an error

This example demonstrates how pre- and post-visitation works. It also shows how visitation can be short-circuited.

package main

import (
	"fmt"

	"github.com/cockroachdb/walkabout/demo"
)

func main() {
	data, _ := demo.NewContainer(true)
	_, _, err := data.WalkTarget(func(ctx demo.TargetContext, x demo.Target) demo.TargetDecision {
		switch x.(type) {
		case *demo.ContainerType:
			fmt.Println("pre container")
			return ctx.Continue().Post(func(demo.TargetContext, demo.Target) (d demo.TargetDecision) {
				fmt.Println("post container")
				return
			})
		default:
			fmt.Println("halting")
			return ctx.Halt()
		}
	})
	if err != nil {
		panic(err)
	}

}

Output:

pre container
halting
post container

This example demonstrates how copy-on-replace can be implemented for "immutable" datastructures.

package main

import (
	"fmt"

	"github.com/cockroachdb/walkabout/demo"
)

func main() {
	data, _ := demo.NewContainer(true)
	count := 0
	data2, changed, err := data.WalkTarget(
		func(ctx demo.TargetContext, x demo.Target) demo.TargetDecision {
			switch t := x.(type) {
			case *demo.ByRefType:
				count++
				cp := *t
				cp.Val = fmt.Sprintf("ByRef %d", count)
				return ctx.Skip().Replace(&cp)

			case *demo.ByValType:
				count++
				cp := *t
				cp.Val = fmt.Sprintf("ByVal %d", count)
				return ctx.Skip().Replace(&cp)
			default:
				return ctx.Continue()
			}
		})
	if err != nil {
		panic(err)
	}
	fmt.Printf("Changed: %v\n", changed)
	fmt.Printf("data != data2: %v", data != data2)

}

Output:

Changed: true
data != data2: true

This example demonstrates how enhanced visitable types can be visited with a function.

package main

import (
	"fmt"
	"reflect"

	"github.com/cockroachdb/walkabout/demo"
)

func main() {
	data, _ := demo.NewContainer(true)
	var container, byVal, byRef int
	_, _, err := data.WalkTarget(func(ctx demo.TargetContext, x demo.Target) (d demo.TargetDecision) {
		switch x.(type) {
		case *demo.ContainerType:
			container++
		case *demo.ByValType:
			byVal++
		case *demo.ByRefType:
			byRef++
		default:
			return ctx.Error(fmt.Errorf("unknown type %s", reflect.TypeOf(x)))
		}
		return
	})
	if err != nil {
		panic(err)
	}
	fmt.Printf("Saw %d Container, %d ByValType, and %d ByRefType",
		container, byVal, byRef)
}

Output:

Saw 1 Container, 17 ByValType, and 6 ByRefType