One keyword, and your own namespace

Two steps in, the library from step one has a shape: three definitions, two of them exported, all of their types written down. Bringing that into a file of your own takes one line, and the line says how much of it you want.

module samples/modules

# R-1: `import` names a module and loads it at most once, so the import graph
# is a DAG rather than textual inclusion. Bare, it brings the module into
# scope under its qualified name and nothing more: after `import app/greeter`
# alone, the module's names are reachable only as `App::Greeter::Greet` and
# `App::Greeter.polite`.
import app/greeter::*
import app/formal::{address}

import names a module and loads it at most once, so the import graph is a DAG rather than textual inclusion. Written bare, import app/greeter gives you the module under its qualified name and nothing more: polite is App::Greeter.polite and nothing shorter.

What you write after the path is what shortens it. ::* brings every exported name, ::{...} brings the ones listed, and the library does not get a say. That is the whole of R-2b, and it is a smaller idea than it sounds: a module's names reach your file only through a line in your file, and the glob is spelled out, so "every name" is visible on the line where it happens.

The list on the second line is the interesting one. app/greeter and app/formal both export title, so taking both whole would make every bare title in the file ambiguous. It takes exactly address from the second module and leaves that module's title behind. That list is a repair rather than mere tidiness.

Where the ambiguity gets reported#

Widen that second import to import app/formal::* and nothing happens. Two modules exporting one name is not a mistake. The error arrives later, at the first bare title you write, because that is the first thing that could mean either.

Then add your own def title to the file and it compiles again. A local definition beats an imported one, silently. That silence is deliberate: it is what stops a library breaking your build by adding an export.

The wall a qualified name does not climb#

Qualifying a name is not a way around the import. Call App::Greeter.polite from a file that never imported app/greeter, because some other file in the program did, and the compiler does not let the rest of the program's imports leak into yours:

Error: `App::Greeter` is not imported here — it is in the program only because
some other file imported it. Add an import in this file, or have a module this
file imports re-export it with `pub import` (SPEC.md R-1)

It names the rule and both ways out. The rules are new, so the compiler teaches them at the moment they are broken, which is the only place a person is actually paying attention.

Now forget the names#

Do it the other way around. Import the module bare, and call one of its exported functions the way every other language would let you.