Proposal: Allow combining union types

[aleator]

Would it be possible to have an analogue of // for union types? As in, <a:T1 | b:T2 | c:T3> \/ <a:T2 | d:T4 | e:T5> = <a:T2 | b:T2 | c:T3 | d:T4 | e:T5>

The use case I have is something like this

let myLayouts = ... union ...
in let myHandlers = ... handlers for the above ...
in let layouts = constructors (./basicLayouts \/ myLayouts)
in let handlers = ./basicHandlers // myHandlers
in (render handlers) [layouts.foo 1 "x",layouts.bar "x" "x"] 

[Gabriella439]

@aleator: Yeah, this seems reasonable to me. My only suggestion is to use \\// / ⩔ for the symbol for duality with ⩓

[brendanzab]

What happens on a conflict between two variants with differing types?

EDIT: oh, I see - the second on is chosen - it's shown in the initial example as a:T1->a:T2.

[aleator]

One thing that bothers me about using ⩔ is that it wouldn't behave exactly like ⩓, and more like //. I don't see how recursively updating unions would make sense. I might be wrong at this though.

Regarding the name, there isn't a type level // yet, is there? Should there be? If yes, perhaps there is some symmetry of names that could be considered here. For example /// for records and \\\ for unions.

If you'd like, I could take a stab at implementing this.

[aleator]

Just for sake of procrastination, here is a stab at getting the semantics done (confessing that I actually haven't read the dhall semantics before doing this). Since naming is hard, I used the 'plus-in-a-circle' as a stand in.

l ⇥ e
───────────
l ⊕ <> ⇥ e


r ⇥ e
────────────
<> ⊕ r ⇥ e


ls₀ ⇥ < x : l₁ | ls₁… >
rs₀ ⇥ < x : r₁ | rs₁… >
< ls₁… > ⊕ < rs₁… > ⇥ < ts… >
───────────────────────────────
ls₀ ⊕ rs₀ ⇥ < x : r₁ | ts… >


ls₀ ⇥ < x : l₁ | ls₁… >   < ls₁… > ⊕ rs ⇥ < ls₂… >
────────────────────────────────────────────────────  ; x ∉ rs
ls₀ ⊕ rs ⇥ < x : l₁ | ls₂… >


l₀ ⇥ l₁   r₀ ⇥ r₁
─────────────────────   ; If no other rule matches
l₀ ⊕ r₀ ⇥ l₁ ⊕ r₁


and typing

Γ ⊢ l :⇥ Type
l ⇥ < ls… >
Γ ⊢ r :⇥ Type
r ⇥ <>
────────────────
Γ ⊢ l ⊕ r : Type

Γ ⊢ l :⇥ Type
l ⇥ < ls… >
Γ ⊢ r :⇥ Type
r ⇥ < a : A | rs… >
Γ ⊢ { ls… } ⊕ { rs… } : T₁
─────────────────────────────
Γ ⊢ l ⊕ r : Type

Γ ⊢ l :⇥ Kind
l ⇥ < ls… >
Γ ⊢ r :⇥ Kind
r ⇥ < a : A >
────────────────
Γ ⊢ l ⊕ r : Kind

Γ ⊢ l :⇥ Kind
l ⇥ < ls… >
Γ ⊢ r :⇥ Kind
r ⇥ < a : A | rs… >
Γ ⊢ < ls… > ⊕ { rs… } : T
───────────────────────────── 
Γ ⊢ l ⊕ r : Kind

[Gabriella439]

@aleator: Yeah, I like the idea of a type-level analog for // named /// and a dual \\\ for union types

[haitlahcen]

Would definitely be cool to have this feature available !

[jvanbruegge]

Just hit this limitation again with dhall-kubernetes. I want to use cert-manager which defines custom resources. I can normally define dhall types for them and use them, but in order to tie everything together I have one file per service that is a list of the big kubernetes union. The problem: I can't add the cert-manager types to that union without copy+pasting the file from dhall-kubernetes to my own repository. With a union operator, I could simply change my top level union import file from:

let union =
      https://raw.githubusercontent.com/dhall-lang/dhall-kubernetes/master/typesUnion.dhall sha256:8e8db456b218b93f8241d497e54d07214b132523fe84263e6c03496c141a8b18

in  union

to

let union =
      https://raw.githubusercontent.com/dhall-lang/dhall-kubernetes/master/typesUnion.dhall sha256:8e8db456b218b93f8241d497e54d07214b132523fe84263e6c03496c141a8b18

let cert-union = ./cert-manager/union.dhall

in  union \\// cert-union

[sjakobi]

@jvanbruegge I think this proposal mostly needs a volunteer to standardize it.

Would you be interested in being that volunteer?

[jvanbruegge]

Sadly not at the moment, as my spare time is quite limited right now. Most likely not before April

[Gabriella439]

I think we should narrow down this proposal to just standardizing support for \\// / ⩔ for now since I think that will satisfy most use cases.

This came up recently again in: https://discourse.dhall-lang.org/t/sum-type-subsets/219