Type dependent implicits

Question

Two implicits are needed in the function, but I can't have them in the same parameter list, because I get dependent method type. So I considered currying once more, but that gives me a syntax error. What's the correct way to do this?

def add[A](newAnnotations: Seq[A])
    (implicit maybeAdd: MaybeAdd[L, Seq[A]])
    (implicit mod: Modifier[maybeAdd.Out, Seq[A], Seq[A]]):
    Slab[Content, maybeAdd.Out] = {
  val l = maybeAdd(annotations, Seq[A]())
  l.updateWith(_ ++ newAnnotations)
}

You cannot have implicits in different parameter list. They MUST be placed in the end and together. — goral, Sep 23 '14 at 06:39
You should investigate the `Aux` pattern in shapeless: it arose to solve exactly this problem. — Miles Sabin, Sep 23 '14 at 06:52

score 1 · Accepted Answer · answered Sep 23 '14 at 06:58

I edited MaybeAdd to have an Aux type, as suggested by @milessabin.

def add[A, Out0](newAnnotations: Seq[A])(implicit maybeAdd: MaybeAdd.Aux[L, Seq[A], Out0], mod: Modifier[Out0, Seq[A], Seq[A]]): Slab[Content, mod.Out] = {
  val l = maybeAdd(annotations, Seq[A]())
  new Slab(content, mod(l, _ ++ newAnnotations))
}

score 0 · Answer 2 · edited Jun 20 '20 at 09:12

Note: the syntax error is likely to be:

illegal dependent method type: 
parameter appears in the type of another parameter in the same section or an earlier one

Meaning one cannot use the dependent type in the same section, only in the next parameters block or as a return type only.

See "A short introduction to the Aux pattern" byLuigi.

 type Aux[A0, B0] = Foo[A0] { type B = B0  }

basically Aux is just a way to extract the result of a type level computation

As noted in "Why is the Aux technique required for type-level computations?"

the Aux type aliases are entirely a syntactic convenience.

The Aux version has a couple of advantages over writing out the type refinements in this way: it's less noisy, and it doesn't require us to remember the name of the type member.
These are purely ergonomic issues, though—the Aux aliases make our code a little easier to read and write, but they don't change what we can or can't do with the code in any meaningful way.

Type dependent implicits

2 Answers2