Getting reference to dependent in service with generic type

may help you . You would like the compiler to consider lexical.Scanner and mylexical.Scanner as equal, based on the fact that at runtime, the value of mylexical and lexical is always the same. This is a run-time property, and the type checker doesn't do any data-flow analysis (that would be way too slow to be practical).
So you need to help the type checker by telling it that the two values are always the same. You can do that by using a singleton type. A singleton type is a type that has exactly one value, and is written as (in this case) lexical.type.

val mylexical: lexical.type = lexical

I hope this helps . You can easily fix the issue by moving the abstract type member to a type parameter like this:

trait Simulator[CM[_]] {
  def useCM(v: CM[_])
}

case class CMH[CM[_]](cm: CM[_])

class SimIterator[S <: Simulator[CM], CM[_]](val sim: S, val cmhs: Seq[CMH[CM]]) {
  cmhs foreach { cmh => sim.useCM(cmh.cm) }
}

case class CMH[CM[_]](cm: CM[_])

trait Cake {
  type CM[_]

  trait Simulator {
    def useCM(v: CM[_])
  }

  class SimIterator[S <: Simulator](val sim: S, val cmhs: Seq[CMH[CM]]) {
    cmhs foreach { cmh => sim.useCM(cmh.cm) }
  }
}

trait Cake {
  type CM[_]

  trait Simulator {
    def useCM(v: CM[_])
  }
}

case class CMH[CM[_]](cm: CM[_])

class SimIteratorBuilder[C <: Cake](val cake: Cake) {
  class SimIterator(val sim: cake.Simulator, val cmhs: Seq[CMH[cake.CM]]) {
    cmhs foreach { cmh => sim.useCM(cmh.cm) }
  }
}

Any of those help You can either ignore the problem and compare a reference to a reference or non-reference to a non-reference:

if modulus == &T::one() {
// Or
if *modulus == T::one() {

impl<T> PowM for T
where
    T: Num + Two + ShrAssign<T> + Rem<T> + PartialOrd<T>,
    for <'a> &'a T: PartialEq<T>,
{
    // ...
}

I hope this helps you . No this is not possible. Generic class level type parameters need to be defined if you wish to use them anywhere inside the class. You are trying to define T0 in terms of ClassA with type parameters that are not part of the ClassB definition so obviously it won't compile.
You could do something like:

ClassB<T0> where T0: ClassA<Int, Int, String> { }

ClassB<T0, T1, T2, T3> where T0: ClassA<T1, T2, T3> { }