Deal with multiple errors in Pattern Matching F#

I'm trying to deal with multiple Result types in the same match...with statement in F#, being more precise, I'm composing what should be returned if anything is an Error.

When I'm dealing with just one or two Result types it's easy to write the code for each possible outcome, but with each additional item, it starts to get more and more complex. Is there a better way to work with multiple Result types at the same time?

I try to avoid using the "_" wildcard since that could lead into errors crawling into the logic when adding or changing something in the code.

Here's an example:

let validateAppointmentAction =
    match (getAppointmentConfirmation, getAppointmentResult, getDossierResult, getInvoiceResult) with
    | (Ok appointmentConfirmation, Ok appointment, Ok dossier, Ok invoiceOption) ->
        // Some logic that returns AppointmentValidationAction in this case
    | (Error e1, Ok appointment, Ok dossier, Ok (invoiceOption)) -> AppointmentValidationAction.Err e1.Message
    | (Ok appointmentConfirmation, Error e2, Ok dossier, Ok (invoiceOption)) -> AppointmentValidationAction.Err e2.Message
    | (Error e1, Error e2, Ok dossier, Ok (invoiceOption)) -> AppointmentValidationAction.Err $"{e1.Message} and {e2.Message}"
    ...

One way of solving this is to declare an error type that wraps all the different errors that you may expect, and then use the FsToolkit.ErrorHandling library to write a function that either returns the result when everything went well, or a list of errors:

open FsToolkit.ErrorHandling

module ValidateEverything =
    type AppointmentConfirmation = AppointmentConfirmation of string
    type Dossier = Dossier of string
    
    type AppointmentConfirmationE =
        | TooLate
        | TooEarly
       
    type DossierE =
        | DossierNotFound
        | DossierNotValidated
    
    type CommonE =
        | AppointmentConfirmationError of AppointmentConfirmationE
        | DossierError of DossierE
    
    let validateAppointmentAction
        (appointmentConfirmationR : Result<AppointmentConfirmation, AppointmentConfirmationE>)
        (dossierR : Result<Dossier, DossierE>)
        = validation {
           
           let! appointmentConfirmation =
              appointmentConfirmationR
              |> Result.mapError CommonE.AppointmentConfirmationError
           
           and! dossier =
              dossierR
              |> Result.mapError CommonE.DossierError
           
           return appointmentConfirmation, dossier
        }
         

This function returns a:

Validation<(AppointmentConfirmation * Dossier),CommonE>

which is the same as

Result<(AppointmentConfirmation * Dossier),List<CommonE>>.

The and! in front of dossier causes dossierR to be calculated (and added to the list) even if the first let! results in an error being returned.

The mapError statements map the various errors into a union, so that they can have the same type, since in F# lists have to contain values of only one type.