6.4 Import

modifier	=	as id
	\|	as ~none
	\|	open open_decl
	\|	expose expose_decl
	\|	rename rename_decl
	\|	only only_decl
	\|	except except_decl
	\|	meta meta_decl
	\|	meta_label
	\|	only_meta meta_decl
	\|	only_meta_label
	\|	only_space only_space_decl
	\|	except_space except_space_decl
	\|	other_modifier

Imports into the enclosing module or block. An import form with a single immediate import_clause is a shorthand for an import form that has a block containing the single import_clause.

The import_clause variant import_item or import_item: modifier; ... are the canonical forms. The other import_clause forms are converted into a canonical form:

import_item modifier is the same as import_item: modifier, where modifier might include a block argument. This form is handy when only one modifier is needed.
import_item modifier: modifier; ... is the same as import_item: modifier; modifier; ... where the initial modifier does not accept a block argument. This form is especially handy when the initial modifier is open or as id and additional modifiers are needed.
modifier: import_clause; ... is the same as the sequence of import_clauses with modifier add to the end of each import_clause. This form is especialy handy when modifier is meta.

An import_item is typically a module_path, but it can be a juxtaposed combination of parsed module_paths, or it can be another import clause form defined with impo.macro.

By default, each clause with a module_path binds a prefix name that is derived from the module_path’s last element. Imports from the module are then accessed using the prefix, ., and the provided-provided name. The as modifier with an identifier supplies a prefix to use, instead, while the as modifier with ~none indicates that only exposed names should be bound.

A module_path clause can be be adjusted through one or more modifiers. The set of modifiers is extensible, but includes as, rename, and expose.

A module_path references a module in one of several possible forms:

collection_module_path: refers to an installed collection library, where the / operator acts as a path separator. Each id in the path is constrained to contain only characters allowed in a string module path, with the additional constraint that . is disallowed. A module path of this form refers to a file with the .rhm suffix.
string: refers to a module using string as a relative path. The string can contain only the characters a-z, A-Z, 0-9, -, +, _, and /, ., and %. Furthermore, a % is allowed only when followed by two lowercase hexadecimal digits, and the digits must form a number that is not the ASCII value of a letter, digit, -, +, or _.
lib(string): refers to an installed collection library, where string is the library name. The same constraints apply to string as when string is used as a relative path by itself, with additional constraints: at least one / is required, and . and .. directory indicators are disallowed. When string does not end with a file suffix, .rhm is added.
file(string): refers to a file through a platform-specific path with no constraints on string.
module_path ! id: refers to submodule of another module. The submodule name id is used as the default import prefix.
.id: refers to a namespace id, which might be predefined like List, or might be bound by namespace or as a prefix with import.
module_path.id: a shorthand for importing only id from module_path path and then importing with .id. The last id in a dotted sequence is allowed to be an export that is not a namespace, in which case the dotted form is a shorthand for exposing just id from module_path. This form can be modified by meta, meta_label, only_meta, or only_meta_label only when a single dot is used and module_path does not refer to a namespace.
module_path.(op): the same shorthand, but for operators.
self: refers to the enclosing module itself, usually combined with ! to refer to a submodule of the enclosing module.
parent: refers to the parent of the enclosing submodule, sometimes combined with ! to refer to a sibling submodule or with additional !s to reach an ancestor of the enclsoing submodule.

import

id / collection_module_path

As a module-path operator, combines id and collection_module_path to build a longer collection-based module path.

import

. id

import

collection_module_path . id

import

collection_module_path . (op)

As an module-path operator, a prefix . refers to an import prefix or a namespace id in the enclosing environment, and an infix . refers to an id or op provided by collection_module_path.

import

lib(string)

Refers to an installed collection library, where string is the library name. See import for more information.

import

file(string)

Refers to a file through a platform-specific path, where string is the library name. See import for more information.

import

module_path ! id

Refers to a submodule name id of the module referenced by module_path. See import for more information.

import

self ! id

import

parent

import

parent ! ...

The form self!id refers to submodule named id of the enclosing module. Additional uses of ! refer to more deepely nested submodules within that one.

In an interactive context, such as a read-eval-print loop (REPL), self!id refers to a module declaraed interactively with name id.

The form parent refers to the parent of an enclosing submodule. A parent form may be followed by !id to access a submodule of the enclosing module (i.e., a sibling submodule). When additional additional ! operators are used before an id or without a subsequent id, each ! refers to an enclosing parent, thus reaching an ancestor module.

See import for more information.

import modifier

as id

import modifier

as ~none

Modifies an import clause to bind the prefix id, used to access non-exposed imports, instead of inferring a prefix identifier from the module name. When as is followed by ~none instead of id, then no prefix is bound for the import (so only exposed identifiers are bound).

import modifier

open

import modifier

open ~scope_like id

Modifies an import clause so that no prefix (normally based on the module name) is bound, and all imports are implicitly exposed. Contrast with as ~none, which also binds no prefix, but binds only names that are speficially exposed.

If ~scope_like id is specified, then the name part of id does not matter, but its scopes are used for the exposed bindings. Otherwise, the scopes for each exposed binding is defived from the module or namespace specification that this open form modifies.

import modifier

expose id_or_rename_as

import modifier

expose:

id_or_rename_as

...

id_or_rename_as	=	id
	\|	rename_as

Modifies an import clause so that the listed ids are imported without a prefix. The exposed ids remain accessible though the import’s prefix, too.

If as is used, the id is renamed in addition to being exposed, or in other words, it behaves like a combination of rename and expose.

import modifier

import modifier

...

Modifies an import clause so that local_id is used in place of the imported id name id. The new name local_id applies to modifiers after the rename modifier.

import modifier

only id

import modifier

only:

id ...

...

Modifies an import clause so that only the listed ids are imported.

import modifier

except id

import modifier

except:

id ...

...

Modifies an import clause so that the listed ids are not imported.

import modifier

1	Rhombus Essentials
2	Collections and Iteration
3	Syntax Objects and Macros
4	Classes and Interfaces
5	Static Information and Binding
6	Core Reference
7	Meta and Macros Reference
8	Rhombus Static by Default
9	Libraries
10	Naming Conventions

6.1	General Forms
6.2	Definitions
6.3	Namespaces
6.4	Import
6.5	Export
6.6	Functions
6.7	Operators
6.8	Classes and Interfaces
6.9	Veneers
6.10	Mutable Variables and Assignment
6.11	Repetitions
6.12	Block
6.13	Conditionals
6.14	Matching
6.15	Iteration
6.16	Recursion
6.17	Context Parameters
6.18	Exceptions
6.19	Continuations
6.20	Implicit Forms
6.21	Static and Dynamic Lookup
6.22	Modules and Submodules
6.23	Booleans
6.24	Numbers
6.25	Characters
6.26	Strings
6.27	Keywords
6.28	Symbols
6.29	Byte Strings
6.30	Lists
6.31	Pairs and Pair Lists
6.32	Mutable Lists
6.33	Arrays
6.34	Maps
6.35	Sets
6.36	Boxes
6.37	Indexables
6.38	Listables
6.39	Sequences
6.40	Appendables
6.41	Comparables
6.42	Paths
6.43	Source Locations
6.44	Void
6.45	Equality
6.46	Dot
6.47	Multiple Values
6.48	Annotations
6.49	Enumerations
6.50	Input and Output
6.51	Eval
6.52	Syntax Objects
6.53	Syntax Classes
6.54	Simple Expression Macros
6.55	Unit Testing