[<RequireQualifiedAccess>]

module UnionEnum =

    open System

    open System.Reflection

    open Microsoft.FSharp.Reflection

​

    let private bindingFlags = BindingFlags.Public ||| BindingFlags.NonPublic

    let getAll<'a when 'a : comparison> () : Set<'a> =

        try

            FSharpType.GetUnionCases(typeof<'a>, bindingFlags)

            |> Seq.map (fun unionCaseInfo -> FSharpValue.MakeUnion(unionCaseInfo, [||], bindingFlags) :?> 'a)

            |> Set.ofSeq

        with

        | :? TargetParameterCountException -> raise <| ArgumentException "Union type must contain only cases without fields."

​

type Flags =

    | FlagA

    | FlagB

    | FlagC

​

// Removed the Set<Flags> type annotation - the compiler now has to infer the type from context.

// getAll returns a Set<_>, so it knows that much for sure - but if you remove the context actually pinning it to a specific type (all the lines after), it'll refuse to compile.

let allFlags : Set<Flags> = (UnionEnum.getAll<Flags> : unit -> Set<Flags>) () : Set<Flags>

​

// The compiler can easily infer flagsA is a Set<Flags>, as there's no ambiguity - FlagA is a literal Flags, the rest just wraps it in containers

let flagsA : Set<Flags> = (set : List<Flags> -> Set<Flags>) ([ (FlagA : Flags) ] : Flags list) : Set<Flags>

printfn "%A" flagsA // set [ FlagA ]

​

// The compiler only knows flagsA is a Set<Flags>, but it can infer that allFlags is a Set<Flags> as set subtraction is only defined for Sets of the same type.

let flagsBC : Set<Flags> = (allFlags : Set<Flags>) - (flagsA : Set<Flags>) : Set<Flags>

printfn "%A" flagsBC // set [ FlagB; FlagC ]

​