CODEWITHSUNDEEP
scalafunctional-programming
sksamuel
sksamuel

Reputation: 16387

Scala Objects and the rise of singletons

General style question.

As I become better at writing functional code, more of my methods are becoming pure functions. I find that lots of my "classes" (in the loose sense of a container of code) are becoming state free. Therefore I make them objects instead of classes as there is no need to instantiate them.

Now in the Java world, having a class full of "static" methods would seem rather odd, and is generally only used for "helper" classes, like you see with Guava and Commons-* and so on.

So my question is, in the Scala world, is having lots of logic inside "objects" and not "classes" quite normal, or is there another preferred idiom.

Upvotes: 20

Views: 2750

Answers (3)

kiritsuku
kiritsuku

Reputation: 53358

Yes, I would say it is normal.

For most of my classes I create a companion object to handle some initialization/validation logic there. For example instead of throwing an exception if validation of parameters fails in a constructor it is possible to return an Option or an Either in the companion objects apply-method:

class X(val x: Int) {
  require(x >= 0)
}
// ==>
object X {
  def apply(x: Int): Option[X] =
    if (x < 0) None else Some(new X(x))
}
class X private (val x: Int)

In the companion object one can add a lot of additional logic, such as a cache for immutable objects.

objects are also good for sending signals between instances if there is no need to also send messages:

object X {
  def doSomething(s: String) = ???
}
case class C(s: String)

class A extends Actor {
  var calculateLater: String = ""
  def receive = {
    case X => X.doSomething(s)
    case C(s) => calculateLater = s
  }
}

Another use case for objects is to reduce the scope of elements:

// traits with lots of members
trait A
trait B
trait C

trait Trait {

  def validate(s: String) = {
    import validator._
    // use logic of validator
  }

  private object validator extends A with B with C {
    // all members of A, B and C are visible here
  }
}

class Class extends Trait {
  // no unnecessary members and name conflicts here
}

Upvotes: 2

Tesseract
Tesseract

Reputation: 8139

You can also use package objects e.g. take a look at the scala.math package object here https://lampsvn.epfl.ch/trac/scala/browser/scala/tags/R_2_9_1_final/src//library/scala/math/package.scala

Upvotes: 4

Paolo Falabella
Paolo Falabella

Reputation: 25844

As you mention in your title, objects are singleton classes, not classes with static methods as you mention in the text of your question.

And there are a few things that make scala objects better than both static AND singletons in java-world, so it is quite "normal" to use them in scala.

For one thing, unlike static methods, object methods are polymorphic, so you can easily inject objects as dependencies:

scala> trait Quack {def quack="quack"}
defined trait Quack

scala> class Duck extends Quack
defined class Duck

scala> object Quacker extends Quack {override def quack="QUAACK"}
defined module Quacker

// MakeItQuack expects something implementing Quack
scala> def MakeItQuack(q: Quack) = q.quack
MakeItQuack: (q: Quack)java.lang.String

// ...it can be a class
scala> MakeItQuack(new Duck)
res0: java.lang.String = quack

// ...or it can be an object
scala> MakeItQuack(Quacker)
res1: java.lang.String = QUAACK

This makes them usable without tight coupling and without promoting global state (which are two of the issues generally attributed to both static methods and singletons).

Then there's the fact that they do away with all the boilerplate that makes singletons so ugly and unidiomatic-looking in java. This is an often overlooked point, in my opinion, and part of what makes singletons so frowned upon in java even when they are stateless and not used as global state.

Also, the boilerplate you have to repeat in all java singletons gives the class two responsibilities: ensuring there's only one instance of itself and doing whatever it's supposed to do. The fact that scala has a declarative way of specifying that something is a singleton relieves the class and the programmer from breaking the single responsibility principle. In scala you know an object is a singleton and you can just reason about what it does.

Upvotes: 16

Related Questions