Expr() behave wierdly when disjuction

[ying-jeanne]

Hi,

I am trying to figure out how Expr() works, tested with some snippets:
https://github.com/ying-jeanne/cue_test_cases/blob/bf84db6edba61d3479838967d7445f1775393fc3/main.go

the print is showed:

........ the v expr() is: [*4 | int] and the length is: 1, ops is :
........ the v expr() is: [*4 | int *7 | int] and the length is: 2, ops is : |
........ the v expr() is: [4 7] and the length is: 2, ops is : |

what seems weird is for the case cueObj1, the expr() returned *4 | int as one single element, is that normal and how i can make it return the list of elements like *4 and int with a size of result of 2?

Not important for this issue, but this code would be used as a part of program to check whether we have doubled defaults for all cue object.

Thanks,

[verdverm]

Defaults are confusing, and I'm not expert here, but my hunch is that the evaluator may be seeing this as a type with a default (perhaps as an optimization) rather than as a disjunction. These lines from the spec lead me to this hunch

Expression               Value-default pair      Rules applied
*"tcp" | "udp"           ⟨"tcp"|"udp", "tcp"⟩    M1, D1
string | *"foo"          ⟨string, "foo"⟩         M1, D1

What happens if you add more types or concrete values to the disjunction? (so that it contains more than two expected elements)

[ying-jeanne]

Hi @verdverm,

What we are trying to do is to use CUE to generate Typescript code, see git repo here: https://github.com/grafana/cuetsy

what is happening is that when we have following case:

var cueObj1 string = `
AType: *4 | int
Foo: {
	Baz: AType | *7
}`

The validation would not fail, but in reality, we can't generate two defaults for the value Baz in typescript, because it is not correct. During generation if we meet case like this, an error should be raised instead of silently generating 7 as Baz's default value.

[verdverm]

@ying-jeanne There are not two defaults in this case. Atype concrete value is 4 so Foo.Baz looks like 4 | *7. I also think the default simplifications result in 7, even without Atype. (the rules)

Consider: https://cuelang.org/play/?id=CNU7UjI20Q8#cue@export@cue

a4: *4 | int
a7: *7 | int

b: a4 | *7
c: (*4 | int) | *7

d: a4 | a7
e: (*4 | int) | (*7 | int)

results in:

a4: 4
a7: 7
b:  7
c:  7
d:  4 | 7
e:  4 | 7

[joulaud]

within this snippet

Y: (*"x" | "xx") | (*"x" | "xx")
Z: *(*"x" | "xx") | (*"x" | "xx")

it is really disconcerting to see Y works as I intend it (giving "x" as result) whereas Z does not (not being able to chose between "x" and "xx")

If I try to understand the spec I would think both should equal (at least because of "a|a, *a|a and *a|*a all resolve to a") but even following the rules I would hope to have something like this mechanic:

X: (*"x" | "xx")
Z:  *X | X


X: (*"x" | "xx")
X:  <"x","x"> | <"xx">                      M1
X:  <"x"|"xx", "x">                         D1
Z: *<"x"|"xx", "x"> | <"x"|"xx", "x">       basic substitution
Z: <"x"|"xx","x"> | <"x"|"xx", "x">         M2
Z: <"x"|"xx"|"x"|"xx", "x"|"x">             D2
Z: <"x"|"xx", "x">                          unification
Z: "x"                                      chosing unique default value

[verdverm]

This one is weird too: a: *(1|2)|(1|*2)

a is always the opposite of the mark on the RHS

[verdverm]

@joulaud There definitely looks to be a bug in there

#1317

[myitcv]

Notwithstanding the issues raised in #1317, there also appears to be an issue with cue.Value.Expr() here: #1710