How to map a sequence of discriminated unions (where all items are of the same case) onto a sequence of items of the type of the case?

Question

I have the following:

type union1 =
    | Case1 of string
    | Case2 of int

let union1s = seq { for i in 1..5 do yield case2 i }

How do I change union1s to a sequence of type seq<int>?

Something like:

let matchCase item =
    match item with
    | Case1 x -> x
    | Case2 x -> x

let case2s = Seq.map matchCase union1s

This attempt does not work because matchCase can not return two different types.

The suggested answers have the same problem (if I understand correctly)

let matchCaseOpt = function
    | Case1 x -> Some x
    | Case2 x -> Some x
    | _ -> None

let case2s = Seq.choose matchCaseOpts unions1s

The expression Some x expects expects type Option string in the match for Case2

I have solved my particular use-case by using a DU of sequences.

type Union1s =
    | Case1s of seq<string>
    | Case2s of seq<int>    

Answer 1

You are assuming your sequence contains not a single case1, so if this is not true you need to throw an exception.

let matchCase item =
    match item with
    | Case1 x -> failwith "Unexpected Case1"
    | Case2 x -> x

let case2s = Seq.map matchCase union1s

An alternative approach, if you are not sure the sequence contains always the same case is to use an Option

let matchCase item =
    match item with
    | Case1 x -> None
    | Case2 x -> Some x

Then it depends on how you will handle these cases, you can just filter out the None values using Seq.choose instead of Seq.map as shown on the other answer.

Which approach to follow depends if you consider having an argument with Case1s an exceptional case or part of the logic of your program. There was a question regarding this F#: Some, None, or Exception? recently.

Using a DU of sequences is correct if you are not mixing Cases, that way your DU Type restrict your domain to the actual cases.