F# "reverse" exhausting match on discriminated unions?

Taking the example of writing a parser-unparser pair for a DU.

The unparser function of course uses match expression, where we can count on static exhaustiveness check if new cases are added later.

Now, for the parsing side, the obvious route is (with eg FParsec) use a choice parser with a list of the DU case parsers. This works, but does not have exhaustiveness checking.

My best solution for this, is to create a DU_Case -> parser function that uses match expression, and using runtime reflection get all DU cases, call the function with them, and pass the so generated list to the choice combinator. This works, and does have static exhaustiveness checking, BUT gets pretty clunky fast, especially if the cases have varying fields.

In other words, is there a good pattern other than using reflection for ensuring exhaustiveness when the discriminated union is the output and not the input?

Edit: example on the reflection based solution

By getting clunky, I mean that for every case that has fields, I have to also create the field values dynamically, instead of the simple Array.zeroCreate(0) which is of course always valid. But what in the else branch? There needs to be code to dynamically create the correct number of field values, with their correct (possibly complex) constructors and so on. Not impossible with reflection, but clunky.

                FSharpType.GetUnionCases duType
                |> Seq.map (fun duCase ->
                    if duCase.GetFields().Length = 0 then
                        let case = FSharpValue.MakeUnion(duCase, Array.zeroCreate(0))
                    else
                        (*...*)