Question

Clojure offers a macro called doto that takes its argument and a list of functions and essentially calls each function, prepending the (evaluated) argument:

(doto (new java.util.HashMap) (.put "a" 1) (.put "b" 2))
-> {a=1, b=2}

Is there some way to implement something similar in Scala? I envision something with the following form:

val something =
  doto(Something.getInstance) {
    x()
    y()
    z()
  }

which will be equivalent to

val something = Something.getInstance
something.x()
something.y()
something.z()

Might it be possible using scala.util.DynamicVariables?

Note that with factory methods, like Something.getInstance, it is not possible to use the common Scala pattern

val something =
  new Something {
    x()
    y()
    z()
  }

Answer 1

I don’t think there is such a thing built-in in the library but you can mimic it quite easily:

def doto[A](target: A)(calls: (A => A)*) =
  calls.foldLeft(target) {case (res, f) => f(res)}

Usage:

scala> doto(Map.empty[String, Int])(_ + ("a" -> 1), _ + ("b" ->2))
res0: Map[String,Int] = Map(a -> 1, b -> 2)

scala> doto(Map.empty[String, Int])(List(_ + ("a" -> 1), _ - "a", _ + ("b" -> 2)))
res10: Map[String,Int] = Map(b -> 2)

Of course, it works as long as your function returns the proper type. In your case, if the function has only side effects (which is not so “scalaish”), you can change doto and use foreach instead of foldLeft:

def doto[A](target: A)(calls: (A => Unit)*) =
  calls foreach {_(target)}

Usage:

scala> import collection.mutable.{Map => M}
import collection.mutable.{Map=>M}

scala> val x = M.empty[String, Int]
x: scala.collection.mutable.Map[String,Int] = Map()

scala> doto(x)(_ += ("a" -> 1), _ += ("a" -> 2))

scala> x
res16: scala.collection.mutable.Map[String,Int] = Map(a -> 2)