scala: override implicit parameter to constructor

Question

I have a class that takes an implicit parameter which is used by functions called inside class methods. I want to be able to either override that implicit parameter, or alternatively, have the implicit argument be copied from its source. As an example:

def someMethod()(implicit p: List[Int]) {
  // uses p
}

class A()(implicit x: List[Int]) {

  implicit val other = List(3) // doesn't compile

  def go() { // don't want to put implicit inside here since subclasses that override go() have to duplicate that
    someMethod()
  }
}

The behavior I want is that someMethod() gets an implicit parameter that is some changed version of x, which was the class's implicit parameter. I want to be able to either mutate x without changing it for whatever passed it into A's constructor, or otherwise override it to a new value of my choosing. Both approaches don't seem to work. That is, it doesn't copy the list in the former case, and the compiler finds an ambiguous implicit value for the latter case. Is there a way to do this?

I realize that I can redefine the implicit value within go(), but this is not a good choice in my case because this class is subclassed numerous times, and I'd like to handle this implicit change in the base class only. So it doesn't necessarily need to go in the constructor, but it must be in a method other than go().

This looks like you're rapidly heading into the territory of unmaintainable code. What's your logic here in wanting an implicit for the parameter on someMethod? Why not just make it an explicit param? — Kevin Wright
– Kevin Wright, Commented May 11, 2011 at 10:45
@Kevin In my particular case there are thousands of subclasses like A and thousands of times they're constructed. It's convenient to not have to pass the same parameter to every one. Why do you say it's unmaintainable? — Heinrich Schmetterling
– Heinrich Schmetterling, Commented May 11, 2011 at 20:41
When trying to reason about your code, if you see a particular implicit of some type in scope, then it's natural to expect that the an implicit of the same type deeper in the call stack will be the same instance. If this assumption is false then it could make debugging very difficult for someone who isn't aware of the change. — Kevin Wright
– Kevin Wright, Commented May 12, 2011 at 11:24

Kevin Wright · Accepted Answer · 2011-05-12 11:31:18Z

8

Introduce another wrapper type, simply to disambiguate:

//  badly named, choose something domain-specific
case class ListHolder(theList: List[Int])

def someMethod()(implicit holder: ListHolder) {
  val xs = holder.theList
  // uses xs ...
}

class A()(implicit xs: List[Int]) {

  implicit val other = ListHolder(42 :: xs) // compiles

  def go() {
    // xs is never considered for the implicit param to someMethod()
    // because it's now the wrong type
  }
}

This also makes the code more self-documenting, as it becomes blindingly obvious that the two implicits are not one and the same.

answered May 12, 2011 at 11:31

Kevin Wright

49.7k9 gold badges107 silver badges156 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Rex Kerr · Accepted Answer · 2011-05-11 15:04:38Z

If you want to have zillions of implicits floating around that don't collide with each other, you can create a wrapper class that you can tag with marker traits for implicit usage. There are a variety of syntaxes you could use; here's one example:

object Example {
  class Implication[A,B](val value: A) {
    def apply[C](c: C) = new Implication[C,B](c)
  }
  object Implication {
    def mark[B] = new Implication[Unit,B](())
    implicit def implication_to_value[A,B](i: Implication[A,B]) = i.value
  }

  trait One {}
  trait Two {}
  implicit val x = Implication.mark[One]("Hello")
  implicit val y = Implication.mark[Two]("Hi")

  def testOne(implicit s: Implication[String,One]) = println(s: String)
  def testTwo(implicit s: Implication[String,Two]) = println(s: String)
  def testThree(s: String) = println("String is " + s)

  def main(args: Array[String]) {
    testOne
    testTwo
    testThree(x)
    testThree(y)
  }
}

Which works as you would hope:

scala> Example.main(Array())
Hello
Hi
String is Hello
String is Hi

Since you have to use a wrapper object, it's not super-efficient, but it can be very effective. (Or very confusing, given how much happens implicitly.)

Antonin Brettsnajdr · Accepted Answer · 2011-05-11 09:58:58Z

0

This modification compiles. I changed x into a var:

class A()(implicit var x: List[Int]) {

  def someMethod()(implicit p: List[Int]) {
    // uses p
  }

  x = List(3) 

  def go() { // don't want to put implicit inside here since subclasses that override go() have to duplicate that
    someMethod()
  }
}

answered May 11, 2011 at 9:58

Antonin Brettsnajdr

4,1432 gold badges22 silver badges14 bronze badges

Collectives™ on Stack Overflow

scala: override implicit parameter to constructor

3 Answers 3

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related