Compartiendo un tipo de tupla en una unión discriminada.

Supongamos que tenemos

type MyTuples =
    | One of a: string * b: string * c: string
    | Two of a: string * b: string * c: string * d: string
    | Three of a: string * b: string * c: string * e: string * f: int

¿No sería posible compartir a: string * b: string * c: string entre los casos de la DU?

Quizás de esta manera:

type MyOne = One of a: string * b: string * c: string // la DU de caso único

type MySharingTuples =
    | One of MyOne
    | Two of MyOne * d: string
    | Three of MyOne * e: string * f: int

let myTwo = MyTuples.Two (a = "1", b = "2", c = "3", d = "4")

let mySharingTwo = MySharingTuples.Two (MyOne.One (a = "1", b = "2", c = "3"), d = "4")

myTwo |> printfn "%A"
mySharingTwo |> printfn "%A"

lo cual imprime

Two ("1", "2", "3", "4")
Two (One ("1", "2", "3"), "4")

Desde una perspectiva de teoría de tipos, myTwo y mySharingTwo no son iguales y el compilador ni siquiera nos permitirá demostrar eso en tiempo de ejecución. Pero desde una perspectiva de teoría de conjuntos, Two ("1", "2", "3", "4") y Two (One ("1", "2", "3"), "4") se ven como:

("1", "2", "3", "4") = (("1", "2", "3"), "4")

lo cual me dicen mis viejos libros de matemáticas que hay equivalencia ahí arriba.

¿Viola MyTuples el principio DRY? ¿Hay alguna manera de mostrar que, por ejemplo, MyOne es equivalente a MyTuples.One? ¿Esta investigación tiene algún sentido? ¿Estoy mezclando teoría de tipos y teoría de conjuntos aquí y confundiéndome?