Expose Content of a Discriminated Union Case - f#

Question

I am wondering if there is a good way of exposing the content of a DU case to the DU type itself.
For example:
[<Measure>] type inch
module StructuralShape =
type Plate =
{
Length : float<inch>
Thickness : float<inch>
}
type SingleAngle =
{
VerticalLeg : float<inch>
HorizontalLeg : float<inch>
Thickness : float<inch>
}
type StructuralShape =
| Plate of Plate
| SingleAngle of SingleAngle
let area (ss : StructuralShape) =
match ss with
| Plate pl -> pl.Length * pl.Thickness
| SingleAngle sa ->
(sa.HorizontalLeg + sa.VerticalLeg - sa.Thickness) * sa.Thickness
type StructuralShape with
member ss.Area = area ss
module Test =
open StructuralShape
let myShape = Plate {Length = 2.0<inch>; Thickness = 0.25<inch>}
let area = myShape.Area
// Looking to allow the user of the library
// to access the internal shape properties
// without having to use some type of 'get shape' function
let length = myShape.Length // fails
After a re-look at my design, which was inconsistent as Fyodor pointed out, I decided to create an interface for IShape.
[<Measure>] type inch
type IShape = interface end
module StructuralShapes =
type Plate =
{
Length : float<inch>
Thickness : float<inch>
}
interface IShape
type SingleAngle =
{
VerticalLeg : float<inch>
HorizontalLeg : float<inch>
Thickness : float<inch>
}
interface IShape
let area (shape: IShape) =
match shape with
| :? Plate as pl -> pl.Length * pl.Thickness
| :? SingleAngle as sa ->
(sa.HorizontalLeg + sa.VerticalLeg - sa.Thickness)
* sa.Thickness
| _ -> failwith "Shape not suppported."
type IShape with
member this.Area = area this
Note: For simplicity, this is a simplified version of the library.

Answer 1

It is unclear what you want to achieve here. I suspect you may have inconsistent design in your mind and not realize it.
If your StructuralShape type only ever has one case, then why do you need it at all? Just use Plate instead!
If your StructuralShape type will have more cases, then what happens when the actual value doesn't have a Thickness field?
If your StructuralShape type will have more cases, but all of them are required to have a Thickness field, and that field has the same type and the same meaning for all of them, then a better design would be to "lift" the common fields to the common type, and leave only differences under the DU:
type Plate = { Length: float }
type Foo = { Bar: string }
type StructuralShapeInfo = Plate of Plate | Foo of Foo
type StructuralShape = { Info: StructuralShapeInfo; Thickness: float }
(pardon my choice of Info suffix; I realize it's not the best choice, but I can't come up with a better one without knowing your domain and thinking about it for a while; there are three hard problems in programming: naming stuff and off-by-one errors)

Answer 2

You can augment a discriminated union with members, which is useful for convenient access in cases like this:
type StructuralShape =
| Plate of Plate
member this.Thickness = match this with Plate p -> p.Thickness
If you add any new cases to StructuralShape, then you need to handle the case in the code for this property.
This may be a useful thing to know, but Fyodor makes a very good point in his answer about reorganising your data model so this isn't necessary.