Question regarding type-coercion-constraints

[16-Bit-Dog]

I have a question regarding the desired implementation for type-coercion-constraints (TypeCoercionConstraintDecl and related).

From what I understand, there are a few potential approaches to implement this constraint (that comes to mind for me), but I am not exactly sure on the original intent for this feature:

1. make a TypeCoercionConstraintDecl a wrapper for a GenericTypeConstraintDecl with the super-type of (a new magic type called) CoerceTo<T>. Existing machinery will handle the rest of the logic.
   • What would CoerceTo<T> look like?
     • interface CoerceTo<T> { __init(T arg); }
   • Cons: existing code will not function unless all declarations are updated with a (potentially very-very big) list of new conformance's
2. automatically add conformance's (CoerceTo<T>) to all structs with a type __init(T arg). Then when building our InheritanceInfo via getInheritanceInfo we would only need to insert a Facet for CoerceTo<T> if we find a TypeCoercionConstraintDecl in our getDependentGenericParent. Existing machinery will handle the rest of the logic.
   • Cons: automatically inserting conformance's sounds expensive and 'hacky'
3. TypeCoercionConstraintDecl is a new type of constraint that effectively just checks for a members presence.
   • Example
     • where T __contains_member getFuncTypeAndName<TR, each TP>(String nameOfFunction)
       • where T __contains_member getFuncTypeAndName<T>("__init")
   • Cons(?): this is not a c++ style template, but it certainly is moving in that direction

[csyonghe]

The reason we need this constraint is to simply the standard library definition of vectors, such that we can define a single implicit vector<T, N>.__init(vector<U, N>) if U is coerceable to U, instead of having to duplicate this a lot of times.

Type coercion currently has more rules than just look for existence of an implicit __init, as you can see in _coerce() function. Therefore, the implementation of type coercion constraint has to be its own decl, verified by calling coerce() in the frontend. The frontend will need to synthesize a TypeCoercionWitness(From, To) which basically wraps a (maybe synthesized) function that takes From and returns To.