¿Por qué la búsqueda implícita se ve afectada por un parámetro de tipo no relacionado?

Question

Considérese este fragmento simplificado de algunas unidades de funcionalidad de medición en Scala:

object UnitsEx { 
    case class Quantity[M <: MInt, T: Numeric](value: T) { 
    private val num = implicitly[Numeric[T]] 
    def *[M2 <: MInt](m: Quantity[M2, T]) = 
     Quantity[M, T](num.times(value, m.value)) 
    } 

    implicit def measure[T: Numeric](v: T): Quantity[_0, T] = Quantity[_0, T](v) 
    implicit def numericToQuantity[T: Numeric](v: T): QuantityConstructor[T] = 
    new QuantityConstructor[T](v) 

    class QuantityConstructor[T: Numeric](v: T) { 
    def m = Quantity[_1, T](v) 
    } 

    sealed trait MInt 
    final class _0 extends MInt 
    final class _1 extends MInt 
} 

Este ejemplo muestra el uso y el error del compilador consigo actualmente:

import UnitsEx._ 

(1 m) * 1 // Works 
1 * (1 m) // Doesn't work: 
/* 
<console>:1: error: overloaded method value * with alternatives: 
(x: Double)Double <and> 
(x: Float)Float <and> 
(x: Long)Long <and> 
(x: Int)Int <and> 
(x: Char)Int <and> 
(x: Short)Int <and> 
(x: Byte)Int 
cannot be applied to (UnitsEx.Quantity[UnitsEx._1,Int]) 
1 * (1 m) 
^ 
*/ 

Envolver la 1 con measure fijaría la problema, pero ¿por qué no se aplica el alcance implícito?

Si quito el parámetro de tipo M como en el siguiente fragmento de código que empiece a funcionar, aunque no puedo ver cómo ese parámetro está relacionado con el tipo de búsqueda implícita:

object UnitsEx2 { 
    case class Quantity[T: Numeric](value: T) { 
    private val num = implicitly[Numeric[T]] 
    def *(m: Quantity[T]) = Quantity[T](num.times(value, m.value)) 
    } 

    implicit def measure[T: Numeric](v: T): Quantity[T] = Quantity[T](v) 
    implicit def numericToQuantity[T: Numeric](v: T): QuantityConstructor[T] = 
    new QuantityConstructor[T](v) 

    class QuantityConstructor[T: Numeric](v: T) { 
    def m = Quantity[T](v) 
    } 
} 

¿Es esta esperada o una limitación conocida del tipo de verificador?

Answer 1

Si cambia el nombre del operador * a p. Ej. mult luego 1 mult (1 m) funciona en ambos casos. Esto no responde a su pregunta, pero indica en la dirección que tal vez haya alguna interferencia con el operador * fuertemente sobrecargado.