Walking CUE Values

[verdverm]

CUE Values have a Walk function (https://pkg.go.dev/cuelang.org/go/[email protected]#Value.Walk)

This function however does not descend into definitions.

What is the recommended way to walk a Value tree across both data and definitions? (custom and AST come to mind as alternatives)

Does it make sense to expand the API to include a function that will walk more of a Value? (using the same Options as Value.Fields())

For reference, tools/flow has the following custom walk function: https://cue.googlesource.com/cue/+/v0.3.0-beta.7/tools/flow/tasks.go#64

[myitcv]

The solution for now (AFAIK) is to use an iterator, per the linked tools/flow example. We could consider expanding/modifying the existing API; that would likely be done as part of the "API revamp". Given the existing solution however, I'd suggest it's not particularly pressing in this case per se. But please say if there's something I'm missing that would suggest otherwise.

[verdverm]

I would agree. Mostly wanted to capture the thought and add it to the nice to haves for later

[verdverm]

While walking CUE values, is it possible to detect "references" like the following, where several values reference or refer to a:

a: "foo"
b: a
c: l: [b]

Is there any API functions in /cue or perhaps the AST/ADT that could be helpful for determining this case? Or do I need to keep a lookup table of some sort?

There seem to be many cases or scenarios for this, maybe the API could be expanded if it does not currently support this?

[myitcv]

Sorry for the delay in replying, @verdverm

I think it depends what kind of semantics you are after when you say "references"

exec go mod tidy
exec go run main.go

-- go.mod --
module mod.com

go 1.16

require cuelang.org/go v0.4.0
-- main.cue --
package x

a: "foo"
b: a
c: l: [b]
-- main.go --
package main

import (
	"fmt"

	"cuelang.org/go/cue"
	"cuelang.org/go/cue/cuecontext"
	"cuelang.org/go/cue/load"
)

func main() {
	ctx := cuecontext.New()
	bps := load.Instances([]string{"."}, nil)
	v := ctx.BuildInstance(bps[0])

	a := v.LookupPath(cue.ParsePath("a"))
	b := v.LookupPath(cue.ParsePath("b"))
	c := v.LookupPath(cue.ParsePath("c"))

	fmt.Printf("a: %v, isReference: %v\n", a, cue.Dereference(a) != a)
	fmt.Printf("b: %v, isReference: %v\n", b, cue.Dereference(b) != b)
	fmt.Printf("c: %v, isReference: %v\n", c, cue.Dereference(c) != c)
}

Yes, c does "reference" a if you squint hard enough... but it very much depends on your definition.

I would probably use cue.Value.Expr() as part of a more involved exploration of "what fields are referenced by this field".

I worry however my rather vague answer might not be much help 😢

[cueckoo]

This discussion has been migrated to cue-lang/cue#862.

For more details about CUE's migration to a new home, please see cue-lang/cue#1078.