How to qualify methods as static in Scala?

Question

I have a class

class MyClass {
  def apply(myRDD: RDD[String]) {
      val rdd2 = myRDD.map(myString => {
          // do String manipulation
      }
  }

}

object MyClass {

}

Since I have a block of code performing one task (the area that says "do String manipulation"), I thought I should break it out into it's own method. Since the method is not changing the state of the class, I thought I should make it a static method.

How do I do that?

I thought that you can just pop a method inside the companion object and it would be available as a static class, like this:

object MyClass {
  def doStringManipulation(myString: String) = {
    // do String manipulation
  }
}

but when I try val rdd2 = myRDD.map(myString => { doStringManipulation(myString)}), scala doesn't recognize the method and it forces me to do MyClass.doStringManipulation(myString) in order to call it.

What am I doing wrong?

Answer 1

In Scala there are no static methods: all methods are defined over an object, be it an instance of a class or a singleton, as the one you defined in your question.

As you correctly pointed out, by having a class and an object named in the same way in the same compilation unit you make the object a companion of the class, which means that the two have access to each others' private fields and methods, but this does mean they are available without specifying which object you are accessing.

What you want to do is either using the long form as mentioned (MyClass.doStringManipulation(myString)) or, if you think it makes sense, you can just import the method in the class' scope, as follows:

import MyClass.doStringManipulation

class MyClass {
  def apply(myRDD: RDD[String]): Unit = {
    val rdd2 = myRDD.map(doStringManipulation)
  }
}

object MyClass {
  private def doStringManipulation(myString: String): String = {
    ???
  }
}

As a side note, for the MyClass.apply method, you used the a notation which is going to disappear in the future:

// this is a shorthand for a method that returns `Unit` but is going to disappear
def method(parameter: Type) {
  // does things
}

// this means the same, but it's going to stay
// the `=` is enough, even without the explicit return type
// unless, that is, you want to force the method to discard the last value and return `Unit`
def method(parameter: Type): Unit = {
  // does things
}

Answer 2

You should follow scala's advice.

val rdd2 = myRDD.map(MyClass.doStringManipulation)