[<Erase>]
 type OfValueAccessor =
     static member inline create<^T, ^ReturnType when ^T:(member ofValue: ^ReturnType)>(?object: ^T): typekeyof<^T, ^ReturnType> = unbox "ofValue"
     static member inline access<^T, ^ReturnType when ^T:(member ofValue: ^ReturnType)>(object: ^T): ^ReturnType = object.ofValue

Now we can observe usage. If we were to create an untyped ofValue typekeyof by using the unit method call, then the result type will be typekeyof<obj, obj>

Subsequent usage would instantly resolve the type to the object it is used on, but this would invalidate it for usage on other types with the same property.

 type TestObject = {
     ofValue: int
 }
 type TestObject2 = {
     ofValue: string
 }
 let testObject = { TestObject.ofValue = 1 }
 let testObject2 = { TestObject2.ofValue = "1" }

 let ofValueAccessor = OfValueAccessor.create()
 
 // the line below will resolve ofValueAccessor to typekeyof<TestObject, int>
 TypeKeyOf.access ofValueAccessor testObject
 
 // The line before can no longer be used on testObject2, as it is of a different type
 // TypeKeyOf.access ofValueAccessor testObject2

We can also alternatively use the SRTP static method to access the value directly, without restricting the method to a single object type.

 // Both are valid and are resolved by the compiler correctly
 OfValueAccessor.access testObject // int
 OfValueAccessor.access testObject2 // string

srtpMember : Name

Returns: WidgetBuilder<TypeDefn>