F＃是否有可能将歧视的工会价值“上调”为“超集”联盟？

Question

Let's say there are two unions where one is a strict subset of another.

type Superset =
| A of int
| B of string
| C of decimal

type Subset =
| A of int
| B of string

Is it possible to automatically upcast a Subset value to Superset value without resorting to explicit pattern matching? Like this:

let x : Subset = A 1
let y : Superset = x // this won't compile :(

Also it's ideal if Subset type was altered so it's no longer a subset then compiler should complain:

type Subset =
| A of int
| B of string
| D of bool // - no longer a subset of Superset!

I believe it's not possible to do but still worth asking (at least to understand why it's impossible)

WHY I NEED IT

I use this style of set/subset typing extensively in my domain to restrict valid parameters in different states of entities / make invalid states non-representable and find the approach very beneficial, the only downside is very tedious upcasting between subsets.

Answer 1

Sorry, no

Sorry, but this is not possible. Take a look at https://fsharpforfunandprofit.com/posts/fsharp-decompiled/#unions — you'll see that F# compiles discriminated unions to .NET classes, each one separate from each other with no common ancestors (apart from Object , of course). The compiler makes no effort to try to identify subsets or supersets between different DUs. If it did work the way you suggested, it would be a breaking change, because the only way to do this would be to make the subset DU a base class, and the superset class its derived class with an extra property. And that would make the following code change behavior:

type PhoneNumber =
| Valid of string
| Invalid

type EmailAddress =
| Valid of string
| ValidButOutdated of string
| Invalid

let identifyContactInfo (info : obj) =
    // This came from external code we don't control, but it should be contact info
    match (unbox obj) with
    | :? PhoneNumber as phone -> // Do something
    | :? EmailAddress as email -> // Do something

Yes, this is bad code and should be written differently, but it illustrates the point. Under current compiler behavior, if identifyContactInfo gets passed a EmailAddress object, the :? PhoneNumber :? PhoneNumber test will fail and so it will enter the second branch of the match, and treat that object (correctly) as an email address. If the compiler were to guess supersets/subsets based on DU names as you're suggesting here, then PhoneNumber would be considered a subset of EmailAddress and so would become its base class. And then when this function received an EmailAddress object, the :? PhoneNumber :? PhoneNumber test would succeed (because an instance of a derived class can always be cast to the type of its base class). And then the code would enter the first branch of the match expression, and your code might then try to send a text message to an email address.

But wait...

What you're trying to do might be achievable by pulling out the subsets into their own DU category:

type AorB =
| A of int
| B of string

type ABC =
| AorB of AorB
| C of decimal

type ABD =
| AorB of AorB
| D of bool

Then your match expressions for an ABC might look like:

match foo with
| AorB (A num) -> printfn "%d" num
| AorB (B s) -> printfn "%s" s
| C num -> printfn "%M" num

And if you need to pass data between an ABC and an ABD :

let (bar : ABD option) =
    match foo with
    | AorB data -> Some (AorB data)
    | C _ -> None

That's not a huge savings if your subset has only two common cases. But if your subset is a dozen cases or so, being able to pass those dozen around as a unit makes this design attractive.