Expected behavior when unifying values and writing out their syntax

[brandoshmando]

Hi there! I'm attempting to generate cue primitive values from go code and write out their syntax to a file, but I'm running into some (seemingly) unexpected behavior when actually writing out the values to syntax. In the following simplified example, I'm attempting to generate a pattern for a string field that has a default within a struct.

package main

import (
	"fmt"

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

var pkg string = `
package test

#Object: {...}

#Pattern: {
    pattern: string
    negate: bool | *false
	if negate {
		value: !~pattern
	}
	if !negate {
		value: =~pattern
	}
}

#Default: {
	value: (string | bool | number | [...] | {...}) | *default
	default: string | bool | number | [...] | {...}
}

#String: {
    value: string
} | #Pattern
`

func main() {
	var r cue.Runtime
	inst, _ := r.Compile("", pkg)

	base := inst.LookupDef("#String")
	pattern := base.Fill("^urn:config:[a-z-:]+$", "pattern")
	def := inst.LookupDef("#Default").Fill("urn:config:test", "default")

	unified := pattern.Lookup("value").Unify(def.Lookup("value"))
	fmt.Println(unified)

	out := inst.LookupDef("#Object").Fill(unified, "field1")
	raw, err := format.Node(out.Syntax())
	if err != nil {
		fmt.Println("failed to write syntax: ", err)
		return
	}

	fmt.Println(string(raw))
}

What's interesting is that the unified value that's generated outputs the syntax that I would expect, i.e.

(=~"^urn:config:[a-z-:]+$" | *"urn:config:test")

But once I fill that value into a new struct as field1, the syntax seems to evaluate the raw cue and complete the value with its default, i.e.

{
	field1: "urn:config:test"
	...
}

Instead I'd expect (and was hoping) that the syntax would look like this:

{
	field1: (=~"^urn:config:[a-z-:]+$" | *"urn:config:test")
	...
}

Is this expected behavior and if so, is there a way to prevent the raw cue of the unified value from evaluating to its default?

[myitcv]

It's a little tricky to see exactly what you're looking to do here, so I've tried to express it in terms of pure CUE:

package test

#Object: {...}

#Pattern: {
	pattern: string
	negate:  bool | *false
	if negate {
		value: !~pattern
	}
	if !negate {
		value: =~pattern
	}
}

#Default: {
	value:   (string | bool | number | [...] | {...}) | *default
	default: string | bool | number | [...] | {...}
}

#String: {
	value: string
} | #Pattern

pattern: #String & {
	pattern: "^urn:config:[a-z-:]+$"
}

def: #Default & {
	default: "urn:config:test"
}

unified: pattern.value & def.value

out: #Object & {
	field1: unified
}

And to further confirm, you're looking to use the API to get the value of out.field1, correct?

$ cue eval -e out.field1
"urn:config:test"

Please can you also confirm what version of CUE you are using?

[brandoshmando]

Thanks for getting back to me @myitcv. I'm using version 0.2.2 at the moment. The pure cue you've laid out here is exactly what I'm trying to accomplish. That said, I'm trying to dynamically generate the cue syntax directly from go vs writing it out by hand.

In this case, I'm unifying the pattern value with the default value and trying fill field1 with the unified constraint. But the syntax it generates seems evaluate the constraint down to its concrete value, in this case the default. What I was hoping to achieve was generating syntax that leaves the constraint intact,

This field1: (=~"^urn:config:[a-z-:]+$" | *"urn:config:test") instead of field1: "urn:config:test".

For extra context, this dynamically generated cue syntax will be written to a file which will then be recompiled into a cue instance and used for validating and completing fields of json objects in another program.

[myitcv]

@brandoshmando apologies for the delay in replying to this. If you try with the latest version of CUE I think you will find things are working as you expected:

exec go mod tidy
exec go run main.go
cmp stdout stdout.golden

-- go.mod --
module mod.com

go 1.16

require (
	cuelang.org/go v0.4.0
)
-- main.go --
package main

import (
	"fmt"

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

var pkg string = `
package test

#Object: {...}

#Pattern: {
	pattern: string
	negate:  bool | *false
	if negate {
		value: !~pattern
	}
	if !negate {
		value: =~pattern
	}
}

#Default: {
	value:   (string | bool | number | [...] | {...}) | *default
	default: string | bool | number | [...] | {...}
}

#String: {
	value: string
} | #Pattern
`

func main() {
	ctx := cuecontext.New()
	v := ctx.CompileString(pkg)

	base := v.LookupDef("#String")
	pattern := base.Fill("^urn:config:[a-z-:]+$", "pattern")
	def := v.LookupDef("#Default").Fill("urn:config:test", "default")

	unified := pattern.Lookup("value").Unify(def.Lookup("value"))
	fmt.Println(unified)

	out := v.LookupDef("#Object").Fill(unified, "field1")
	raw, err := format.Node(out.Syntax())
	if err != nil {
		fmt.Println("failed to write syntax: ", err)
		return
	}

	fmt.Println(string(raw))
}
-- stdout.golden --
*"urn:config:test" | =~"^urn:config:[a-z-:]+$"
{
	_#def
	_#def: {
		field1: =~pattern & (string | bool | number | [...] | {
			...
		} | *default)
		...
	}
}

[cueckoo]

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

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