Is there an implicit in this call to flatMap?

Question

In this code :

import java.io.File
def recursiveListFiles(f: File): Array[File] = {
  val these = f.listFiles
  these ++ these.filter(_.isDirectory).flatMap(recursiveListFiles)
}

taken from : How do I list all files in a subdirectory in scala?

Why does flatMap(recursiveListFiles) compile ? as recursiveListFiles accepts a File parameter ? Is file parameter implicitly passed to recursiveListFiles ?

Michael Zajac · Answer 1 · 2015-02-07T14:10:16.730

1

No because the expanded flatMap looks like:

flatMap(file => recursiveListFiles(file))

So each file in these is getting mapped to an Array[File], which gets flattened in flatMap. No implicit magic here (in the way that you're asking).

edited Feb 07 '15 at 14:10

answered Feb 06 '15 at 22:54

Michael Zajac

55,144
7
113
138

1

Actually, there is; `Array[File]` is converted to a `WrappedArray[File]` by an implicit, since obviously Java arrays don't inherit from `GenTraversableOnce`. – Alexey Romanov Feb 07 '15 at 04:07
But not in the way the OP is asking. – Michael Zajac Feb 07 '15 at 04:20
Yes, just a clarification in case someone misunderstands. – Alexey Romanov Feb 07 '15 at 06:51
1

Technically, there's also the implicit `CanBuildFrom` – Michael Zajac Feb 07 '15 at 13:19

score 0 · Answer 2 · answered Feb 06 '15 at 22:55

0

flatMap takes a function f: (A) ⇒ GenTraversableOnce[B] to return List[B].

In your case, it is taking recursiveListFiles which is a File ⇒ Array[File] to therefore return a List[File]. This resulting List[File] is then concatenated to these.

answered Feb 06 '15 at 22:55

Jean Logeart

52,687
11
83
118

score 0 · Accepted Answer · answered Feb 07 '15 at 15:04

Sort of. flatMap quite explicitly passes an argument to its own argument. This is the nature of a higher-order function -- you basically give it a callback, it calls the callback, and then it does something with the result. The only implicit thing happening is conversion of a method to a function type.

Any method can be converted to an equivalent function type. So def recursiveListFiles(f: File): Array[File] is equivalent to File => Array[File], which is great, because on an Array[File], you have flatMap[B](f: File => Array[B]): Array[B], and your method's function type fits perfectly: the type parameter B is chosen to be File.

As mentioned in another answer, you could explicitly create that function by doing:

these.filter(_.isDirectory).flatMap(file => recursiveListFiles(file)) or these.filter(_.isDirectory).flatMap(recursiveListFiles(_)) or these.filter(_.isDirectory).flatMap(recursiveListFiles _)

In more complex circumstances, you might need to work with one of those more verbose options, but in your case, no need to bother.

Is there an implicit in this call to flatMap?

3 Answers3