makeImplicitConversion performs the heavier lifting to get the implicit listing: - for each possible conversion function (also called view) * figures out the final result of the view (to what is our class transformed?) * figures out the necessary constraints on the type parameters (such as T <: Int) and the context (such as Numeric[T]) * lists all inherited members

What? in details:

• say we start from a class A[T1, T2, T3, T4]
• we have an implicit function (view) in scope: def enrichA[T3 <: Long, T4](a: A[Int, Foo[Bar[X]], T3, T4])(implicit ev1: TypeTag[T4], ev2: Numeric[T4]): EnrichedA
• A is converted to EnrichedA ONLY if a couple of constraints are satisfied: * T1 must be equal to Int * T2 must be equal to Foo[Bar[X]] * T3 must be upper bounded by Long * there must be evidence of Numeric[T4] and a TypeTag[T4] within scope
• the final type is EnrichedA and A therefore inherits a couple of members from enrichA

How? some notes:

• Scala's type inference will want to solve all type parameters down to actual types, but we only want constraints to maintain generality
• therefore, allViewsFrom wraps type parameters into "untouchable" type variables that only gather constraints, but are never solved down to a type
• these must be reverted back to the type parameters and the constraints must be extracted and simplified (this is done by the uniteConstraints and boundedTParamsConstraints. Be sure to check them out
• we also need to transform implicit parameters in the view's signature into constraints, such that Numeric[T4] appears as a constraint

Make the implicit conversion objects

A word about the scope of the implicit conversions: currently we look at a very basic context composed of the default Scala imports (Predef._ for example) and the companion object of the current class, if one exists. In the future we might want to extend this to more complex scopes.

Computes the shadowing table for all the members in the implicit conversions

removeImplicitParameters transforms implicit parameters from the view result type into constraints and returns the simplified type of the view

for the example view: implicit def enrichMyClass[T](a: MyClass[T])(implicit ev: Numeric[T]): EnrichedMyClass[T] the implicit view result type is: (a: MyClass[T])(implicit ev: Numeric[T]): EnrichedMyClass[T] and the simplified type will be: MyClass[T] => EnrichedMyClass[T]

uniteConstraints takes a TypeConstraint instance and simplifies the constraints inside

Normally TypeConstraint contains multiple lower and upper bounds, and we want to reduce this to a lower and an upper bound. Here are a couple of catches we need to be aware of:

• before finding a view (implicit method in scope that maps class A[T1,T2,.. Tn] to something else) the type parameters are transformed into "untouchable" type variables so that type inference does not attempt to fully solve them down to a type but rather constrains them on both sides just enough for the view to be applicable -- now, we want to transform those type variables back to the original type parameters
• some of the bounds fail type inference and therefore refer to Nothing => when performing unification (lub, glb) they start looking ugly => we (unsoundly) transform Nothing to WildcardType so we fool the unification algorithms into thinking there's nothing there
• we don't want the wildcard types surviving the unification so we replace them back to Nothings