Explore type coercion for records.

[cristianoc]

The proposed PR extends type coercion ":>" in ReScript to record types, allowing you to:

• Coerce a mandatory field to an optional one.
• Omit fields in the target type.

Notice you can coerce a type to another identically defined one. This can be useful e.g. with React V4 components, where each one defines its own type for props.

To see an example, we have the following record types:

type r1 = {a: option<int>, b: int}
type r2 = {a?: int, b: int}
type r3 = {a?: int}
type r4 = {}

1. Coerce a mandatory field to an optional one:

let _ = (x: r1) => (x :> r2) // Convert a from mandatory to optional

2. Omit fields in the target type:

let _ = (x: r2) => (x :> r3) // Can omit field
let _ = (x: r1) => (x :> r3) // Omit field and convert from mandatory to optional
let _ = (x: r3) => (x :> r4) // Omit everything

However, you cannot coerce an optional field to a mandatory one, as seen in the commented line:

// let _ = (x: r2) => (x :> r1) can't turn an optional field to a mandatory one

[zth]

Love that the actual added code to support this is just a couple of lines.

A few additional things I thought about:

• when documenting this we should make sure to make explicit that this is just at the runtime level. Meaning coercing a record into a record with fewer fields, all fields from the source records are still present in runtime, but not at the type level
• double check the error messages

[cristianoc]

Perhaps add an explanation of what type coercion is, in the docs. Then just refer to it.

Notice we can also add type coercions for variants now that the runtime representation does not have any surprises (such as special casing when there's only one case with payload).

[cristianoc]

For example you could take a known variant and type coerce into one with an additional unknown case, to be fed into a function that expects unknown as possible input.
Or play the usual subclasses games with Eg 2 vs 3 cases.