Idiomatic solution preventing unification / Pattern matching on sum-types

[loisch]

Hi,

I've stripped down my use case to the following minimal example with following definition in one file

#rk: {
    CompleteWard: null
} | {
    PartialWard: string
}

I now want to add the orgSyntax field (different file / different team) "pattern matching" on the different cases from the definition of #rk

#rk: {
    orgSyntax!: string
}

#rk: {
    CompleteWard: null
    orgSyntax: "CompleteWard"
} | {
    PartialWard: string
    orgSyntax: "PartialWard"
}

This doesn't work for

example1: #rk
example1: CompleteWard: null

example2: #rk
example2: PartialWard: "TEST"

because

{
    PartialWard: string
    orgSyntax: "PartialWard"
}

can be unified with

{
    CompleteWard: null
}

I've found a solution I'm not quite happy with because I need to repeat all unset fields in all cases

#rk: {
    CompleteWard: null
    PartialWard?: _|_
    orgSyntax: "CompleteWard"
} | {
    PartialWard: string
    CompleteWard?: _|_
    orgSyntax: "PartialWard"
}

What's the best way to define a "function" to obtain the orgSyntax or to extend an existing definition?

[myitcv]

Hi @loisch

because

{
    PartialWard: string
    orgSyntax: "PartialWard"
}

can be unified with

{
    CompleteWard: null
}

Please can you demonstrate what you did here? Because I can't fully reproduce what you describe.

Here's what I did:

! exec cue export x.cue
cmp stderr stderr.golden

-- x.cue --
package x

#rk: {
	orgSyntax!: string
}

#rk: {
	CompleteWard: null
	orgSyntax:    "CompleteWard"
} | {
	PartialWard: string
	orgSyntax:   "PartialWard"
}

[string]: #rk

example1: CompleteWard: null

example2: PartialWard: "TEST"

example3: {
	PartialWard: string
	orgSyntax:   "PartialWard"
}
example3: {
	CompleteWard: null
}
-- stderr.golden --
example3: 2 errors in empty disjunction:
example3.CompleteWard: field not allowed:
    ./x.cue:3:6
    ./x.cue:10:5
    ./x.cue:15:11
    ./x.cue:21:11
    ./x.cue:26:2
example3.PartialWard: field not allowed:
    ./x.cue:3:6
    ./x.cue:7:6
    ./x.cue:15:11
    ./x.cue:22:2
    ./x.cue:25:11

i.e. I can't unify the values you suggested because I get an error.

[loisch]

Thanks for looking into this @myitcv!

I'll first give some context. About 15 years ago we quite unconventionally chose org-mode as a configuration format for our hospital information system written in Haskell and TypeScript. We have many different data-structures / DSLs in different kinds of org-mode files for different subsystems and servers and we're currently generating parts of this complex configuration. As org-mode doesn't have schemas / validation we only do validation when parsing. I'm comparing CUE and Pkl and others as a replacement. I'd like to define our configuration data structure (in this example #rk) in one place. For backwards compatibility with our current system I'd like to define a translation from these data structures to our org-mode format in a different place. In traditional functional programming this would be a function from the data-structure to string. As CUE doesn't have functions I have instead tried to add the orgSyntax attribute to the configuration data-structure using a different definition (possibly in a different file) that can be unified with the definition of the data-structure.

This doesn't work

// UPSTREAM TYPE DEFINITION 
#rk: {
    CompleteWard: null
} | {
    PartialWard: string
}

// UPSTREAM DATA
example1: #rk
example1: CompleteWard: null

example2: #rk
example2: PartialWard: "TEST"


// LEGACY TRANSFORMATION OF UPSTREAM DATA TO ORG-MODE REPRESENTATION
#rk: {
    orgSyntax!: string
}

// Failed attempt to do pattern-matching
#rk: {
    CompleteWard: null
    orgSyntax: "CompleteWard"
} | {
    PartialWard: string
    orgSyntax: "PartialWard"
}

and fails with this error

example1: incomplete value {orgSyntax:"CompleteWard",CompleteWard:null} | {orgSyntax:"PartialWard",CompleteWard:null,PartialWard:string} | {orgSyntax:"CompleteWard",CompleteWard:null,PartialWard:string}
example2: incomplete value {orgSyntax:"PartialWard",PartialWard:"TEST",CompleteWard:null} | {orgSyntax:"CompleteWard",PartialWard:"TEST",CompleteWard:null} | {orgSyntax:"PartialWard",PartialWard:"TEST"}

I understand the reason and I know that I can fix it by instead writing

// UPSTREAM TYPE DEFINITION
#rk: {
    CompleteWard: null
} | {
    PartialWard: string
}

// UPSTREAM DATA
example1: #rk
example1: CompleteWard: null

example2: #rk
example2: PartialWard: "TEST"


// LEGACY TRANSFORMATION OF UPSTREAM DATA TO ORG-MODE REPRESENTATION
#rk: {
    orgSyntax!: string
}

#rk: {
    CompleteWard: null
    PartialWard?: _|_
    orgSyntax: "CompleteWard"
} | {
    PartialWard: string
    CompleteWard?: _|_
    orgSyntax: "PartialWard"
}

but if upstream extends the definition for #rk adding another case like

#rk: {
    CompleteWard: null
} | {
    PartialWard: string
} | { 
    MergedWards: [string]
} 

I have to add one case to my pattern-match AND extend each existing case to not allow unification with the new case. Is there a better way to write the translation matching on the cases defined in the "upstream" configuration?

Here's a more complete example - our real system is much more complex and has even more cases:

import "strings"

#PatSet: {
	PatSet: string
}

#PatSets: {
	PatSets: [string, ...string]
}

#RenderingKind: {
	CompleteWard: null
} | {
	PartialWard: string
} | {
	MixedWard: null | "GroupWard" | "GroupRoom"
} | {
	MergedWardByRoomNumber: [...string]
}

#List: {
	listName:      string
	source:        #PatSet | #PatSets
	renderingKind: #RenderingKind
}

#Lists: [string]: #List

#Config: {
	lists: #Lists
}

config: #Config
config:{
	lists: {
		"KIM-INF": {
			listName: "Trop.-Med. u. Inf. (KIM-INF)"
			source: PatSet:           "KIM-INF"
			renderingKind: MixedWard: "GroupWard"
		}
		"KIM11-KIM-INF": {
			listName: "Infektiologie: KIM Stat. 11"
			source: PatSet:              "KIM11-KIM-INF"
			renderingKind: CompleteWard: null
		}
		"KIM9NEPH+KIM12END": {
			listName: "KIM Stat. 9 (KIM9NEPH + KIM12END)"
			source: PatSets: ["KIM9NEPH", "KIM12END"]
			renderingKind: MergedWardByRoomNumber: ["KIM9NEPH", "KIM12END"]
		}
	}
}

_expected: config.listsOrg
_expected: """
	** KIM-INF
	- listName :: Trop.-Med. u. Inf. (KIM-INF)
	- source :: PatSet "KIM-INF"
	- renderingKind :: MixedWard GroupWard
	** KIM11-KIM-INF
	- listName :: Infektiologie: KIM Stat. 11
	- source :: PatSet "KIM11-KIM-INF"
	- renderingKind :: CompleteWard
	** KIM9NEPH+KIM12END
	- listName :: KIM Stat. 9 (KIM9NEPH + KIM12END)
	- source :: PatSets ["KIM9NEPH","KIM12END"]
	- renderingKind :: MergedWardByRoomNumber HideEmptyBeds ["KIM9NEPH","KIM12END"]
	"""

#RenderingKind: {
	orgSyntax!: string
}

#RenderingKind: {
	CompleteWard:            null
	PartialWard?:            _|_
	MixedWard?:              _|_
	MergedWardByRoomNumber?: _|_
	orgSyntax:               "CompleteWard"
} | {
	PartialWard:             string
	CompleteWard?:           _|_
	MixedWard?:              _|_
	MergedWardByRoomNumber?: _|_
	orgSyntax:               "PartialWard \"\(PartialWard)\""
} | {
	MixedWard:               null
	CompleteWard?:           _|_
	PartialWard?:            _|_
	MergedWardByRoomNumber?: _|_
	orgSyntax:               "MixedWard"
} | {
	MixedWard:               string
	CompleteWard?:           _|_
	PartialWard?:            _|_
	MergedWardByRoomNumber?: _|_
	orgSyntax:               "MixedWard \(MixedWard)"
} | {
	MergedWardByRoomNumber: [...string]
	CompleteWard?: _|_
	PartialWard?:  _|_
	MixedWard?:    _|_
	_xs:           strings.Join(MergedWardByRoomNumber, "\",\"")
	orgSyntax:     "MergedWardByRoomNumber HideEmptyBeds [\"\(_xs)\"]"
}

#PatSet: {
	PatSet:    string
	orgSyntax: "PatSet \"\(PatSet)\""
}

#PatSets: {
	PatSets: [string, ...string]
	_xs:       strings.Join(PatSets, "\",\"")
	orgSyntax: "PatSets [\"\(_xs)\"]"
}

#List: {
	orgSyntax: string
}

#Lists: {
	[KEY=string]: #List & {
		listName:      string
		source:        #PatSet | #PatSets
		renderingKind: #RenderingKind
		orgSyntax:     """
			** \(KEY)
			- listName :: \(listName)
			- source :: \(source.orgSyntax)
			- renderingKind :: \(renderingKind.orgSyntax)
			"""
	}
}
#Config: {
	lists: #Lists
	listsOrg: strings.Join([for x in lists { x.orgSyntax }], "\n")
}

[myitcv]

@loisch thanks for the detailed context. Very interesting!

Reducing down the original declaration of #rk:

#rk: {
	CompleteWard: null
} | {
	PartialWard: string
}

#rk: {
	orgSyntax!: string
}

#rk: {
	CompleteWard: null
	orgSyntax:    "CompleteWard"
} | {
	PartialWard: string
	orgSyntax:   "PartialWard"
}

Using cue eval we can see this results in:

#rk: {
    CompleteWard: null
    orgSyntax:    "CompleteWard"
} | {
    CompleteWard: null
    orgSyntax:    "PartialWard"
    PartialWard:  string
} | {
    PartialWard:  string
    orgSyntax:    "CompleteWard"
    CompleteWard: null
} | {
    PartialWard: string
    orgSyntax:   "PartialWard"
}

This is, I suspect, not what you were expecting. The reason this happens is that the multiple declaration "sites" of #rk are unified together. Hence we in effect have:

#rk: (
{ 
	CompleteWard: null
} | {
	PartialWard: string
}
) & (
{
	orgSyntax!: string
}
) & (
{
	CompleteWard: null
	orgSyntax:    "CompleteWard"
} | {
	PartialWard: string
	orgSyntax:   "PartialWard"
}
)

According to the rules of disjunctions:

The unification of a disjunction with another value is equal to the disjunction composed of the unification of this value with all of the original elements of the disjunction. In other words, unification distributes over disjunction.

this is reduced to the value shown by cue eval.

That said, I suspect you want to build your #rk disjunction a different way. Perhaps something like this (the format used here is testscript-based txtar; allows for multi-file examples):

# x alone
exec cue export x.cue
cmp stdout stdout.x.golden

# x and y
exec cue export x.cue y.cue
cmp stdout stdout.x_and_y.golden

-- x.cue --
package example

#rkParts: {
	completeWard: {
		CompleteWard: null
	}

	partialWard: {
		PartialWard: string
	}
}

#rk: or([for _, v in #rkParts {v}])

examples: [string]: #rk

examples: one: CompleteWard: null

examples: two: PartialWard: "TEST"
-- y.cue --
package example

// Refine to require orgSyntax elsewhere
#rkParts: {
	[string]: {
		orgSyntax!: string
	}

	completeWard: orgSyntax: "CompleteWard"
	partialWard: orgSyntax:  "PartialWard"
}
-- stdout.x.golden --
{
    "examples": {
        "one": {
            "CompleteWard": null
        },
        "two": {
            "PartialWard": "TEST"
        }
    }
}
-- stdout.x_and_y.golden --
{
    "examples": {
        "one": {
            "CompleteWard": null,
            "orgSyntax": "CompleteWard"
        },
        "two": {
            "PartialWard": "TEST",
            "orgSyntax": "PartialWard"
        }
    }
}

Taking your more complete example this gives:

exec cue export x.cue
cmp stdout stdout.golden

-- x.cue --
import "strings"

#PatSet: {
	PatSet: string
}

#PatSets: {
	PatSets: [string, ...string]
}

#RenderingKinds: {
	CompleteWard: {
		CompleteWard: null
	}
	PartialWard: {
		PartialWard: string
	}
	MixedWard: {
		MixedWard: null | "GroupWard" | "GroupRoom"
	}
	MergedWardByRoomNumber: {
		MergedWardByRoomNumber: [...string]
	}
}

#RenderingKind: or([for _, v in #RenderingKinds {v}])

#List: {
	listName:      string
	source:        #PatSet | #PatSets
	renderingKind: #RenderingKind
}

#Lists: [string]: #List

#Config: {
	lists: #Lists
}

config: #Config
config: {
	lists: {
		"KIM-INF": {
			listName: "Trop.-Med. u. Inf. (KIM-INF)"
			source: PatSet:           "KIM-INF"
			renderingKind: MixedWard: "GroupWard"
		}
		"KIM11-KIM-INF": {
			listName: "Infektiologie: KIM Stat. 11"
			source: PatSet:              "KIM11-KIM-INF"
			renderingKind: CompleteWard: null
		}
		"KIM9NEPH+KIM12END": {
			listName: "KIM Stat. 9 (KIM9NEPH + KIM12END)"
			source: PatSets: ["KIM9NEPH", "KIM12END"]
			renderingKind: MergedWardByRoomNumber: ["KIM9NEPH", "KIM12END"]
		}
	}
}

_expected: config.listsOrg
_expected: """
	** KIM-INF
	- listName :: Trop.-Med. u. Inf. (KIM-INF)
	- source :: PatSet "KIM-INF"
	- renderingKind :: MixedWard GroupWard
	** KIM11-KIM-INF
	- listName :: Infektiologie: KIM Stat. 11
	- source :: PatSet "KIM11-KIM-INF"
	- renderingKind :: CompleteWard
	** KIM9NEPH+KIM12END
	- listName :: KIM Stat. 9 (KIM9NEPH + KIM12END)
	- source :: PatSets ["KIM9NEPH","KIM12END"]
	- renderingKind :: MergedWardByRoomNumber HideEmptyBeds ["KIM9NEPH","KIM12END"]
	"""

#RenderingKinds: {
	[string]: orgSyntax!: string
}

#RenderingKinds: {
	CompleteWard: orgSyntax: "CompleteWard"
	PartialWard: {
		PartialWard: _
		orgSyntax:   "PartialWard \"\(PartialWard)\""
	}
	MixedWard: {
		MixedWard: _
		let suffix = [if MixedWard == null {""}, " " + MixedWard][0]
		orgSyntax: "MixedWard" + suffix
	}
	MergedWardByRoomNumber: {
		MergedWardByRoomNumber: [...string]
		let xs = strings.Join(MergedWardByRoomNumber, "\",\"")
		orgSyntax: "MergedWardByRoomNumber HideEmptyBeds [\"\(xs)\"]"
	}
}

#PatSet: {
	PatSet:    string
	orgSyntax: "PatSet \"\(PatSet)\""
}

#PatSets: {
	PatSets: [string, ...string]
	let xs = strings.Join(PatSets, "\",\"")
	orgSyntax: "PatSets [\"\(xs)\"]"
}

#List: {
	orgSyntax: string
}

#Lists: {
	[KEY=string]: #List & {
		listName:      string
		source:        #PatSet | #PatSets
		renderingKind: #RenderingKind
		orgSyntax:     """
			** \(KEY)
			- listName :: \(listName)
			- source :: \(source.orgSyntax)
			- renderingKind :: \(renderingKind.orgSyntax)
			"""
	}
}

#Config: {
	lists: #Lists
	listsOrg: strings.Join([for x in lists {x.orgSyntax}], "\n")
}
-- stdout.golden --
{
    "config": {
        "lists": {
            "KIM-INF": {
                "listName": "Trop.-Med. u. Inf. (KIM-INF)",
                "source": {
                    "PatSet": "KIM-INF",
                    "orgSyntax": "PatSet \"KIM-INF\""
                },
                "renderingKind": {
                    "MixedWard": "GroupWard",
                    "orgSyntax": "MixedWard GroupWard"
                },
                "orgSyntax": "** KIM-INF\n- listName :: Trop.-Med. u. Inf. (KIM-INF)\n- source :: PatSet \"KIM-INF\"\n- renderingKind :: MixedWard GroupWard"
            },
            "KIM11-KIM-INF": {
                "listName": "Infektiologie: KIM Stat. 11",
                "source": {
                    "PatSet": "KIM11-KIM-INF",
                    "orgSyntax": "PatSet \"KIM11-KIM-INF\""
                },
                "renderingKind": {
                    "CompleteWard": null,
                    "orgSyntax": "CompleteWard"
                },
                "orgSyntax": "** KIM11-KIM-INF\n- listName :: Infektiologie: KIM Stat. 11\n- source :: PatSet \"KIM11-KIM-INF\"\n- renderingKind :: CompleteWard"
            },
            "KIM9NEPH+KIM12END": {
                "listName": "KIM Stat. 9 (KIM9NEPH + KIM12END)",
                "source": {
                    "PatSets": [
                        "KIM9NEPH",
                        "KIM12END"
                    ],
                    "orgSyntax": "PatSets [\"KIM9NEPH\",\"KIM12END\"]"
                },
                "renderingKind": {
                    "MergedWardByRoomNumber": [
                        "KIM9NEPH",
                        "KIM12END"
                    ],
                    "orgSyntax": "MergedWardByRoomNumber HideEmptyBeds [\"KIM9NEPH\",\"KIM12END\"]"
                },
                "orgSyntax": "** KIM9NEPH+KIM12END\n- listName :: KIM Stat. 9 (KIM9NEPH + KIM12END)\n- source :: PatSets [\"KIM9NEPH\",\"KIM12END\"]\n- renderingKind :: MergedWardByRoomNumber HideEmptyBeds [\"KIM9NEPH\",\"KIM12END\"]"
            }
        },
        "listsOrg": "** KIM-INF\n- listName :: Trop.-Med. u. Inf. (KIM-INF)\n- source :: PatSet \"KIM-INF\"\n- renderingKind :: MixedWard GroupWard\n** KIM11-KIM-INF\n- listName :: Infektiologie: KIM Stat. 11\n- source :: PatSet \"KIM11-KIM-INF\"\n- renderingKind :: CompleteWard\n** KIM9NEPH+KIM12END\n- listName :: KIM Stat. 9 (KIM9NEPH + KIM12END)\n- source :: PatSets [\"KIM9NEPH\",\"KIM12END\"]\n- renderingKind :: MergedWardByRoomNumber HideEmptyBeds [\"KIM9NEPH\",\"KIM12END\"]"
    }
}

which passes as expected. The modified CUE is edited as minimally as possible to make the diff with your original a small as possible:

--- orig.cue    2025-01-01 09:12:55.625207803 +0000
+++ x.cue       2025-01-01 09:14:07.453003580 +0000
@@ -8,16 +8,23 @@
        PatSets: [string, ...string]
 }

-#RenderingKind: {
-       CompleteWard: null
-} | {
-       PartialWard: string
-} | {
-       MixedWard: null | "GroupWard" | "GroupRoom"
-} | {
-       MergedWardByRoomNumber: [...string]
+#RenderingKinds: {
+       CompleteWard: {
+               CompleteWard: null
+       }
+       PartialWard: {
+               PartialWard: string
+       }
+       MixedWard: {
+               MixedWard: null | "GroupWard" | "GroupRoom"
+       }
+       MergedWardByRoomNumber: {
+               MergedWardByRoomNumber: [...string]
+       }
 }

+#RenderingKind: or([for _, v in #RenderingKinds {v}])
+
 #List: {
        listName:      string
        source:        #PatSet | #PatSets
@@ -67,41 +74,26 @@
        - renderingKind :: MergedWardByRoomNumber HideEmptyBeds ["KIM9NEPH","KIM12END"]
        """

-#RenderingKind: {
-       orgSyntax!: string
+#RenderingKinds: {
+       [string]: orgSyntax!: string
 }

-#RenderingKind: {
-       CompleteWard:            null
-       PartialWard?:            _|_
-       MixedWard?:              _|_
-       MergedWardByRoomNumber?: _|_
-       orgSyntax:               "CompleteWard"
-} | {
-       PartialWard:             string
-       CompleteWard?:           _|_
-       MixedWard?:              _|_
-       MergedWardByRoomNumber?: _|_
-       orgSyntax:               "PartialWard \"\(PartialWard)\""
-} | {
-       MixedWard:               null
-       CompleteWard?:           _|_
-       PartialWard?:            _|_
-       MergedWardByRoomNumber?: _|_
-       orgSyntax:               "MixedWard"
-} | {
-       MixedWard:               string
-       CompleteWard?:           _|_
-       PartialWard?:            _|_
-       MergedWardByRoomNumber?: _|_
-       orgSyntax:               "MixedWard \(MixedWard)"
-} | {
-       MergedWardByRoomNumber: [...string]
-       CompleteWard?: _|_
-       PartialWard?:  _|_
-       MixedWard?:    _|_
-       _xs:           strings.Join(MergedWardByRoomNumber, "\",\"")
-       orgSyntax:     "MergedWardByRoomNumber HideEmptyBeds [\"\(_xs)\"]"
+#RenderingKinds: {
+       CompleteWard: orgSyntax: "CompleteWard"
+       PartialWard: {
+               PartialWard: _
+               orgSyntax:   "PartialWard \"\(PartialWard)\""
+       }
+       MixedWard: {
+               MixedWard: _
+               let suffix = [if MixedWard == null {""}, " " + MixedWard][0]
+               orgSyntax: "MixedWard" + suffix
+       }
+       MergedWardByRoomNumber: {
+               MergedWardByRoomNumber: [...string]
+               let xs = strings.Join(MergedWardByRoomNumber, "\",\"")
+               orgSyntax: "MergedWardByRoomNumber HideEmptyBeds [\"\(xs)\"]"
+       }
 }

 #PatSet: {
@@ -111,8 +103,8 @@

 #PatSets: {
        PatSets: [string, ...string]
-       _xs:       strings.Join(PatSets, "\",\"")
-       orgSyntax: "PatSets [\"\(_xs)\"]"
+       let xs = strings.Join(PatSets, "\",\"")
+       orgSyntax: "PatSets [\"\(xs)\"]"
 }

 #List: {
@@ -132,6 +124,7 @@
                        """
        }
 }
+
 #Config: {
        lists: #Lists
        listsOrg: strings.Join([for x in lists {x.orgSyntax}], "\n")

Hopefully that helps to unblock you?

[loisch]

That's absolutely awesome! Thank you so much! I'll use that approach!

I've tried to read everything on cuelang.org and cuetorials.com and both websites are great learning about syntax and semantics. What I really like about CUE is how a few simple language feature produce such a powerful tool. I couldn't find many examples of how CUE is actually used. It would be great to learn more about best practices, patterns, pitfalls and to have examples how to ist used in the real world. Thank's for replacing my _xs with let xs - review guidelines and "do's" and "don't" would be helpful too.

Thank's a lot for your great support!