Eliminating (non-normalized?) disjunctions

[NReilingh]

I am attempting to use CUE to specify a schema for a fairly permissive data structure. I have defined much of this permissiveness through the use of disjunctions, and I am running into trouble, it seems, because I have assumed that disjunctions will resolve based on completeness, which is not the case.

For a simplified example, I have a top-level field which is can be a single type or a list of one or more of this type. The type is then defined as a disjunction of two different struct types which have overlapping but not identical fields:

topField: [#FieldType, ...#FieldType] | #FieldType

#FieldType: #TypeA | #TypeB

#TypeA: {
    commonField: string
    uniqueField: string
    type: "A" // for illustration
}

#TypeB: {
    commonField: string
    type: "B" // for illustration
}

topField: {
    commonField: "foo"
    // uniqueField: "bar" // (un)comment to switch types
}

At this point, topField is considered incomplete, because it resolves to {commonField:"foo",uniqueField:string,type:"A"} | {commonField:"foo",type:"B"}

The #TypeA side of the disjunction is not eliminated because it is still a valid cue value. In order for it to be eliminated, it would have to resolve to _|_.

I can work around this somewhat by preferencing #TypeB in the disjunction:

topField: [#FieldType, ...#FieldType] | #FieldType

#FieldType: #TypeA | *#TypeB

#TypeA: {
    commonField: string
    uniqueField: string
    type: "A" // for illustration
    ...
}

#TypeB: {
    commonField: string
    type: "B" // for illustration
    ...
}

topField: {
    commonField: "foo"
    uniqueField: "bar" // (un)comment to switch types
}

This will work so long as I only have two options in the disjunction, but it doesn't help if I want the types to be open -- then #TypeB will always be selected, as it is above.

I have made a semi-successful attempt at solving this by explicitly defining some logic based on the existence of uniqueField, as follows:

topField: #FieldType & {
    if topField.uniqueField != _|_ {
        type: "A"
    }
}

#FieldType: #TypeA | *#TypeB

#TypeA: {
    commonField: string
    uniqueField: string
    type: "A"
    ...
}

#TypeB: {
    commonField: string
    type: "B"
    ...
}

topField: {
    commonField: "foo"
    uniqueField: "bar" // (un)comment to switch types
}

What this tries to do is force a type: "A" & type: "B" conflict that eliminates #TypeB from the disjunction when the uniqueField exists on topField. I could make this invisible on export by using the _type underscore convention.

However, this is very inflexible, as it relies on a direct reference to topField and I want this logic to be "built in" to #FieldType, so I can use the [#FieldType, ...#FieldType] | #FieldType form in my first example. It is also still awkward to use the preference mark *, but there doesn't seem to be a different way to eliminate the #TypeA side of the disjunction, as topField.uniqueField == _|_ does not appear to ever return true.

I think ideally what I would be looking for is something that could be applied directly to the #FieldType definition, like #FieldType: concreteof(#TypeA | #TypeB), or

#FieldType: (#TypeA | #TypeB) & {
    if [this].uniqueField != _|_ {
        type: "A"
    }
    if [this].uniqueField == _|_ {
        type: "B"
    }
}

-- but I don't think this is supported by the language at this time.

My fallback option is to forego this level of specificity in the schema and just use a single type with an optional uniqueField, instead of having #TypeA, #TypeB, and the disjunction at all. My sense is that disjunctions are better used when they can be considered "normalized", which seems in practice to mean that all of the options are of different non-struct types, or of structs with no possibility of "overlap" either by virtue of being open or by containing the same fields.

[mpvl]

Maybe one of these tricks helps:

• if you don't put ... in the structs, uniqueField will not be allowed in the other and the tie is broken as well.
• You can use multiple preference marks.
• Although I would consider this bad style, you could use cascading defaults: *a | (*b | (*c | d)) or something of that nature.
• As optional fields are allowed to be errors, you could also write:

#FieldType:  {
    uniqueField?:  _|_ // an error if defined
        type: "A"
} | {
    uniqueField: string
}

[NReilingh]

Wow, that last option seems to be just what I needed in this case -- though I also needed to combine it with cascading defaults. I had assumed that something like ***a | **b | *c | d would work, but I needed to do *(*(*a | b) | c) | d.

[cueckoo]

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

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