FsCheck lazy generators

I have issues with generation of data within my tests.

    testProperty "calculate Operation against different operations should increase major" <| fun  operationIdApi operationIdClient summaryApi summaryClient descriptionApi descriptionClient   -> 
    ( notAllEqual [
            fun () -> assessEquality <| StringEquals(operationIdApi, operationIdClient)
            fun () -> assessEquality <| StringEquals(summaryApi , summaryClient)
            fun () -> assessEquality <| StringEquals(descriptionApi, descriptionClient)
        ]) ==> lazy (
        let operationClient = createOpenApiOperation operationIdClient summaryClient descriptionClient
        let operationAPI = createOpenApiOperation operationIdApi summaryApi descriptionApi
        let actual = calculate operationAPI operationClient
        Expect.equal actual (Fact.Semver.IncreaseMajor) "return IncreaseMajor"
    )

The code that is actually tested is :

 semver {
            if operationAPI.OperationId<> operationClient.OperationId then yield! IncreaseMajor
            if operationAPI.Summary <> operationClient.Summary then yield! IncreaseMajor
        }

The test should fail when the data produced is same OperationId, same summary and different description.
But it does not and it led me to create my own generator or at least try to do so:

I wanted my test to be written like this :

testProperty "calculate Operation against different operations should increase major" <| fun  (operationId:ElementSet<string>)  (summary:ElementSet<string>)   -> 

Therefore I create a type accordingly:

type ElementSet<'a> =
    | Same of 'a
    | Different 

and a generator for this type :

let setGen<'a> =
    Gen.oneof [
            gen { 
                let! v = Arb.generate<'a>
                return Same(v)
            }
            gen { return Different}
    ]

type ElementSetGenerator =
    static member ElementSet() = 
        Arb.fromGen setGen<'a>

do Arb.register<ElementSetGenerator>() |> ignore

I was then trying to extract the data to construct my object :

let createOpenApiOperation operationId summary=
let pi  = OpenApiOperation(OperationId=operationId.Get, Summary=summary.Get)    
pi

The Get method did not exist yet so I was about to implement it by adding a member to my ElementSet<'a>:

type ElementSet<'a> =
    | Same of 'a
    | Different 
    with member this.Get = 
        match this with
            | Same s -> s
            | Different ->  Arb.generate<'a>// some random generation here 

And this is where I am stuck. I would love to get some randomness here when I extract data. I wonder if this is the correct way to do so, or if I should have answered the problem earlier?

Thanks for your inputs.

I think I found it, the answer was to handle it at the beginning :

let setGen<'a when 'a:equality>   =
    Gen.oneof [
            gen { 
                let! v = Arb.generate<'a>
                return Same(v)
            }
            gen { 
                let! x,y  =
                    Arb.generate<'a>
                    |> Gen.two
                    |> Gen.filter (fun (a,b)-> a <> b)

                return Different(x,y)
            }
    ]

and then to use two getter to access the values :

type ElementSet<'a> when 'a:equality=
    | Same of 'a
    | Different of 'a*'a
    with member this.Fst =  match this with | Same s -> s | Different (a, b)->  a
         member this.Snd =  match this with | Same s -> s | Different (a, b)->  b

this way I can access values within my test:

 testProperty "calculate Operation against different operations should increase major" <| fun  (operationId:ElementSet<NonWhiteSpaceString>)  (summary:ElementSet<NonWhiteSpaceString>) (description:ElementSet<NonWhiteSpaceString>)   -> 
  let operationClient = createOpenApiOperation operationId.Fst summary.Fst description.Fst
  let operationAPI = createOpenApiOperation operationId.Snd summary.Snd description.Snd
  let actual = calculate operationAPI operationClient
  Expect.equal actual (Fact.Semver.IncreaseMajor) "return IncreaseMajor"

for the record I then have the creation of my stub as follows :

let createOpenApiOperation (operationId:NonWhiteSpaceString) (summary:NonWhiteSpaceString) (description:NonWhiteSpaceString)=
let pi  = OpenApiOperation(OperationId=operationId.Get, Summary=summary.Get, Description=description.Get)    
pi