// I'm building a UI library. There are different elements (buttons, images, ...) with different properties.

// However, not all properties are supported by all elements. I want to use the type system to enforce that

// only valid properties are set when constructing elements.

​

// I try to avoid interfaces as much as possible, I'm using them only to encode the set of valid properties

// on an element type, like so:

type IElement = interface end

type IButton = inherit IElement

type IImage = inherit IElement

​

// "Button constructor": Given a list of property assignments, produces a button instance (just unit here).

// A property assignment is a function ('t -> unit) -- this allows us to specify assignments of

// IButton properties as well as IElement properties, because IButton is a subtype of IElement, hence

// IElement -> unit is a subtype of IButton -> unit (contravariance).

// IImage properties, for example, are disallowed since IButton is not a subtype of IImage.

let createButton (props: (IButton -> unit) list) = ()

​

// In my initial design, properties are objects of type Property<'a, 't> where 'a is the property value type

// and 't is the "target type", i.e. specifies on which elements the property is valid.

// With the custom operator @= we can produce property assignments using the syntax "Property @= value".

module InitialApiDesign =

    type Property<'a, 't>() =

        static member (@=) (prop: Property<'a, 't>, value: 'a) =

            fun (_: 't) -> ()

​

    let Width = Unchecked.defaultof<Property<float, IElement>>

    let Height = Unchecked.defaultof<Property<float, IElement>>

    let IsEnabled = Unchecked.defaultof<Property<bool, IButton>>

    let ImageSource = Unchecked.defaultof<Property<string, IImage>>

​

    let ui =

        createButton [

            IsEnabled @= false           // IButton -> unit (OK, as expected)

            ImageSource @= "x.png"       // IImage -> unit (Error, as expected)

            Width @= 20.0                // IElement -> unit (Error, NOT expected! Why no auto-upcasting here?)

            (let z = Width @= 20.0 in z) // IElement -> unit (This works, but why?)

        ]

​

// In this alternative design, there's no Property type with custom operator.

// Instead, the properties are functions themselves:

// So syntactically an assignment is now 'Width 20.0' instead of 'Width @= 20.0'.

//

// Observe that property assignments are still of type ('t -> unit), but the compiler behaves differently:

// Here, IElement -> unit is automatically upcast to IButton -> unit to match the expected list type.

module AlternativeApiDesign =

    let Width (_: float) (_: IElement) = ()

    let Height (_: float) (_: IElement) = ()

    let IsEnabled (_: bool) (_: IButton) = ()

    let ImageSource (_: string) (_: IImage) = ()

​

    let ui =

        createButton [

            IsEnabled false      // IButton -> unit (OK, as expected)

            ImageSource "x.png"  // IImage -> unit (Error, as expected)

            Width 20.0           // IElement -> unit (OK, as expected)

        ]