Customize root imports in Scala source files

[odersky]

Scala automatically imports all of Predef, the scala package, and the java.lang package. Sometimes that's not what we want.
Scala currently offers some -Y options to customize imports on the command line. I think this is bad style, the meaning of a piece of source code should be self contained.

I propose here a way to support root import customization it in the source code itself. We can always add new imports so the only question is how to suppress and customize the three existing root imports. Right now we can do this in Scala 3 for Predef only:

import Predef.{summon, assert}

This would only import summon and assert from Predef and leave the rest alone.

We should allow the same for the other two root imports, scala, and java.lang. There's also the question of how to suppress a root import entirely. We can do this in a roundabout way for Predef, like this:

import Predef.summon as _

This imports just summon but it renames it to _, which means it does not import summon in the end. Cute, but we should be able to express it much clearer like this:

import Predef.{}

All that's needed is allowing empty sequences of selectors in braces. In the system proposed so far, these would be useful only for root imports.

There's also the question whether we want to generalize this for all imports, allowing overriding outer or implicit imports in some inner scope. If it is to be that general, then I believe we need a syntactic marker for this "overriding" behavior of imports. My suggestion is:

override import Predef.{}

But if it is just for root imports, we might not need that added piece of syntax. On the other hand, maybe it would be good even then since it makes it clearer what goes on.

[odersky]

I should say from an implementation perspective, all this would be very easy to implement. We already have the necessary mechanism in place for Predef imports.

[EugeneFlesselle]

Allowing overriding outer or implicit imports in some inner scope could also be interesting for renaming imports.

Right now. one can already do

object Outer:
  import scala.deriving.Mirror

  val _: Mirror = ???

  object Inner:
    import scala.deriving.Mirror as M
    val _: M = ??? // Ok
    val _: Mirror = ??? // Also ok

But there is no way to remove the initial import (named Mirror) in the scope of Inner.
Perhaps this could also be addressed by adding override to the inner import.

[som-snytt]

An alternative is to support scala-cli directives or pragmas.

//> using options -Yno-imports -Yno-predef

Once the offending "root import" is turned off, imports in source are not magic.

The other angle is that (at least in Scala 2), the in-source import must be "processed" before code that relies on it; a method with a local import that attempts to filter root imports might be typechecked "too late". Of course it is possible to warn about that edge case. But directives have the advantage that they are restricted (to the file header) and syntactically boring.

As a refinement, since people have always complained that you never know what you're getting in java.lang (let alone the scala namespace), it becomes possible to enforce in source:

//> using options -java-output-version:8

which is the dotty alias for -release to mean "target JDK version for input classes and output class file format".

There is another ticket for "conditional compilation". An alternative to directives, which are "free-form", would be a syntax that just enforces the requirement (that root imports are turned off or the JDK API is version 8) without specifying the mechanism. (For the current implementation of -release, which determines the class path, all it could do is fail if the condition is not met.)

The other available syntax is language imports.

Also, maybe a "local import" could be treated in the usual way:

println("hello, world") // ok
def m() =
  import language.noPredef
  println("hello, world") // not ok

But the proposed syntax for turning off arbitrary imports in scope is more powerful.

def m() =
  override import cats.syntax.{}
  // clean slate

Woe betide the "organize imports" widgets in the tooling community.

[dwijnand]

Very much tongue-in-cheek, if we want the opposite of import java.lang.* do we want... export java.lang.*? 😄

I almost feel like import java.lang.* as _ implies "don't import any of them". But import Predef.{} looks completely fine too.

Speaking of braces, it would be nice to be able to do import util.{ *, Spans.NoSpan }, like in Rust. Perhaps I can nerd-snipe @kyouko-taiga into this fight. 🙂

[kyouko-taiga]

I'm usually easy to nerd-snipe, but in this particular case I'm afraid I'm not familiar enough with Rust's imports to have any opinion. Besides, I'm not a very big fan of selected imports, as I find them noisy.

As far as I can tell, OP's proposal looks a little like the way selected imports work in Swift (which I do know):

import var Darwin.stderr // Imports only `stderr` from `Darwin`

But the way modules work in Swift is quite different from the way packages work in Scala and, AFAIK, crates in Rust. We typically don't use deep hierarchies of namespaces and use the above selected imports very sparingly.

[som-snytt]

I see we've been doing it all wrong. Instead of "organize imports", we need a "minimize imports" feature which would offer to refactor not the imports but the module, into units that would minimize imports of any kind.