How to extract values from an array definition

[gamma-khan]

Hi! I'm struggling to figure out how I can extract the text values "foo, FOO, bar, BAR" from this definition in Go.

I've muddled with using Eval and Expr however I end up with a value printing [..."foo" | "FOO" | "bar" | "BAR"] but cannot break it down further :(

#FOO: "foo" | "FOO"
#BAR: "bar" | "BAR"
#def:{ foobar:[ ... #FOO | #BAR] }

package main

import (
	"fmt"

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

func main() {

	ctx := cuecontext.New()

	cueString := `
	#def:{ foobar:[ ... #FOO | #BAR] }
	#FOO: "foo" | "FOO"
	#BAR: "bar" | "BAR"
	`
	v := ctx.CompileString(cueString)

	field := v.LookupPath(cue.MakePath(cue.Def("def"), cue.Str("foobar")))

	fmt.Println(field) // [..."foo" | "FOO" | "bar" | "BAR"]

	_, _fields := field.Eval().Expr()
	fmt.Println(_fields[0]) // [..."foo" | "FOO" | "bar" | "BAR"]

}

Could someone help me figure this out please :)

[myitcv]

This should do the trick:

go mod tidy
go run .
cmp stdout stdout.golden

-- go.mod --
module example

go 1.21.3

require cuelang.org/go v0.6.0

-- main.go --
package main

import (
	"fmt"
	"log"

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

func main() {

	ctx := cuecontext.New()

	cueString := `
	#def:{ foobar:[ ... #FOO | #BAR] }
	#FOO: "foo" | "FOO"
	#BAR: "bar" | "BAR"
	`
	v := ctx.CompileString(cueString)

	// The use of cue.AnyIndex "selects" the constraint
	field := v.LookupPath(cue.MakePath(cue.Def("def"), cue.Str("foobar"), cue.AnyIndex))

	var disjunctionElements []cue.Value
	var work cue.Value
	todo := []cue.Value{field}
	for len(todo) > 0 {
		work, todo = todo[0], todo[1:]
		work = cue.Dereference(work) // TODO: appears to be a bug that this is required
		op, values := work.Expr()
		switch op {
		case cue.NoOp:
			// We have an element in the disjunction
			disjunctionElements = append(disjunctionElements, values...)
		case cue.OrOp:
			// We need to break down the "element" more
			todo = append(todo, values...)
		default:
			log.Fatalf("unexpected op: %#v", op)
		}
	}
	fmt.Printf("%#v", disjunctionElements)
}
-- stdout.golden --
[]cue.Value{"foo", "FOO", "bar", "BAR"}

I've left comments on the important bits.

And I've raised #2711 to answer where the cue.Dereference() that I noted is required.

[gamma-khan]

Thank you so much for this! I don't get the mechanics behind Cue all that much, so I was blindly bashing my head against the docs - clearly missed anything on constraints and "indexes".

My definition has a changed a tad, into this #def:{ foobar: [...#FOO] | [...#BAR] } but I've managed to work your solution into it.. I'm assuming using AnyIndex returns bar | BAR because that's the top (?) value in the lattice?

I don't really understand too well what the functions all do, however I found that if I did v.Eval().Expr(), I didn't get that NodeLink bug you discovered, not sure what that means but hope it's worth something 😄

[myitcv]

I'm assuming using AnyIndex returns bar | BAR because that's the top (?) value in the lattice?

AnyIndex allows you to examine the constraint for a list of zero or more elements. Because it's entirely possible to declare a list with:

l: [int, ...string]

In which case you know there will be at least one element.

AnyIndex is useful where there is a constraint that applies if elements are present (but there might not be, and yet you still want to get the constraint).

One question to ask is whether you need to go to the extent of jumping through these hoops to extract the constraint. Do you control the CUE you are examining? If so, you could extract the constraint from the list to a different field and reference that.

#listElement: string | int
#list: [...#listElement]

Granted you might not control the CUE in your case.

[gamma-khan]

Thank you for explaining!

That's a great idea, I didn't think to do so haha. It evaluates the expression and so gives the concrete values as I was looking for...simple! 😄