public class A {
    @Inject
    public A(B b, C c) {
        this.b = b;
        this.c = c;
    }
}

public class B {
    @Inject
    public B(D d) {
        this.d = d;
    }
}

public class C {
    @Inject
    public C(D d) {
        this.d = d;
    }
}

public class D { /* ... */ }

A a = injector.createInstance(A.class);

case class A(implicit b: B, c: C)
case class B(implicit d: D)
case class C(implicit d: D)
class D { /* ... */ }

implicit val theD = new D
implicit val theB = B()
implicit val theC = C()

val a = A()

class A {
  self: B with C =>
}

trait B {
  self: D =>
}

trait C {
  self: D =>
}

trait D {}

val x = new A with BImpl with CImpl with DImpl

val x = new A

class A {
  self: B with C =>

  def sum = tripleD + doubleD
}

trait B {
  self: D =>

  def tripleD = x * 3
}

trait C {
  self: D =>

  def doubleD = x * 2
}

trait D extends B with C {
  val x: Int
}

trait E extends D {
  val x = 3
}

trait F extends D {
  val x = 4
}

val a = new A with E
val b = new A with F

println("a.sum = " + a.sum)
println("b.sum = " + b.sum)