In Scala, is it bad, from the point of view of efficacy and speed of incremental compilers (sbt, sbt in Eclipse, IntelliJ), to use wildcard imports? Does it adversely affect the way these incremental compilers decide what to recompile in case of changes?
For instance, if for a new class X
, I would only need to import classes A
and B
(and not C
) from package pack
, do I get a penalty for writing this:
import pack._
instead of this?
import pack.{ A, B }
Assuming A
and B
have no dependency on C
, would X
be recompiled with the wildcard import and not with the more specific import when C
changes, or would the dependency tracking system be smart enough to realize that C
is not used by X
despite the wildcard import?
There's no performance impact to using the wildcard since the compiler will only import the classes required by your code.
Arraylist in the . class file. Without the wildcard(*), the directive tells the compiler to look for one specific file in the classpath. Thus, it is suffice to say that the import directive may influence the compile time but it does not affect the runtime of the program.
Java developers use the wildcard (*) in import statements to import all the classes in a particular package.
There is one tiny impact, but you probably won't notice it. The impact is that when there's a reference to symbol "Foo" the compiler must resolve "Foo" into a fully qualified name. The scope of where it can look for "Foo" is affected by wildcard imports. But that's all done in memory and you almost certainly won't notice such tiny differences in resolution speed unless you have something crazy like thousands of classes in one package.
Other than that, no impact. If you import pack._ and some arbitrary class in pack._ that you don't depend on changes then your file won't have to be recompiled.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With