Shortcut for using X: X, ...

[mkitti]

In code for a library with many dependencies, it is advantageous to explicitly declare from where all symbols are being added to the local namespace. This helps to avoid ambiguity issues when multiple packages export the same symbol. For example, a number of packages (e.g. Plots.jl, GR.jl, Makie.jl) export the symbol plot.

Currently, if one wanted to just load a package and other symbols, including the package name itself, a Julia programmer has to repeat the package name as follows.

using LinearAlgebra: LinearAlgebra, I

LinearAlgebra.svd(I(5))

Alternatively, they could use the import statement together with using. Again, this results in repetition.

using LinearAlgebra: I
import LinearAlgebra

LinearAlgebra.svd(I(5))

To make it easier to import the package as a symbol as well as other symbols within the package, I propose we allow . to be a shortcut for the package as follows.

using LinearAlgebra: ., I

LinearAlgebra.svd(I(5))

Currently the first line results in a syntax error.

julia> using LinearAlgebra: ., I
ERROR: syntax: unexpected ","

[mikmoore]

How devastating would it be if using X: Y always brought X into scope? Are there situations where one would want to using stuff from a module but couldn't stand to have X brought into scope? It seems a little weird that

julia> using LinearAlgebra: norm

julia> norm([1])
1.0

julia> LinearAlgebra.norm([1])
ERROR: UndefVarError: `LinearAlgebra` not defined

I.e., that I can using a function from a module but then can't use its qualified name. I was going to suggest a benefit of not bringing X into scope is that I literally cannot access methods other than those explicitly using'd, but that isn't true:

julia> parentmodule(norm).eigvals([1;;])
1-element Vector{Float64}:
 1.0

[ericphanson]

One could contrive a case, like

module Outer1
    module A
    useful_func() = 1
    where = "I'm in Outer1"
    end # A
end # Outer1

module Outer2
    export A
    module A
    where = "I'm in Outer2"
    end # A
end # Outer2

using .Outer2
using .Outer1.A: useful_func

A.where

where currently returns "I'm in Outer2". If .Outer1.A exported A, then there would be a clash.

I'm not sure if this happens much in practice though.