Scala use of underscore as an object placeholder

Question

Trying to wrap my head around the varying uses of the _. Right now I'm struggling with this example:

object Chapter9 extends App {
  FileMatcher.filesEnding(".scala").foreach(println)
}

object FileMatcher {
  private def filesHere = (new java.io.File(".")).listFiles

  private def filesMatching(matcher: String => Boolean) = {
    for (file <- filesHere; if matcher(file.getName))
    yield file
  }

  def filesEnding(query: String) =
    filesMatching(_.endsWith(query))

  def filesContaining(query: String) =
    filesMatching(_.contains(query))

  def filesRegex(query: String) =
    filesMatching(_.matches(query))
}

So clearly we want to abstract away the common work of looping/filtering/yielding for the varying types of matchers, makes sense to put it in a helper function.

I'm getting hung up on the _.endsWith part. My understanding is that this underscore (being the first and only one used in the method body) will be filled in by the first parameter, which in this case is query. I tried to test this theory by doing:

def filesEnding(query: String) = {
  println(_: String)
}

But the program doesn't print anything. So what is _ here? How does Scala know what object to to search for an endsWith method on?

It looks like from output of the program that somehow file gets filled in for this underscore but have no idea how. Maybe the underscore remains a "wildcard" until it is used inside filesMatching's body and by that point the nearest enclosing scope is the for and the first "parameterisfile`?

http://stackoverflow.com/questions/8000903/what-are-all-the-uses-of-an-underscore-in-scala — Zahiro Mor, May 08 '16 at 05:43
http://stackoverflow.com/questions/1025181/hidden-features-of-scala/1083523#1083523 — Zahiro Mor, May 08 '16 at 05:47
I can't tell whether to down-vote because the question doesn't make much sense, or whether it's a possible point of confusion for new users. There are many of them. — som-snytt, May 08 '16 at 06:10

jwvh · Accepted Answer · 2016-05-08T06:13:43.587

Look at the signature for filesMatching(). Notice that it takes one argument of type String => Boolean. So its argument is a function that itself take a String argument and turns it into a Boolean.

Now remember that an anonymous function often looks something like this:

{ x => /* do something with x */ }

And in cases where x is used only once, then that can be abbreviated to a single _. So, working backwards, this

filesMatching(_.endsWith(query))

can be rewritten as this

filesMatching(x => x.endsWith(query))

So the filesMatching() code has its argument, a function that takes a string (which in the anonymous function I've called x). That function, matcher, is invoked with the string file.getName to get a Boolean. That boolean value is tested in an if clause:

if matcher(file.getName)

TL;DR: The underscore is shorthand for the file.getName string.

Thank you - for some reason I was getting hung up on the underscore which I assumed would try to be "filled in" by `filesEnding`. I failed to connect the dots from the more verbose function literal being written in shorthand. Much appreciated. — diplosaurus, May 08 '16 at 08:40

score 0 · Answer 2 · edited May 23 '17 at 10:33

The canonical answer is What are all the uses of an underscore in Scala?

But -Xprint:parser shows

((x$1: String) => println((x$1: String)))

which is uninteresting except for the redundantly typed expression in the body of the function.

It doesn't seem to generate any extra code. The param is already a String.

I don't think your example compiles? Or I don't know what you're asking.

Explicit types can help debug when type of an anonymous function aren't inferred as you wish.

Edit: I gave this a try:

object Chapter9 extends App {
  FileMatcher.filesEnding(".scala").foreach(println)
}

object FileMatcher {
  private def filesHere = (new java.io.File(".")).listFiles

  private def filesMatching(matcher: String => Boolean) = {
    for (file <- filesHere; if matcher(file.getName))
    yield file
  }
def filesEnding(query: String) = {
  println(_: String)
}
}

An expression with an underscore as an anonymous function needs its expected type to tell it what type the underscore is, unless explicitly annotated as you did. But that is not common usage.

Instead of (_: Int) * 2, (i: Int) => i * 2, but that's a style question.

IntelliJ complains about the `FileMatcher` forward reference, but other than that it compiles just fine. — jwvh, May 08 '16 at 06:09

Scala use of underscore as an object placeholder

2 Answers2