I have a case class defined as such:
case class StreetSecondary(designator: String, value: Option[String])
I then define an explicit companion object:
object StreetSecondary {
//empty for now
}
The act of defining the explicit companion object StreetSecondary causes the compiler produced "implicit companion object" to be lost; i.e. replaced with no ability to access the compiler produced version. For example, the tupled
method is available on case class StreetSecondary via this implicit companion object. However, once I define the explicit companion object, the tupled
method is "lost".
So, what do I need to define/add/change to the above StreetSecondary explicit companion object to regain all the functionality lost with the replacement of the compiler provided implicit companion object? And I want more than just the tupled
method restored. I want all functionality (for example, including extractor/unapply
) restored.
Thank you for any direction/guidance you can offer.
UPDATE 1
I have done enough searching to discover several things:
A) The explicit companion object must be defined BEFORE its case class (at least that is the case in the Eclipse Scala-IDE WorkSheet, and the code doesn't work in the IntelliJ IDE's WorkSheet regardless of which comes first).
B) There is a technical trick to force tupled
to work (thank you drstevens): (StreetSecondary.apply _).tupled
While that solves the specific tupled
method problem, it still doesn't accurately or completely describe what the scala compiler is providing in the implicit companion object.
C) Finally, the explicit companion object can be defined to extend a function which matches the signature of the parameters of the primary constructor and returns an instance of the case class. It looks like this:
object StreetSecondary extends ((String, Option[String]) => StreetSecondary) {
//empty for now
}
Again, I am still not confident accurately or completely describes what the scala compiler is providing in the implicit companion object.
Why would you think you are loosing them?
Seems like I still got extractors.
In your case you still got it all:
Scala 2.11.0
It looks like scalac is predefining the
tupled
function when you aren't providing additional functions in the companionresults in the following
When defining an explicit companion object for a case class (as of Scala 2.11), to fully replace the compiler provided functionality in the lost implicit companion object, the basic template for the explicit companion object has two requirements:
Requirements:
1. Must extend a function definition which consists of a tuple (exactly matching the type and order of the case class constructor parameters) returning the type of the case class
2. Must override the toString function to provide the object class name (identical to that of the associated case class)
Here's the original example code for the "empty" explicit companion object:
And here is the example code after implementing the above requirements:
To meet requirement 1 above,
extends ((String, Option[String]) => StreetSecondary)
is inserted right after the object name and before the first curly brace.To meet requirement 2 above,
override def toString = getClass.getName.split("""\$""").reverse.dropWhile(x => {val char = x.take(1).head; !((char == '_') || char.isLetter)}).head
is inserted in the body of the object (the explicit implementation remains questionable)Deep appreciation to @drstevens for his posting the javap output to help me gain confidence the above two steps are all that are required to restore the lost functionality.