A trait for setters or stupid, non-cascading objects in general

gistfile1.scala

// A simple trait:

trait CascadingActions {

  implicit def tToActioneerT[T](t: T) = Actioneer(t)

  case class Actioneer[T](tee: T) {
    def withAction(action: (T => Unit)): T = 
      withActions(action)
    def withActions(actions: (T => Unit)*): T = {
      actions foreach (_ (tee))
      tee
    }
  }
}

// Yet with nice properties when you're dealing with
// an object that take a lot of setters, and you really
// wish it supported cascading:

def newStupid = {
  val stupidTemporaryVariable = new StupidObject
  stupidTemporaryVariable setSillyProperty "foo"
  stupidTemporaryVariable setAnotherOne "bar"
  stupidTemporaryVariable // mention it AGAIN here, just so it gets returned
}

// But instead:

def newStupid = new StupidObject withActions(
  _ setSillyProperty "foo",
  _ setAnotherOne "bar")

// Wow!

That works too, although I think you mean

def returning[T](x: T)(f: T => Unit) = { f(x); x }

and for extra credit:

def returning[T](x: T)(fs: (T => Unit)*) = { fs foreach (_(x)); x }

or something.

@retronym: yes, that avoids the issue with StupidObject being final, and it doesn't introduce a new subclass. However, it is no longer a single expression, but is back to being a sequence of statements, the last one being the expression returned:

def newStupid {
    val nso = new StupidObject;
    {
        import nso._
        sillyProperty = "foo"
        anotherOne = "bar"
    }
    nso // ... and an expression at the end
}

re "although I think you mean..." I meant exactly what I wrote; unfortunately the helpful markup processor betrayed me. If you look at the raw text you will see the untainted vision.