companion-object

What is the difference between an object and a companion object in a class in kotlin? Example: class MyClass { object Holder { //something } companion object { //something } } I already read that companion object shall be used, if the containing parameters/methods are closely related to its class. But why is there also the possibility of declaring a normal object in the class? Because it behaves exactly like the companion, but it must have a name. Is there maybe a difference in its "static" (I'm from the java side) lifecycle? Objects can implement interfaces. Inside a class, defining a simple

I am looking at Akka related typesafe activator code and the following construct intrigued me: Companion object: object MarkerActor { sealed trait MarkerMessage case object Stop extends MarkerMessage .. def objectMethod = print("hi from companion object") } Companion class: it imports the companion object methods: class MarkerActor extends Actor with ActorLogging { import MarkerActor._ // Comment this line to compare w or w/o import available objectMethod // just to see if 'visible' within companion class override def receive = { case Stop => { So.. that is a bit surprising. Why is there not a

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,

I'd like to add implicit conversions to Java classes generated by a modeling tool. So I want to add them to the companion object of those classes, so that the compiler automatically finds them. But I cannot add them in a separate file, because the companion has to be defined in the same file. Is there anything I can do about this? Of course, I can define all my implicit conversions in another object and then bring it into scope, but this requires an extra import. Any other solution? With the Scala compiler as it stands now there is no way to define companion objects other than by putting them

When you create a case class, the compiler creates a corresponding companion object with a few of the case class goodies: an apply factory method matching the primary constructor, equals , hashCode , and copy . Somewhat oddly, this generated object extends FunctionN. scala> case class A(a: Int) defined class A scala> A: (Int => A) res0: (Int) => A = <function1> This is only the case if: There is no manually defined companion object There is exactly one parameter list There are no type arguments The case class isn't abstract. Seems like this was added about two years ago. The latest incarnation

I am kind of blocked with the following ( macro annotation ) situation. Suppose I have an annotation called @factory which aims to generate an apply method for the annotated trait in the corresponding companion object. For instance, given the trait A : @factory trait A { val a1: Int } the expected code to be generated is the following one: object A extends Factory[A] { def apply(_a1: Int) = new A { val a1 = _a1 } } Now suppose we have a trait B which inherits from A : @factory trait B extends A { val b1: String } which is supposed to generate: object B extends Factory[B] { def apply(_a1: Int,