Workaround type testing against interface (not supported) or classes with generics (emits warnings)

[MangelMaxime]

Hello,

I wanted to share with you a tips that I found today. In a project of mine, I needed to type test against interface but this is not supported by Fable.

So I decided to use abstract class instead because they are supported.

However, when type testing against classes:

match field.State with
| :? IStandardField<'Values, 'Value, 'Attributes> as standardField ->
    // Do something with standardField

| :? IGenericField<'Values> as genericField ->
    // Do something with genericField

| _ ->
    // Invalid type

Fable generate a warning 'Generic args are ignored in type testing'.

Unfortunately, we cannot suppress this warning, and it is emitted once per compilation. This means that any Fable.Form.Simple.Bulma user will see this warning...

To work around this issue, it possible to dynamically cast the instance:

try
    let standardField = field.State :?> IStandardField<'Values, 'Value, 'Attributes>

    let attributes = standardField.InnerField.Attributes

    let config = ...

    standardField.RenderField config

with _ ->
    try
        let genericField = field.State :?> IGenericField<'Values>

        genericField.RenderField dispatch fieldConfig field

    with _ ->
        // Invalid type

The code above will not generate any warning, and works if we call an API that is specific to
the casted type.

In the case above, InnerField only exists in IStandardField, so if we get an instance of IGenericField,
we will get an exception which then have a chance to handle, and so on.

However, I am not a fan of this approach, as it feels dirty to use exceptions for control flow.

The solution I found, is to use a DU that we get access to via implementing a class IRendererField.

And then, we make the abstract class IStandardField and IGenericField inherit from IRendererField
and specify the type of field renderer they are.

This makes the code feel cleaner, emit no warning and closer to type testing against classes/interfaces.

match field.State with        
| :? IRendererField as rendererField ->

    match rendererField.FieldRendererType with
    | FieldRendererType.Standard ->

        let standardField = field.State :?> IStandardField<'Values, 'Value, 'Attributes>

        let attributes = standardField.InnerField.Attributes

        let config = ...

        standardField.RenderField config

    | FieldRendererType.Generic ->
        let genericField = field.State :?> IGenericField<'Values>

        genericField.RenderField dispatch fieldConfig field

| _ ->
    failwith "Field not implemented, please implement the field `IStandardField<'Values>` or `IGenericField<'Values>`"

This makes the code feel cleaner, emit no warning and closer to type testing against classes/interfaces.

Snippet of the domain use in my application

[<RequireQualifiedAccess>]
type FieldRendererType =
    | Standard
    | Generic

type IRendererField(typ) =
    member _.FieldRendererType : FieldRendererType = typ

[<AbstractClass>]
type IStandardField<'Values, 'Value, 'Attributes when 'Attributes :> Field.IAttributes>() =
    inherit IRendererField(FieldRendererType.Standard)

    abstract RenderField:
        StandardRenderFieldConfig<'Msg, 'Value, 'Attributes> ->
            ReactElement

    abstract InnerField: Field.Field<'Attributes, 'Value, 'Values>

[<AbstractClass>]
type IGenericField<'Values>() =
    inherit IRendererField(FieldRendererType.Generic)

    abstract RenderField:
        Dispatch<'Msg> ->
        Form.View.FieldConfig<'Values, 'Msg> ->
        FilledField<'Values> ->
            ReactElement

I wanted to share this tips I found, as perhaps it can be useful to someone else or the future me 🤣.