Companion objects benefits of posibility to implement interfaces

Question

Why in Kotlin/Scala companion objects can implements some interfaces, what benefits this can have? When is useful to use this feature?

Answer 1

Because companion objects are objects, objects can implement interfaces (or extend classes), and there is no good reason to disallow it for companion objects in particular.

One common use in Scala is for factories: e.g. Seq, List, Vector etc. companion objects all extend TraversableFactory so you can write code working with a TraversableFactory and pass any of them to construct the type you want. E.g.

def build[CC[X] <: Traversable[X] with GenericTraversableTemplate[X, CC], A](factory: TraversableFactory[CC])(elems: A*) = factory(elems)

// build(List)(1,2,3) == List(1, 2, 3)
// build(Set)(1,2,3) == Set(1, 2, 3)

Similarly, all case class companion objects extend function types.

Answer 2

You use singleton object when you need only one instance of particular class in program.

E.g. Scala's Nil implements List[Nothing]. Rather than every type of list to implement it's particular Nil there is just one of them.

In typeclass pattern, where you have just one implicit object for corresponding implementation.

Also, where you'd create a public static Something in Java, you'd create that in a companion object.

I personally found them useful for implementing an sbt plugin, that renders object Blah extends Renderable to files blah.html. Find more about usefulness here. I had to know that it implements that trait!

Answer 3

You can use companion objects and inheritance for some level of class-lavel or static polymorphism.

Example 1: Factories

Consider an interface

interface Factory<T> {
    fun create(): T
}

Now, we create a class whose companion object implements it

class Foo {
    companion object: Factory<Foo> {
        override fun create() = Foo()
    }
}

Now we can create an extension function for all factories to create and e.g. log the object.

fun <T> Factory<T>.createAndLog(): T {
    val t = create()
    println(t)
    return t
}

Und use it like so

Foo.createAndLog()

Example 2: Queries

Consider a marker interface

interface Queryable<T>

We now have two classes User and Article that represent tables in a database whose companion object implements the interface.

class User(val id: String) {
    companion object: Queryable<User> {}
}

class Article(val authorId: String) {
    companion object: : Queryable<Article> {}
}

We can now define an extension function to create a query from the class

fun <T> Queryable<T>.query() = db.createQuery<T>()

which we can call as

User.query()
//or
Article.query()