Modular C
Importing and abbreviating
#pragma CMOD import [ abbrev = ] path
#pragma CMOD context [ abbrev = ] opening closing [ path ]

Identifiers that are exported by other modules are usable as such, no extra Modular C feature would be required. The import directive comes into play when we want to shorten long module paths or when we want Code insertion.

The abbreviation feature is in fact quite simple, and similar to the abbreviation pair for the module name proj◼arith◼pair, see Make identifiers visible. Writing

#pragma module proj◼arith◼compute
#pragma import p2 = proj◼arith◼pair
double sum(C◼size n, p2 A[n]) {
double accu = 0;
for (C◼size i = 0; i < n; ++i) {
accu += p2◼add(A[i]);
}
return accu;
}

is similar to

#pragma module proj◼arith◼compute
double sum(C◼size n, proj◼arith◼pair A[n]) {
double accu = 0;
for (C◼size i = 0; i < n; ++i) {
accu += proj◼arith◼pair◼add(A[i]);
}
return accu;
}

That is, using the abbreviation p2 with the import lets us write shorter and more readable code. Also, it enables us to modify the whole import easily and to switch to a different module with the same interface.

Remarks
We can use any non-composed name for the abbreviation, as long as it doesn't conflict with other local names that we are using.
Using a composed module name implies that all "parent" modules are implicitly imported. In example above, modules proj and proj◼arith are imported implicitly.
Import of Modular C modules is never purely textual. To be imported, a module has always to be compiled, such that the importer may refer to that compiled information about the module.