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 its 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?

Nothing is "wrong". This is the correct way to access object's methods: `ObjectName.method`. Alternatively, you can import it into names space by putting this somewhere in scope (or at the top of the file): `import MyClass._`. — Dima, Jan 09 '18 at 23:39
It's interesting that the import of MyClass._ is needed since MyClass is defined within the file. — B. Smith, Jan 09 '18 at 23:45
`MyClass` is defined within the file, so you do not need to import it (if it was in a different package, you would also need `import that.package.MyClass`). But `doStringManipulation` is defined inside `MyClass`, so you do need to import that. You could also just do `import MyClass.doStringManipulation`. `_` is a wildcard, that just imports everything. — Dima, Jan 10 '18 at 11:46

score 35 · Accepted Answer · edited Jul 13 '22 at 14:46

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 not 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
}

score 3 · Answer 2 · answered Jan 09 '18 at 23:39

3

You should follow scala's advice.

val rdd2 = myRDD.map(MyClass.doStringManipulation)

answered Jan 09 '18 at 23:39

Joaquín Bucca

1,060
8
11

score 2 · Answer 3 · answered Aug 19 '20 at 09:00

2

Write this inside the class then it will work as expected.

import MyClass._

answered Aug 19 '20 at 09:00

Shubham Gupta

317
3
5

How to qualify methods as static in Scala?

3 Answers3

Linked