Hiding closure boilerplate with macros?

Question

Given an example closure, which in this case returns the number of words in a string (with an additional arbitrary operator).

val myfunc = (s: String) => Option(s).map(_.split(" ").size).filter(_ >= 2)

Is there a way I can hide some of the boilerplate such that I can write:

val myfunc = given[String].map(_.split(" ").size).filter(_ >= 2)

Answer 1

If you can live with two parentheses and an underscore extra, you don't need macros for that:

class Given[A] {
  def apply[B](f: Option[A] => B): A => B = (a: A) => f(Option(a))
}
def given[A] = new Given[A]

In action:

scala> val myfunc = given[String](_.map(_.split(" ").size).filter(_ >= 2))
myfunc: String => Option[Int] = <function1>

scala> List("salmon cod herring","tuna").map(myfunc)
res4: List[Option[Int]] = List(Some(3), None)

Answer 2

I doubt. A macro replaces the function call it is in with something that type checks. So, what would you replace given[String] with in your example? If you replaced it with (s: String) => Option(s), you'd get this:

((s: String) => Option(s)).map(_.split(" ").size).filter(_ >= 2)

Which doesn't work like you want. You want the whole line to be changed, which is not going to happen.