Modules

Jiang currently uses source files as modules. Imports connect source files, and imported APIs stay under a module namespace instead of being flattened into the current file.

File Imports

import "math.jiang";

The default module name comes from the file name. After importing math.jiang, access public declarations through math.Name:

Int value = math.add(1, 2);

Import Aliases

Use an alias when the file name is not the module name you want:

alias m = import "utils/math.jiang";

Int value = m.add(1, 2);

The alias names the target module namespace. It does not flatten imported declarations into the current module.

File Paths

A quoted import is a file path import:

alias math = import "utils/math.jiang";

File paths are interpreted relative to the importing source file. Write the full path; imports do not automatically add .jiang or search for a directory entry.

Quoted file imports are only for files inside the current package. To import another package, declare it in package.jiang and use an unquoted package import.

Visibility

Declarations that should be visible to other modules use public:

public struct Point {
    Int x;
    Int y;
}

public Int distance(Point point) {
    return point.x + point.y;
}

public const Int default_limit = 1024;

Declarations without public are module-local.

Extensions follow the same import visibility rule. An extension in another module does not become active just because the target type is visible; the consumer must import the module that defines the extension. Extensions meant for other modules should be written as public extend.

public const is also part of the module API. Consumers can read scalar constants and fields on const structs through the module namespace:

alias cfg = import "config.jiang";

Int value = cfg.default_limit;

Re-exports

public alias name = import ...; imports a module for local use and re-exports that namespace as part of the current module API:

public alias leaf = import "leaf.jiang";

This does not flatten imported declarations:

alias middle = import "middle.jiang";

Int value = middle.leaf.answer();

Alias

Use alias to give a type or an existing symbol another name:

alias Byte = UInt8;
alias NameBytes = UInt8[]&;

alias add = math.add;

If the right-hand side resolves to an existing namespace, type, value, or member symbol, the alias is bound in that same name domain. If it does not resolve to an existing symbol, the right-hand side is treated as type syntax and must be a valid type.

public alias re-exports a public symbol through the current module API:

public alias answer = math.add;

For a function target, the alias keeps the target’s public overload family. Calls use normal overload resolution in the target namespace, and private functions with the same name are not re-exported.