Store frequently used strings in object - Scala - string

Question

I would like to store frequently used strings inside an object. On top of this, I would also like to conveniently add a functionality similar to the mkString function's, where if there are two objects of a certain type, they can be appended with a certain character or set of characters.
Here is what I have until now:
import org.scalatest._
class MyKey(val inputValue: String) {
val value = inputValue
def + (otherMyKeys: MyKey): MyKey = {
new MyKey(this.value + "." + otherMyKeys.value)
}
override def toString(): String = this.value.toString
}
object MyKeys {
val SPARK = new MyKey("spark")
val JSON = new MyKey("json")
val TITLE = new MyKey("title")
val URI = new MyKey("uri")
}
class MyKeySpec extends FlatSpec with Matchers {
"MyKey" should "not put a fullstop character when there is only one value" in {
MyKeys.SPARK should not equal("spark")
MyKeys.SPARK.toString() should equal("spark")
}
it should "put a fullstop character between multiple keys" in {
val actual = MyKeys.SPARK + MyKeys.JSON + MyKeys.TITLE + MyKeys.URI
val expected = "spark.json.title.uri"
actual should not equal(expected)
actual.toString() should equal(expected)
}
it should "work even when the same key is repeated multiple times" in {
val actual = MyKeys.SPARK + MyKeys.SPARK + MyKeys.SPARK
val expected = "spark.spark.spark"
actual should not equal(expected)
actual.toString() should equal(expected)
}
}
This solution is elegant in using the "+" function but does not work without a toString. Is there a more elegant solution where I would not even have to use the toString function? The aim is to make a string like "spark.json.spark.spark" as MyKeys.SPARK + MyKey.JSON + MyKey.SPARK + MyKey.SPARK
I can use the mkString function to do the same thing but that, I feel, is not super intuitive. How do I achieve that?

Answer 1

One thing you might do is define an apply() method instead of overriding the toString().
def apply(): String = this.value
Then you get...
MyKeys.SPARK should not equal("spark")
MyKeys.SPARK() should equal("spark")
... etc.
The problem with your design is that anything of type MyKey is, obviously, not a String. It's almost a String, but still needs some catalyst to make the transition, something like .toString() or, as I suggested, the hidden .apply() method.
You could make MyKeys.SPARK a real String, but the + method for String already has a meaning and can't be redefined. If you were OK using a different operator then it could be done.
object MyKeys {
val SPARK = "spark"
val JSON = "json"
val TITLE = "title"
val URI = "uri"
}
implicit class Dotter(str :String) {
def *(append :String) = str + "." + append
}
MyKeys.SPARK * MyKeys.JSON * MyKeys.SPARK //res0: String = spark.json.spark

Answer 2

Have you considered using implicit conversions for this?
class MyKey(val value: String) {
def + (otherMyKeys: MyKey): MyKey = {
new MyKey(this.value + "." + otherMyKeys.value)
}
}
object MyKey {
implicit def myKeyToString(myKey: MyKey): String = myKey.value
}
object MyKeys {
val SPARK = new MyKey("spark")
val JSON = new MyKey("json")
}
val result: String = MyKeys.SPARK + MyKeys.JSON // spark.json