Context bound for varargs

Question

Few days ago I started to learn Cats and I want to implement method appendOptional for Map[String, _: Show].

I started with the following idea:

def appendOptional[T: Show](to: Map[String, String], values: (String, Option[T])*): Map[String, String] = 
    values.foldLeft(values) {
        case (collector, (key, Some(value))) => 
            collector + (key -> implicitly[Show[T]].show(value)) 
        case (collector, _) => collector
    }

And to use it like:

def createProps(initial: Map[String, String], name: Option[String], age: Option[Int])

val initial = Map("one" -> "one", "two" -> "two")
val props = appendOptional(initial, "name" -> name, "age" -> age)

I understand that this approach is quite naive and straightforward because implicitly[Show[T]].show(value) will actually lookup for Show[Any].

Also, I had an idea to accept HList with context bound, but I have not found any example of that.

One more variant is to create a lot of overloaded methods (as it is done in a lot of libraris):

def appendOptional[T1: Show, T2: Show](to: Map[String, String], v1: (String, Option[T1], v2: (String, Option[T2])))

Question: Is there a way to define context bound for varargs functions?

Alexey Romanov · Accepted Answer · 2018-04-14T10:45:33.610

Strictly speaking, the first is the correct way to define the bound; varargs don't mean the type of arguments varies, only their number.

The way to achieve what you want with varying types is more involved and requires packing Show instances together with values. E.g.

case class HasShow[A](x: A)(implicit val ev: Show[A])

def appendOptional(to: Map[String, String], values: (String, Option[HasShow[_]])*): Map[String, String] =     
    values.foldLeft(values) {
        // value.ev.show(value.x)) can be extracted into a method on HasShow as well
        case (collector, (key, Some(value: HasShow[a]))) => 
            collector + (key -> value.ev.show(value.x)) 
        case (collector, _) => collector
    }

val props = appendOptional(initial, "name" -> name.map(HasShow(_)), "age" -> age.map(HasShow(_)))

You can sprinkle some more implicit conversions for HasShow to simplify the call-site, but this way you can see what's going on better.

For this specific case I think a better and simpler solution would be

implicit class MapOp(self: Map[String, String]) extends AnyVal {
    def appendOptional[A: Show](key: String, value: Option[A]) =  
        value.fold(self)(x => self + (key -> Show.show(x)))
}

val props = initial.appendOptional("name", name).appendOptional("age", age)

Thank you for your answer. Yes, you are right, I have already implemented the seconds variant. Although method chaining is simple to implement, the would be a bit of boilerplate code which could be avoided with generic method. Nevertheless, I agree that second approach is simpler and much more maintainable and explicit. — Andrii Abramov, Apr 14 '18 at 10:45
The problem is that the first way has, if anything, more boilerplate code. It is still useful in many situations. — Alexey Romanov, Apr 14 '18 at 10:48

Context bound for varargs

1 Answers1